@ohif/app 3.12.0-beta.99 → 3.12.0

package/dist/{1903.bundle.dc5248f7cb6ba1dc1072.js → 3081.bundle.41838985e0472851eadb.js}

@@ -1,5 +1,5 @@
 "use strict";
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[1903],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[3081],{
 
 /***/ 38007:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
@@ -25,8 +25,8 @@ var useSegmentations = __webpack_require__(73421);
 var useViewportSegmentations = __webpack_require__(79063);
 // EXTERNAL MODULE: ../../../node_modules/react/index.js
 var react = __webpack_require__(86326);
-// EXTERNAL MODULE: ../../ui-next/src/index.ts + 3073 modules
-var src = __webpack_require__(1246);
+// EXTERNAL MODULE: ../../ui-next/src/index.ts + 3075 modules
+var src = __webpack_require__(12517);
 ;// ../../../extensions/cornerstone/src/hooks/useViewportHover.ts
 
 
@@ -117,7 +117,7 @@ var useViewportRendering = __webpack_require__(47488);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   c: () => (/* binding */ useActiveViewportSegmentationRepresentations)
 /* harmony export */ });
-/* harmony import */ var _ohif_ui_next__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1246);
+/* harmony import */ var _ohif_ui_next__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12517);
 /* harmony import */ var _useViewportSegmentations__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(79063);
 
 
@@ -250,6 +250,8 @@ function useMeasurementTracking({
 /* harmony import */ var lodash_debounce__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(62051);
 /* harmony import */ var lodash_debounce__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(lodash_debounce__WEBPACK_IMPORTED_MODULE_1__);
 /* harmony import */ var _ohif_core__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(42356);
+/* harmony import */ var _ohif_i18n__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(89010);
+
 
 
 
@@ -268,7 +270,7 @@ function mapMeasurementToDisplay(measurement, displaySetService) {
     displayText: baseDisplayText
   } = measurement;
   const firstSite = findingSites?.[0];
-  const label = baseLabel || finding?.text || firstSite?.text || '(empty)';
+  const label = baseLabel || finding?.text || firstSite?.text || _ohif_i18n__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.t('MeasurementTable:empty');
 
   // Initialize displayText with the structure used in Length.ts and CobbAngle.ts
   const displayText = {
@@ -496,8 +498,8 @@ __webpack_require__.d(__webpack_exports__, {
 var react = __webpack_require__(86326);
 // EXTERNAL MODULE: ../../core/src/index.ts + 69 modules
 var src = __webpack_require__(42356);
-// EXTERNAL MODULE: ../../ui-next/src/index.ts + 3073 modules
-var ui_next_src = __webpack_require__(1246);
+// EXTERNAL MODULE: ../../ui-next/src/index.ts + 3075 modules
+var ui_next_src = __webpack_require__(12517);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
 var esm = __webpack_require__(15327);
 ;// ../../../extensions/cornerstone/src/components/ViewportDataOverlaySettingMenu/utils.ts
@@ -1657,7 +1659,7 @@ function useViewportSegmentations({
 
 /***/ }),
 
-/***/ 71903:
+/***/ 63081:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -6985,8 +6987,8 @@ var useLutPresentationStore = __webpack_require__(10182);
 var usePositionPresentationStore = __webpack_require__(44646);
 // EXTERNAL MODULE: ../../../extensions/cornerstone/src/stores/useSegmentationPresentationStore.ts + 1 modules
 var useSegmentationPresentationStore = __webpack_require__(2847);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/index.js + 46 modules
-var esm_utilities = __webpack_require__(33592);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/index.js + 47 modules
+var esm_utilities = __webpack_require__(85343);
 ;// ../../../extensions/cornerstone/src/utils/initWebWorkerProgressHandler.ts
 
 
@@ -7471,8 +7473,8 @@ function _showCPURenderingModal(uiModalService, hangingProtocolService) {
     inheritsFrom: 'ohif.overlayItem.instanceNumber'
   }]
 });
-// EXTERNAL MODULE: ../../ui-next/src/index.ts + 3073 modules
-var ui_next_src = __webpack_require__(1246);
+// EXTERNAL MODULE: ../../ui-next/src/index.ts + 3075 modules
+var ui_next_src = __webpack_require__(12517);
 // EXTERNAL MODULE: ../../../node_modules/react-i18next/dist/es/index.js + 15 modules
 var es = __webpack_require__(99993);
 ;// ../../../extensions/cornerstone/src/components/ExportSegmentationSubMenuItem.tsx
@@ -7488,7 +7490,7 @@ const ExportSegmentationSubMenuItem = ({
 }) => {
   const {
     t
-  } = (0,es/* useTranslation */.Bd)('SegmentationTable');
+  } = (0,es/* useTranslation */.Bd)('SegmentationPanel');
   return /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuSub */.lvB, null, /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuSubTrigger */.nVd, {
     className: "pl-1"
   }, /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.Export, {
@@ -7555,7 +7557,7 @@ const CustomDropdownMenuContent = () => {
   } = (0,src/* useSystem */.Jg)();
   const {
     t
-  } = (0,es/* useTranslation */.Bd)('SegmentationTable');
+  } = (0,es/* useTranslation */.Bd)('SegmentationPanel');
   const {
     onSegmentationAdd,
     onSegmentationRemoveFromViewport,
@@ -7564,7 +7566,7 @@ const CustomDropdownMenuContent = () => {
     exportOptions,
     activeSegmentation,
     activeSegmentationId,
-    segmentationRepresentationType,
+    segmentationRepresentationTypes,
     disableEditing
   } = (0,ui_next_src/* useSegmentationTableContext */.dQ$)('CustomDropdownMenu');
 
@@ -7623,7 +7625,7 @@ const CustomDropdownMenuContent = () => {
   }, !disableEditing && /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuItem */._26, {
     onClick: () => onSegmentationAdd({
       segmentationId,
-      segmentationRepresentationType
+      segmentationRepresentationType: segmentationRepresentationTypes?.[0]
     })
   }, /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.Add, {
     className: "text-foreground"
@@ -7643,7 +7645,7 @@ const CustomDropdownMenuContent = () => {
     className: "pl-2"
   }, t('Rename'))), /*#__PURE__*/react.createElement(ExportSegmentationSubMenuItem, {
     segmentationId: segmentationId,
-    segmentationRepresentationType: segmentationRepresentationType,
+    segmentationRepresentationType: segmentationRepresentationTypes?.[0],
     allowExport: allowExport,
     actions: actions
   }), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuSeparator */.mBJ, null), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuItem */._26, {
@@ -7677,7 +7679,7 @@ const CustomSegmentStatisticsHeader = ({
   } = servicesManager.services;
   const {
     t
-  } = (0,es/* useTranslation */.Bd)('SegmentationTable');
+  } = (0,es/* useTranslation */.Bd)('SegmentationPanel');
   const segmentation = segmentationService.getSegmentation(segmentationId);
   const segment = segmentation.segments[segmentIndex];
   const cachedStats = segment.cachedStats;
@@ -7770,10 +7772,14 @@ const CustomSegmentStatisticsHeader = ({
 
 
 
+
 function SegmentationToolConfig() {
   const {
     commandsManager
   } = (0,src/* useSystem */.Jg)();
+  const {
+    t
+  } = (0,es/* useTranslation */.Bd)('SegmentationPanel');
 
   // Get initial states based on current configuration
   const [previewEdits, setPreviewEdits] = (0,react.useState)(false);
@@ -7813,28 +7819,28 @@ function SegmentationToolConfig() {
     onCheckedChange: handlePreviewEditsChange
   }), /*#__PURE__*/react.createElement("span", {
     className: "text-foreground text-base"
-  }, "Preview edits before creating")), /*#__PURE__*/react.createElement("div", {
+  }, t('Preview edits before creating'))), /*#__PURE__*/react.createElement("div", {
     className: "flex items-center gap-2"
   }, /*#__PURE__*/react.createElement(ui_next_src/* Switch */.dOG, {
     checked: useCenterAsSegmentIndex,
     onCheckedChange: handleUseCenterAsSegmentIndexChange
   }), /*#__PURE__*/react.createElement("span", {
     className: "text-foreground text-base"
-  }, "Use center as segment index")), /*#__PURE__*/react.createElement("div", {
+  }, t('Use center as segment index'))), /*#__PURE__*/react.createElement("div", {
     className: "flex items-center gap-2"
   }, /*#__PURE__*/react.createElement(ui_next_src/* Switch */.dOG, {
     checked: toggleSegmentEnabled,
     onCheckedChange: handleToggleSegmentEnabledChange
   }), /*#__PURE__*/react.createElement("span", {
     className: "text-foreground text-base"
-  }, "Hover on segment border to activate")), /*#__PURE__*/react.createElement("div", {
+  }, t('Hover on segment border to activate'))), /*#__PURE__*/react.createElement("div", {
     className: "flex items-center gap-2"
   }, /*#__PURE__*/react.createElement(ui_next_src/* Switch */.dOG, {
     checked: segmentLabelEnabled,
     onCheckedChange: handleSegmentLabelEnabledChange
   }), /*#__PURE__*/react.createElement("span", {
     className: "text-foreground text-base"
-  }, "Show segment name on hover")));
+  }, t('Show segment name on hover'))));
 }
 ;// ../../../extensions/cornerstone/src/customizations/segmentationPanelCustomization.tsx
 
@@ -9100,6 +9106,10 @@ function ViewportDownloadFormNew({
   })), /*#__PURE__*/react.createElement(ui_next_src/* ImageModal */.jiK.ImageSize, {
     width: dimensions.width.toString(),
     height: dimensions.height.toString(),
+    widthLabel: t('Width'),
+    heightLabel: t('Height'),
+    widthPlaceholder: t('Width'),
+    heightPlaceholder: t('Height'),
     onWidthChange: e => {
       onDimensionsChange({
         ...dimensions,
@@ -9114,9 +9124,7 @@ function ViewportDownloadFormNew({
     },
     maxWidth: MAX_TEXTURE_SIZE.toString(),
     maxHeight: MAX_TEXTURE_SIZE.toString()
-  }, t('Image size'), " ", /*#__PURE__*/react.createElement("span", {
-    className: "text-muted-foreground"
-  }, "px")), /*#__PURE__*/react.createElement(ui_next_src/* ImageModal */.jiK.SwitchOption, {
+  }, t('Image size in pixels')), /*#__PURE__*/react.createElement(ui_next_src/* ImageModal */.jiK.SwitchOption, {
     defaultChecked: showAnnotations,
     checked: showAnnotations,
     onCheckedChange: onAnnotationsChange
@@ -9505,9 +9513,14 @@ const CornerstoneViewportDownloadForm = ({
           mode,
           bindings
         } = toolModeAndBindings[toolName];
-        toolGroup.setToolMode(toolName, mode, {
-          bindings
-        });
+        try {
+          toolGroup.setToolMode(toolName, mode, {
+            bindings
+          });
+        } catch (error) {
+          // Handle errors when restoring tool mode during cleanup (e.g., when tool state is undefined)
+          console.debug('Error restoring tool mode during cleanup:', toolName, error);
+        }
       });
     };
   }, []);
@@ -9557,7 +9570,7 @@ const CornerstoneViewportDownloadForm = ({
           volumeId: volumeIds[0]
         }]);
       }
-      if (segmentationRepresentations.length > 0) {
+      if (segmentationRepresentations?.length) {
         segmentationRepresentations.forEach(segRepresentation => {
           const {
             segmentationId,
@@ -9638,14 +9651,17 @@ const CornerstoneViewportDownloadForm = ({
       }, 100);
     }
   }, [viewportDimensions, showAnnotations]);
-  const handleDownload = async (filename, fileType) => {
+  const handleDownload = async (baseFilename, fileType) => {
     const divForDownloadViewport = document.querySelector(`div[data-viewport-uid="${VIEWPORT_ID}"]`);
     if (!divForDownloadViewport) {
       console.debug('No viewport found for download');
       return;
     }
+    const filename = `${baseFilename}.${fileType}`;
     const canvas = await (0,html2canvas_esm/* default */.A)(divForDownloadViewport);
-    downloadUrl(canvas.toDataURL(`image/${fileType}`, 1.0));
+    downloadUrl(canvas.toDataURL(`image/${fileType}`, 1.0), {
+      filename
+    });
   };
   const ViewportDownloadFormNew = customizationService.getCustomization('ohif.captureViewportModal');
   return /*#__PURE__*/react.createElement(ViewportDownloadFormNew, {
@@ -9707,6 +9723,11 @@ async function updateSegmentationStats({
   // Loop through each segment's stats
   Object.entries(stats).forEach(([segmentIndex, segmentStats]) => {
     const index = parseInt(segmentIndex);
+    if (!updatedSegmentation.segments[index]) {
+      // This happens when a segment is being restored
+      console.warn('Segment not found to update cached stats:', index);
+      return;
+    }
     if (!updatedSegmentation.segments[index].cachedStats) {
       updatedSegmentation.segments[index].cachedStats = {};
       hasUpdates = true;
@@ -10317,8 +10338,8 @@ let EasingFunctionEnum = /*#__PURE__*/function (EasingFunctionEnum) {
   return EasingFunctionEnum;
 }({});
 const EasingFunctionMap = new Map([[EasingFunctionEnum.EASE, ease], [EasingFunctionEnum.EASE_IN, easeIn], [EasingFunctionEnum.EASE_OUT, easeOut], [EasingFunctionEnum.EASE_IN_OUT, easeInOut], [EasingFunctionEnum.LINEAR, linear]]);
-// EXTERNAL MODULE: ../../i18n/src/index.js + 210 modules
-var i18n_src = __webpack_require__(68523);
+// EXTERNAL MODULE: ../../i18n/src/index.js + 286 modules
+var i18n_src = __webpack_require__(89010);
 ;// ../../../extensions/cornerstone/src/utils/createSegmentationForViewport.ts
 
 
@@ -10523,6 +10544,42 @@ function commandsModule({
       }
     }
   }
+
+  /**
+   * Creates a command function that sets a style property for segmentation types.
+   * If type is provided, sets the property for that type only.
+   * If type is not provided, sets the property for both Labelmap and Contour types.
+   * @param propertyName - The name of the style property to set
+   * @returns A command function that takes { type, value }
+   */
+  const createSetStyleCommand = propertyName => {
+    return ({
+      type,
+      value
+    }) => {
+      const {
+        segmentationService
+      } = servicesManager.services;
+      if (type) {
+        segmentationService.setStyle({
+          type
+        }, {
+          [propertyName]: value
+        });
+      } else {
+        segmentationService.setStyle({
+          type: esm_enums.SegmentationRepresentations.Labelmap
+        }, {
+          [propertyName]: value
+        });
+        segmentationService.setStyle({
+          type: esm_enums.SegmentationRepresentations.Contour
+        }, {
+          [propertyName]: value
+        });
+      }
+    };
+  };
   const actions = {
     jumpToMeasurementViewport: ({
       annotationUID,
@@ -11965,7 +12022,7 @@ function commandsModule({
         animationFunctionType
       } = customizationService.getCustomization('panelSegmentation.jumpToSegmentHighlightAnimationConfig') ?? {};
       const validAnimationFunctionType = Object.values(EasingFunctionEnum).includes(animationFunctionType) ? animationFunctionType : undefined;
-      segmentationService.jumpToSegmentCenter(segmentationId, segmentIndex, undefined, highlightAlpha, highlightSegment, animationLength, undefined, validAnimationFunctionType);
+      segmentationService.jumpToSegmentNext(segmentationId, segmentIndex, undefined, highlightAlpha, highlightSegment, animationLength, undefined, validAnimationFunctionType);
     },
     /**
      * Toggles the visibility of a segment
@@ -12139,146 +12196,6 @@ function commandsModule({
       const renderInactive = segmentationService.getRenderInactiveSegmentations(viewportId);
       segmentationService.setRenderInactiveSegmentations(viewportId, !renderInactive);
     },
-    /**
-     * Sets the fill alpha value for a segmentation type
-     * @param props.type - The type of segmentation
-     * @param props.value - The alpha value to set
-     */
-    setFillAlphaCommand: ({
-      type,
-      value
-    }) => {
-      const {
-        segmentationService
-      } = servicesManager.services;
-      segmentationService.setStyle({
-        type
-      }, {
-        fillAlpha: value
-      });
-    },
-    /**
-     * Sets the outline width for a segmentation type
-     * @param props.type - The type of segmentation
-     * @param props.value - The width value to set
-     */
-    setOutlineWidthCommand: ({
-      type,
-      value
-    }) => {
-      const {
-        segmentationService
-      } = servicesManager.services;
-      segmentationService.setStyle({
-        type
-      }, {
-        outlineWidth: value
-      });
-    },
-    /**
-     * Sets whether to render fill for a segmentation type
-     * @param props.type - The type of segmentation
-     * @param props.value - Whether to render fill
-     */
-    setRenderFillCommand: ({
-      type,
-      value
-    }) => {
-      const {
-        segmentationService
-      } = servicesManager.services;
-      segmentationService.setStyle({
-        type
-      }, {
-        renderFill: value
-      });
-    },
-    /**
-     * Sets whether to render fill for inactive segmentations of a segmentation type
-     * @param props.type - The type of segmentation
-     * @param props.value - Whether to render fill for inactive segmentations
-     */
-    setRenderFillInactiveCommand: ({
-      type,
-      value
-    }) => {
-      const {
-        segmentationService
-      } = servicesManager.services;
-      segmentationService.setStyle({
-        type
-      }, {
-        renderFillInactive: value
-      });
-    },
-    /**
-     * Sets whether to render outline for a segmentation type
-     * @param props.type - The type of segmentation
-     * @param props.value - Whether to render outline
-     */
-    setRenderOutlineCommand: ({
-      type,
-      value
-    }) => {
-      const {
-        segmentationService
-      } = servicesManager.services;
-      segmentationService.setStyle({
-        type
-      }, {
-        renderOutline: value
-      });
-    },
-    /**
-     * Sets whether to render outline for inactive segmentations of a segmentation type
-     * @param props.type - The type of segmentation
-     * @param props.value - Whether to render outline for inactive segmentations
-     */
-    setRenderOutlineInactiveCommand: ({
-      type,
-      value
-    }) => {
-      const {
-        segmentationService
-      } = servicesManager.services;
-      segmentationService.setStyle({
-        type
-      }, {
-        renderOutlineInactive: value
-      });
-    },
-    /**
-     * Sets the fill alpha for inactive segmentations.
-     * If no type is provided, the fill alpha for all types will be set.
-     * @param props.type - The type of segmentation
-     * @param props.value - The alpha value to set
-     */
-    setFillAlphaInactiveCommand: ({
-      type,
-      value
-    }) => {
-      const {
-        segmentationService
-      } = servicesManager.services;
-      if (type) {
-        segmentationService.setStyle({
-          type
-        }, {
-          fillAlphaInactive: value
-        });
-      } else {
-        segmentationService.setStyle({
-          type: esm_enums.SegmentationRepresentations.Labelmap
-        }, {
-          fillAlphaInactive: value
-        });
-        segmentationService.setStyle({
-          type: esm_enums.SegmentationRepresentations.Contour
-        }, {
-          fillAlphaInactive: value
-        });
-      }
-    },
     editSegmentLabel: async ({
       segmentationId,
       segmentIndex
@@ -13230,25 +13147,25 @@ function commandsModule({
       commandFn: actions.toggleRenderInactiveSegmentationsCommand
     },
     setFillAlpha: {
-      commandFn: actions.setFillAlphaCommand
+      commandFn: createSetStyleCommand('fillAlpha')
     },
     setOutlineWidth: {
-      commandFn: actions.setOutlineWidthCommand
+      commandFn: createSetStyleCommand('outlineWidth')
     },
     setRenderFill: {
-      commandFn: actions.setRenderFillCommand
+      commandFn: createSetStyleCommand('renderFill')
     },
     setRenderFillInactive: {
-      commandFn: actions.setRenderFillInactiveCommand
+      commandFn: createSetStyleCommand('renderFillInactive')
     },
     setRenderOutline: {
-      commandFn: actions.setRenderOutlineCommand
+      commandFn: createSetStyleCommand('renderOutline')
     },
     setRenderOutlineInactive: {
-      commandFn: actions.setRenderOutlineInactiveCommand
+      commandFn: createSetStyleCommand('renderOutlineInactive')
     },
     setFillAlphaInactive: {
-      commandFn: actions.setFillAlphaInactiveCommand
+      commandFn: createSetStyleCommand('fillAlphaInactive')
     },
     editSegmentLabel: {
       commandFn: actions.editSegmentLabel
@@ -15391,6 +15308,7 @@ var hooks = __webpack_require__(38007);
 
 
 
+
 function ViewportDataOverlayMenu({
   viewportId
 }) {
@@ -15398,6 +15316,9 @@ function ViewportDataOverlayMenu({
     commandsManager,
     servicesManager
   } = (0,src/* useSystem */.Jg)();
+  const {
+    t
+  } = (0,es/* useTranslation */.Bd)();
   const [pendingForegrounds, setPendingForegrounds] = (0,react.useState)([]);
   const [pendingSegmentations, setPendingSegmentations] = (0,react.useState)([]);
   const {
@@ -15555,7 +15476,7 @@ function ViewportDataOverlayMenu({
     disabled: potentialForegroundDisplaySets.length === 0
   }, /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.Plus, {
     className: "h-4 w-4"
-  }), "Foreground"), /*#__PURE__*/react.createElement(ui_next_src/* Button */.$nd, {
+  }), t('Common:Foreground')), /*#__PURE__*/react.createElement(ui_next_src/* Button */.$nd, {
     variant: "ghost",
     className: "text-primary ml-2 flex items-center",
     disabled: potentialOverlayDisplaySets.length === 0,
@@ -15565,7 +15486,7 @@ function ViewportDataOverlayMenu({
     dataCY: `AddSegmentationDataOverlay-${viewportId}`
   }, /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.Plus, {
     className: "h-4 w-4"
-  }), "Segmentation")), /*#__PURE__*/react.createElement("div", {
+  }), t('Tools:Segmentation'))), /*#__PURE__*/react.createElement("div", {
     className: ""
   }, /*#__PURE__*/react.createElement("div", {
     className: "my-2 ml-1"
@@ -15618,7 +15539,7 @@ function ViewportDataOverlayMenu({
   }, /*#__PURE__*/react.createElement(ui_next_src/* SelectTrigger */.bqE, {
     className: "flex-1"
   }, /*#__PURE__*/react.createElement(ui_next_src/* SelectValue */.yvm, {
-    placeholder: "SELECT A SEGMENTATION"
+    placeholder: t('Common:SELECT A SEGMENTATION')
   })), /*#__PURE__*/react.createElement(ui_next_src/* SelectContent */.gCo, null, potentialOverlayDisplaySets.map(item => /*#__PURE__*/react.createElement(ui_next_src/* SelectItem */.ebT, {
     key: item.displaySetInstanceUID,
     value: item.displaySetInstanceUID,
@@ -15688,7 +15609,7 @@ function ViewportDataOverlayMenu({
   }, /*#__PURE__*/react.createElement(ui_next_src/* SelectTrigger */.bqE, {
     className: "flex-1"
   }, /*#__PURE__*/react.createElement(ui_next_src/* SelectValue */.yvm, {
-    placeholder: "SELECT A FOREGROUND"
+    placeholder: t('Common:SELECT A FOREGROUND')
   })), /*#__PURE__*/react.createElement(ui_next_src/* SelectContent */.gCo, null, potentialForegroundDisplaySets.map(item => /*#__PURE__*/react.createElement(ui_next_src/* SelectItem */.ebT, {
     key: item.displaySetInstanceUID,
     value: item.displaySetInstanceUID,
@@ -16131,7 +16052,9 @@ function Colormap({
     className: "p-1"
   }, colormaps.map((colormap, index) => /*#__PURE__*/react.createElement(ui_next_src/* AllInOneMenu */.se.Item, {
     key: index,
-    label: colormap.description,
+    label: t(`Colormaps:${colormap.Name}`, {
+      defaultValue: colormap.Name
+    }),
     useIconSpace: false,
     onClick: () => {
       setCurrentColormap(colormap);
@@ -16188,9 +16111,13 @@ function Colorbar({
 
 
 
+
 function WindowLevel({
   viewportId
 } = {}) {
+  const {
+    t
+  } = (0,es/* useTranslation */.Bd)('WindowLevelActionMenu');
   const {
     viewportDisplaySets
   } = (0,useViewportRendering/* useViewportRendering */.e)(viewportId);
@@ -16242,7 +16169,7 @@ function WindowLevel({
     onClick: () => setShowPreview(!showPreview)
   }, /*#__PURE__*/react.createElement("span", {
     className: "flex-shrink-0"
-  }, "Preview in viewport"), /*#__PURE__*/react.createElement(ui_next_src/* Switch */.dOG, {
+  }, t('Preview in viewport')), /*#__PURE__*/react.createElement(ui_next_src/* Switch */.dOG, {
     className: "ml-auto flex-shrink-0",
     checked: showPreview,
     onCheckedChange: checked => {
@@ -16261,7 +16188,7 @@ function WindowLevel({
     className: "p-1"
   }, windowLevelPresets.map((preset, index) => /*#__PURE__*/react.createElement(ui_next_src/* AllInOneMenu */.se.Item, {
     key: index,
-    label: preset.description,
+    label: t(preset.description),
     secondaryLabel: `${preset.window} / ${preset.level}`,
     useIconSpace: false,
     onClick: () => {
@@ -16289,6 +16216,7 @@ function WindowLevel({
 
 
 
+
 function VolumeRenderingPresetsContent({
   presets,
   viewportId,
@@ -16299,6 +16227,9 @@ function VolumeRenderingPresetsContent({
   } = (0,src/* useSystem */.Jg)();
   const [searchValue, setSearchValue] = (0,react.useState)('');
   const [selectedPreset, setSelectedPreset] = (0,react.useState)(null);
+  const {
+    t
+  } = (0,es/* useTranslation */.Bd)('WindowLevelActionMenu');
   const handleSearchChange = (0,react.useCallback)(event => {
     setSearchValue(event.target.value);
   }, []);
@@ -16316,7 +16247,7 @@ function VolumeRenderingPresetsContent({
   }, /*#__PURE__*/react.createElement(ui_next_src/* PresetDialog */.MUF.PresetBody, null, /*#__PURE__*/react.createElement(ui_next_src/* PresetDialog */.MUF.PresetFilter, null, /*#__PURE__*/react.createElement(ui_next_src/* PresetDialog */.MUF.PresetSearch, {
     value: searchValue,
     onChange: handleSearchChange,
-    placeholder: "Search all"
+    placeholder: t('Search all', 'Search all')
   })), /*#__PURE__*/react.createElement(ui_next_src/* PresetDialog */.MUF.PresetGrid, null, filteredPresets.map((preset, index) => /*#__PURE__*/react.createElement("div", {
     key: index,
     className: "flex cursor-pointer flex-col items-start",
@@ -16336,7 +16267,7 @@ function VolumeRenderingPresetsContent({
     className: "mt-4 flex-shrink-0"
   }, /*#__PURE__*/react.createElement(ui_next_src/* FooterAction */.esu.Right, null, /*#__PURE__*/react.createElement(ui_next_src/* FooterAction */.esu.Secondary, {
     onClick: hide
-  }, "Cancel"))));
+  }, t('Common:Cancel')))));
 }
 ;// ../../../extensions/cornerstone/src/components/WindowLevelActionMenu/VolumeRenderingPresets.tsx
 
@@ -16345,6 +16276,7 @@ function VolumeRenderingPresetsContent({
 
 
 
+
 function VolumeRenderingPresets({
   viewportId
 } = {}) {
@@ -16357,11 +16289,14 @@ function VolumeRenderingPresets({
   const {
     uiDialogService
   } = servicesManager.services;
+  const {
+    t
+  } = (0,es/* useTranslation */.Bd)('WindowLevelActionMenu');
   const onClickPresets = () => {
     uiDialogService.show({
       id: 'volume-rendering-presets',
       content: VolumeRenderingPresetsContent,
-      title: 'Rendering Presets',
+      title: t('Rendering Presets'),
       isDraggable: true,
       contentProps: {
         presets: volumeRenderingPresets,
@@ -16370,7 +16305,7 @@ function VolumeRenderingPresets({
     });
   };
   return /*#__PURE__*/react.createElement(ui_next_src/* AllInOneMenu */.se.Item, {
-    label: "Rendering Presets",
+    label: t('Rendering Presets'),
     icon: /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.VolumeRendering, null),
     rightIcon: /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.ByName, {
       name: "action-new-dialog"
@@ -16382,6 +16317,7 @@ function VolumeRenderingPresets({
 
 
 
+
 function VolumeRenderingQuality({
   volumeRenderingQualityRange,
   viewportId
@@ -16399,6 +16335,9 @@ function VolumeRenderingQuality({
     step
   } = volumeRenderingQualityRange;
   const [quality, setQuality] = (0,react.useState)(null);
+  const {
+    t
+  } = (0,es/* useTranslation */.Bd)('WindowLevelActionMenu');
   const onChange = (0,react.useCallback)(value => {
     commandsManager.runCommand('setVolumeRenderingQulaity', {
       viewportId,
@@ -16437,7 +16376,7 @@ function VolumeRenderingQuality({
     className: "flex flex-row items-center"
   }, /*#__PURE__*/react.createElement(ui_next_src/* Numeric */.ewR.Label, {
     className: "w-16"
-  }, "Quality"), /*#__PURE__*/react.createElement(ui_next_src/* Numeric */.ewR.SingleRange, {
+  }, t('Quality')), /*#__PURE__*/react.createElement(ui_next_src/* Numeric */.ewR.SingleRange, {
     sliderClassName: "mx-2 flex-grow"
   })))));
 }
@@ -16445,6 +16384,7 @@ function VolumeRenderingQuality({
 
 
 
+
 function VolumeShift({
   viewportId
 }) {
@@ -16466,6 +16406,9 @@ function VolumeShift({
     actor
   } = viewport.getActors()[0];
   const ofun = actor.getProperty().getScalarOpacity(0);
+  const {
+    t
+  } = (0,es/* useTranslation */.Bd)('WindowLevelActionMenu');
   (0,react.useEffect)(() => {
     if (isBlocking) {
       return;
@@ -16505,7 +16448,7 @@ function VolumeShift({
     className: "flex flex-row items-center"
   }, /*#__PURE__*/react.createElement(ui_next_src/* Numeric */.ewR.Label, {
     className: "w-16"
-  }, "Shift"), /*#__PURE__*/react.createElement(ui_next_src/* Numeric */.ewR.SingleRange, {
+  }, t('Shift')), /*#__PURE__*/react.createElement(ui_next_src/* Numeric */.ewR.SingleRange, {
     sliderClassName: "mx-2 flex-grow"
   })))));
 }
@@ -16513,6 +16456,7 @@ function VolumeShift({
 
 
 
+
 function VolumeLighting({
   viewportId,
   hasShade
@@ -16529,6 +16473,9 @@ function VolumeLighting({
     diffuse: null,
     specular: null
   });
+  const {
+    t
+  } = (0,es/* useTranslation */.Bd)('WindowLevelActionMenu');
 
   // Single callback to handle all lighting property changes
   const onLightingChange = (0,react.useCallback)((property, value) => {
@@ -16561,13 +16508,13 @@ function VolumeLighting({
   // Configuration for our lighting properties
   const lightingProperties = [{
     key: 'ambient',
-    label: 'Ambient'
+    label: t('Ambient')
   }, {
     key: 'diffuse',
-    label: 'Diffuse'
+    label: t('Diffuse')
   }, {
     key: 'specular',
-    label: 'Specular'
+    label: t('Specular')
   }];
   return /*#__PURE__*/react.createElement("div", {
     className: "my-1 mt-2 flex flex-col space-y-2"
@@ -16596,10 +16543,14 @@ function VolumeLighting({
 
 
 
+
 function VolumeShade({
   viewportId,
   onClickShade = bool => {}
 }) {
+  const {
+    t
+  } = (0,es/* useTranslation */.Bd)('WindowLevelActionMenu');
   const {
     servicesManager,
     commandsManager
@@ -16629,7 +16580,7 @@ function VolumeShade({
   }, [viewportId, cornerstoneViewportService]);
   return /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement("span", {
     className: "flex-grow"
-  }, "Shade"), /*#__PURE__*/react.createElement(ui_next_src/* Switch */.dOG, {
+  }, t('Shade')), /*#__PURE__*/react.createElement(ui_next_src/* Switch */.dOG, {
     className: "ml-2 flex-shrink-0",
     key: key,
     checked: shade,
@@ -16648,6 +16599,7 @@ function VolumeShade({
 
 
 
+
 function VolumeRenderingOptions({
   viewportId
 } = {}) {
@@ -16655,6 +16607,9 @@ function VolumeRenderingOptions({
     volumeRenderingQualityRange
   } = (0,useViewportRendering/* useViewportRendering */.e)(viewportId);
   const [hasShade, setShade] = (0,react.useState)(false);
+  const {
+    t
+  } = (0,es/* useTranslation */.Bd)('WindowLevelActionMenu');
   return /*#__PURE__*/react.createElement(ui_next_src/* AllInOneMenu */.se.ItemPanel, null, /*#__PURE__*/react.createElement(VolumeRenderingQuality, {
     viewportId: viewportId,
     volumeRenderingQualityRange: volumeRenderingQualityRange
@@ -16664,7 +16619,7 @@ function VolumeRenderingOptions({
     className: "mt-2 flex h-8 !h-[20px] w-full flex-shrink-0 items-center justify-start px-2 text-base"
   }, /*#__PURE__*/react.createElement("div", {
     className: "text-muted-foreground text-sm"
-  }, "Lighting")), /*#__PURE__*/react.createElement("div", {
+  }, t('Lighting'))), /*#__PURE__*/react.createElement("div", {
     className: "bg-background mt-1 mb-1 h-px w-full"
   }), /*#__PURE__*/react.createElement("div", {
     className: "hover:bg-accent flex h-8 w-full flex-shrink-0 items-center px-2 text-base hover:rounded"
@@ -16689,20 +16644,22 @@ function VolumeRenderingOptions({
 
 function WindowLevelActionMenu({
   viewportId,
-  element,
   align,
-  side
+  side,
+  onVisibilityChange
 }) {
   return /*#__PURE__*/react.createElement(WindowLevelActionMenuContent, {
     viewportId: viewportId,
     align: align,
-    side: side
+    side: side,
+    onVisibilityChange: onVisibilityChange
   });
 }
 function WindowLevelActionMenuContent({
   viewportId,
   align,
-  side
+  side,
+  onVisibilityChange
 }) {
   const {
     t
@@ -16723,7 +16680,8 @@ function WindowLevelActionMenuContent({
     isVisible: true,
     align: align,
     side: side,
-    backLabel: i18next/* default */.A.t('WindowLevelActionMenu:Back to Display Options')
+    backLabel: i18next/* default */.A.t('WindowLevelActionMenu:Back to Display Options'),
+    onVisibilityChange: onVisibilityChange
   }, /*#__PURE__*/react.createElement(ui_next_src/* AllInOneMenu */.se.ItemPanel, null, !is3DVolume && /*#__PURE__*/react.createElement(Colorbar, {
     viewportId: viewportId
   }), colorbarProperties?.colormaps && !is3DVolume && /*#__PURE__*/react.createElement(ui_next_src/* AllInOneMenu */.se.SubMenu, {
@@ -16758,7 +16716,6 @@ function WindowLevelActionMenuWrapper_extends() { return WindowLevelActionMenuWr
 function WindowLevelActionMenuWrapper(props) {
   const {
     viewportId,
-    element,
     location,
     isOpen = false,
     onOpen,
@@ -16839,9 +16796,9 @@ function WindowLevelActionMenuWrapper(props) {
     sideOffset: 5
   }, /*#__PURE__*/react.createElement(WindowLevelActionMenu, {
     viewportId: viewportIdToUse,
-    element: element,
     align: align,
-    side: side
+    side: side,
+    onVisibilityChange: handleOpenChange
   })));
 }
 ;// ../../../extensions/cornerstone/src/components/VOIManualControlMenu/VOIManualControlMenu.tsx
@@ -17481,6 +17438,7 @@ function ModalityLoadBadge({
 
 
 
+
 /**
  * NavigationComponent provides navigation controls for viewports containing
  * special displaySets (SR, SEG, RTSTRUCT) to navigate between segments or measurements
@@ -17517,7 +17475,7 @@ function NavigationComponent({
   } = (0,hooks/* useViewportSegmentations */.Lt)({
     viewportId
   });
-  const hasSegmentations = segmentationsWithRepresentations.length > 0;
+  const hasSegmentations = segmentationsWithRepresentations.length > 0 && segmentationsWithRepresentations.some(segmentation => segmentation?.representation?.type !== esm_enums.SegmentationRepresentations.Surface);
 
   // prefer segment navigation if available
   const navigationMode = hasSegmentations ? 'segment' : isSRDisplaySet ? 'measurement' : isTracked ? 'measurement' : null;
@@ -17546,7 +17504,8 @@ function NavigationComponent({
     if (!segmentationsWithRepresentations.length) {
       return;
     }
-    const segmentationId = segmentationsWithRepresentations[0].segmentation.segmentationId;
+    const activeSegmentationWithRepresentation = segmentationsWithRepresentations.find(segmentation => segmentation?.representation?.active);
+    const segmentationId = activeSegmentationWithRepresentation.segmentation.segmentationId;
     src_utils.handleSegmentChange({
       direction,
       segmentationId,
@@ -18014,9 +17973,10 @@ function AdvancedRenderingControls({
 
 
 
+
 const getDisabledState = disabledText => ({
   disabled: true,
-  disabledText: disabledText ?? 'Not available on the current viewport'
+  disabledText: disabledText ?? i18n_src/* default */.A.t('Buttons:Not available on the current viewport')
 });
 function getToolbarModule({
   servicesManager,
@@ -18349,7 +18309,7 @@ function getToolbarModule({
       if (supportedModalities?.length) {
         const hasAnySupportedModality = displaySets.some(displaySet => supportedModalities.includes(displaySet?.Modality));
         if (!hasAnySupportedModality) {
-          return getDisabledState(disabledText || 'Tool not available for this modality');
+          return getDisabledState(disabledText || i18n_src/* default */.A.t('Buttons:Tool not available for this modality'));
         }
       }
     }
@@ -18792,9 +18752,26 @@ ToolGroupService.REGISTRATION = {
 ;// ../../../extensions/cornerstone/src/services/ToolGroupService/index.js
 
 /* harmony default export */ const services_ToolGroupService = (ToolGroupService);
+;// ../../../extensions/cornerstone/src/utils/isAnyDisplaySetCommon.ts
+/**
+ * Checks whether two viewports share at least one common display set.
+ *
+ * This method checks to see if the source and target share a display set.
+ * It performs an O(n * m) comparison between the display sets of each viewport.
+ * Since each viewport typically contains only a small number of display sets (≤ 5),
+ * the computational cost is negligible.
+ *
+ * @param sourceDisplaySetUIDs - Array of displaySetInstanceUID from the source viewport.
+ * @param targetDisplaySetUIDs - Array of displaySetInstanceUID from the target viewport.
+ * @returns true if at least one display set is common; false otherwise.
+ */
+function isAnyDisplaySetCommon(sourceDisplaySetUIDs, targetDisplaySetUIDs) {
+  return sourceDisplaySetUIDs.some(uid => targetDisplaySetUIDs.includes(uid));
+}
 ;// ../../../extensions/cornerstone/src/services/SyncGroupService/createHydrateSegmentationSynchronizer.ts
 
 
+
 const {
   createSynchronizer
 } = dist_esm.SynchronizerManager;
@@ -18818,6 +18795,13 @@ function createHydrateSegmentationSynchronizer(synchronizerName, {
   });
   return stackImageSynchronizer;
 }
+
+/**
+ * This method will add the segmentation representation to any target viewports having:
+ *
+ * 1. the same FrameOfReferenceUID (FOR) as the segmentation representation, or
+ * 2. a shared DisplaySet with the source viewport when no FOR is present.
+ */
 const segmentationRepresentationModifiedCallback = async (synchronizerInstance, sourceViewport, targetViewport, sourceEvent, {
   servicesManager,
   options
@@ -18828,14 +18812,20 @@ const segmentationRepresentationModifiedCallback = async (synchronizerInstance,
     type: segmentationRepresentationType
   } = event.detail;
   const {
-    segmentationService
+    segmentationService,
+    cornerstoneViewportService
   } = servicesManager.services;
   const targetViewportId = targetViewport.viewportId;
+  const sourceViewportId = sourceViewport.viewportId;
   const {
     viewport
   } = (0,esm.getEnabledElementByViewportId)(targetViewportId);
-  const targetFrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-  if (!targetFrameOfReferenceUID) {
+  const sourceViewportInfo = cornerstoneViewportService.getViewportInfo(sourceViewportId);
+  const targetViewportInfo = cornerstoneViewportService.getViewportInfo(targetViewportId);
+  const sourceDisplaySetUIDs = extractDisplaySetUIDs(sourceViewportInfo);
+  const targetDisplaySetUIDs = extractDisplaySetUIDs(targetViewportInfo);
+  const sharedDisplaySetExists = isAnyDisplaySetCommon(sourceDisplaySetUIDs, targetDisplaySetUIDs);
+  if (!sharedDisplaySetExists && !viewport.getFrameOfReferenceUID()) {
     return;
   }
   const targetViewportRepresentation = segmentationService.getSegmentationRepresentations(targetViewportId, {
@@ -18851,10 +18841,17 @@ const segmentationRepresentationModifiedCallback = async (synchronizerInstance,
     segmentationId,
     type,
     config: {
-      blendMode: viewport.getBlendMode() === 1 ? BlendModes.LABELMAP_EDGE_PROJECTION_BLEND : undefined
+      blendMode: viewport?.getBlendMode?.() === 1 ? BlendModes.LABELMAP_EDGE_PROJECTION_BLEND : undefined
     }
   });
 };
+
+/**
+ * Extracts the displaySetInstanceUIDs from a viewportInfo.
+ */
+function extractDisplaySetUIDs(viewportInfo) {
+  return viewportInfo.getViewportData().data.map(ds => ds.displaySetInstanceUID);
+}
 ;// ../../../extensions/cornerstone/src/services/SyncGroupService/SyncGroupService.ts
 var _SyncGroupService;
 
@@ -19138,6 +19135,9 @@ var _SegmentationService;
 
 
 
+const {
+  DefaultHistoryMemo: SegmentationService_DefaultHistoryMemo
+} = esm.utilities.HistoryMemo;
 const {
   Labelmap: LABELMAP,
   Contour: CONTOUR,
@@ -19898,11 +19898,69 @@ class SegmentationService extends src/* PubSubService */.Rc {
     });
   }
 
+  /**
+   * Creates a memo that records the current state of a segment (segmentationId/segmentIndex)
+   * so that undo can restore it via addSegment and redo can call removeSegment again
+   * without recording history.
+   *
+   * @param segmentationId - The ID of the segmentation.
+   * @param segmentIndex - The index of the segment (must still exist when called).
+   * @param _options - Reserved (e.g. deleting) for future use.
+   * @returns A Memo with restoreMemo(undo): undo => addSegment, redo => removeSegment (skipRecordingHistory).
+   */
+  createSegmentIndexMemo(segmentationId, segmentIndex, _options) {
+    const csSegmentation = this.getCornerstoneSegmentation(segmentationId);
+    const segment = csSegmentation?.segments?.[segmentIndex];
+    if (!segment) {
+      return null;
+    }
+    let color;
+    let visibility;
+    const viewportIds = this.getViewportIdsWithSegmentation(segmentationId);
+    if (viewportIds.length > 0) {
+      const firstViewportId = viewportIds[0];
+      const representations = this.getSegmentationRepresentations(firstViewportId, {
+        segmentationId
+      });
+      const repType = representations[0]?.type ?? LABELMAP;
+      color = this.getSegmentColor(firstViewportId, segmentationId, segmentIndex);
+      visibility = dist_esm.segmentation.config.visibility.getSegmentIndexVisibility(firstViewportId, {
+        segmentationId,
+        type: repType
+      }, segmentIndex);
+    }
+    const segmentState = {
+      segmentIndex,
+      label: segment.label,
+      isLocked: segment.locked,
+      active: segment.active,
+      color,
+      visibility
+    };
+    const service = this;
+    const memo = {
+      id: esm.utilities.uuidv4(),
+      operationType: 'segmentIndex',
+      restoreMemo(undo) {
+        if (undo === true) {
+          service.addSegment(segmentationId, segmentState);
+        } else {
+          // Redo: remove the segment via cornerstone without recording history
+          dist_esm.segmentation.removeSegment(segmentationId, segmentIndex, {
+            recordHistory: false
+          });
+        }
+      }
+    };
+    return memo;
+  }
+
   /**
    * Removes a segment from a segmentation and updates the active segment index if necessary.
    *
    * @param segmentationId - The ID of the segmentation containing the segment to remove.
    * @param segmentIndex - The index of the segment to remove.
+   * @param options - Optional. skipRecordingHistory: if true, do not push undo memo (used when redoing).
    *
    * @remarks
    * This method performs the following actions:
@@ -19911,8 +19969,23 @@ class SegmentationService extends src/* PubSubService */.Rc {
    * 3. If the removed segment was the active segment, it updates the active segment index.
    *
    */
-  removeSegment(segmentationId, segmentIndex) {
-    dist_esm.segmentation.removeSegment(segmentationId, segmentIndex);
+  removeSegment(segmentationId, segmentIndex, options) {
+    let memo;
+    if (!options?.skipRecordingHistory) {
+      memo = this.createSegmentIndexMemo(segmentationId, segmentIndex, {
+        deleting: true
+      });
+      SegmentationService_DefaultHistoryMemo.startGroupRecording();
+      dist_esm.segmentation.removeSegment(segmentationId, segmentIndex, {
+        recordHistory: true
+      });
+      SegmentationService_DefaultHistoryMemo.push(memo);
+      SegmentationService_DefaultHistoryMemo.endGroupRecording();
+    } else {
+      dist_esm.segmentation.removeSegment(segmentationId, segmentIndex, {
+        recordHistory: false
+      });
+    }
   }
   setSegmentVisibility(viewportId, segmentationId, segmentIndex, isVisible, type) {
     this._setSegmentVisibility(viewportId, segmentationId, segmentIndex, isVisible, type);
@@ -20128,15 +20201,111 @@ class SegmentationService extends src/* PubSubService */.Rc {
   removeSegmentationRepresentations(viewportId, specifier = {}) {
     dist_esm.segmentation.removeSegmentationRepresentations(viewportId, specifier);
   }
-  jumpToSegmentCenter(segmentationId, segmentIndex, viewportId, highlightAlpha = 0.9, highlightSegment = true, animationLength = 750, highlightHideOthers = false, animationFunctionType = EasingFunctionEnum.EASE_IN_OUT) {
-    const center = this._getSegmentCenter(segmentationId, segmentIndex);
-    if (!center) {
+
+  /**
+   * Jumps to the next slice that contains the specified segment in the viewport.
+   * For labelmaps, it jumps to the segment center. For contours, it cycles through
+   * all slices that contain contour data for the segment.
+   *
+   * @param segmentationId - The ID of the segmentation
+   * @param segmentIndex - The index of the segment to jump to
+   * @param viewportId - Optional viewport ID. If not provided, applies to all viewports with this segmentation
+   * @param highlightAlpha - Alpha value for highlighting (0-1)
+   * @param highlightSegment - Whether to highlight the segment after jumping
+   * @param animationLength - Length of highlight animation in milliseconds
+   * @param highlightHideOthers - Whether to hide other segments during highlight
+   * @param animationFunctionType - The easing function to use for animation
+   */
+  jumpToSegmentNext(segmentationId, segmentIndex, forViewportId, direction = 1, highlightAlpha = 0.9, highlightSegment = true, animationLength = 750, highlightHideOthers = false, animationFunctionType = EasingFunctionEnum.EASE_IN_OUT) {
+    const viewportIds = forViewportId ? [forViewportId] : this.getViewportIdsWithSegmentation(segmentationId);
+    viewportIds.forEach(viewportId => {
+      const representations = this.getSegmentationRepresentations(viewportId, {
+        segmentationId
+      });
+      if (!representations || representations.length === 0) {
+        return;
+      }
+      const representation = representations[0];
+      const {
+        type
+      } = representation;
+
+      // For contours, check if we have a segment center.
+      const center = type === CONTOUR ? this._getSegmentCenter(segmentationId, segmentIndex) : undefined;
+      const canUseSegmentCenter = type !== CONTOUR || !!center;
+      if (canUseSegmentCenter) {
+        this.jumpToSegmentCenter(segmentationId, segmentIndex, viewportId, highlightAlpha, highlightSegment, animationLength, highlightHideOthers, animationFunctionType, center);
+        return;
+      }
+      const {
+        viewport
+      } = (0,esm.getEnabledElementByViewportId)(viewportId);
+      if (!viewport) {
+        return;
+      }
+      const viewRefs = this._getContourViewReferences(segmentationId, viewport, segmentIndex);
+      if (!viewRefs) {
+        return;
+      }
+
+      // Get the current slice index
+      const currentSliceIndex = viewport.getCurrentImageIdIndex();
+      let nearestSliceIndex = null;
+      let loopSliceIndex = null;
+      for (const [sliceIndex] of viewRefs.entries()) {
+        // Track loop index for wraparound (smallest for forward, largest for backward)
+        if (direction > 0) {
+          if (loopSliceIndex === null || sliceIndex < loopSliceIndex) {
+            loopSliceIndex = sliceIndex;
+          }
+        } else {
+          if (loopSliceIndex === null || sliceIndex > loopSliceIndex) {
+            loopSliceIndex = sliceIndex;
+          }
+        }
+        if (direction > 0) {
+          // Forward direction: find nearest slice after current
+          if (sliceIndex <= currentSliceIndex) {
+            continue;
+          }
+          if (nearestSliceIndex === null || sliceIndex < nearestSliceIndex) {
+            nearestSliceIndex = sliceIndex;
+          }
+        } else {
+          // Backward direction: find nearest slice before current
+          if (sliceIndex >= currentSliceIndex) {
+            continue;
+          }
+          if (nearestSliceIndex === null || sliceIndex > nearestSliceIndex) {
+            nearestSliceIndex = sliceIndex;
+          }
+        }
+      }
+
+      // Wraparound: if no slice found in direction, use loop index
+      nearestSliceIndex = nearestSliceIndex ?? loopSliceIndex;
+      if (nearestSliceIndex === null) {
+        return;
+      }
+      const viewRef = viewRefs.get(nearestSliceIndex);
+      viewport.setViewReference(viewRef);
+      viewport.render();
+    });
+  }
+
+  /**
+   * Jumps the viewport to the center of hte given segment.
+   * Only works for labelmaps, and may result in not showing any contours.
+   */
+  jumpToSegmentCenter(segmentationId, segmentIndex, viewportId, highlightAlpha = 0.9, highlightSegment = true, animationLength = 750, highlightHideOthers = false, animationFunctionType = EasingFunctionEnum.EASE_IN_OUT, center) {
+    const resolvedCenter = center ?? this._getSegmentCenter(segmentationId, segmentIndex);
+    if (!resolvedCenter) {
       console.warn('No center found for segmentation', segmentationId, segmentIndex);
       return;
     }
     const {
       world
-    } = center;
+    } = resolvedCenter;
 
     // need to find which viewports are displaying the segmentation
     const viewportIds = viewportId ? [viewportId] : this.getViewportIdsWithSegmentation(segmentationId);
@@ -20144,6 +20313,9 @@ class SegmentationService extends src/* PubSubService */.Rc {
       const {
         viewport
       } = (0,esm.getEnabledElementByViewportId)(viewportId);
+      if (!viewport?.jumpToWorld) {
+        return;
+      }
       viewport.jumpToWorld(world);
       highlightSegment && this.highlightSegment(segmentationId, segmentIndex, viewportId, highlightAlpha, animationLength, highlightHideOthers, animationFunctionType);
     });
@@ -20530,6 +20702,54 @@ class SegmentationService extends src/* PubSubService */.Rc {
       }
     }]);
   }
+  /**
+   * Gets slice indices for contour segmentations by checking view references from annotation metadata
+   * @private
+   */
+  _getContourViewReferences(segmentationId, viewport, segmentIndex) {
+    const segmentation = dist_esm.segmentation.state.getSegmentation(segmentationId);
+    const contourData = segmentation.representationData[CONTOUR];
+    if (!contourData || !contourData.annotationUIDsMap) {
+      return;
+    }
+    const viewReferences = new Map();
+    // Iterate through the annotationUIDsMap
+    contourData.annotationUIDsMap.forEach((annotationUIDs, currentSegmentIndex) => {
+      // Filter by segment index if specified
+      if (segmentIndex !== undefined && currentSegmentIndex !== segmentIndex) {
+        return;
+      }
+      // Process each annotation UID
+      annotationUIDs.forEach(annotationUID => {
+        const annotation = dist_esm.annotation.state.getAnnotation(annotationUID);
+        if (!annotation?.metadata) {
+          return;
+        }
+        const {
+          metadata
+        } = annotation;
+        // Check if the viewport can view this annotation's view reference with navigation
+        const isViewable = viewport.isReferenceViewable(metadata, {
+          withNavigation: true
+        });
+        if (!isViewable) {
+          return;
+        }
+        const {
+          sliceIndex
+        } = metadata;
+        if (sliceIndex === undefined) {
+          console.warn("Can't find slice index:", metadata);
+          return;
+        }
+        viewReferences.set(sliceIndex, metadata);
+      });
+    });
+    if (viewReferences.size === 0) {
+      return;
+    }
+    return viewReferences;
+  }
 }
 _SegmentationService = SegmentationService;
 SegmentationService.REGISTRATION = {
@@ -21153,6 +21373,8 @@ var _CornerstoneViewportService;
 
 
 
+
+
 const CornerstoneViewportService_EVENTS = {
   VIEWPORT_DATA_CHANGED: 'event::cornerstoneViewportService:viewportDataChanged',
   VIEWPORT_VOLUMES_CHANGED: 'event::cornerstoneViewportService:viewportVolumesChanged'
@@ -21596,8 +21818,7 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
    * viewport to display the image in where it matches, in order:
    *   * Active viewport that can be navigated to the given image without orientation change
    *   * Other viewport that can be navigated to the given image without orientation change
-   *   * Active viewport that can change orientation to display the image
-   *   * Other viewport that can change orientation to display the image
+   *   * Best-aligned viewport that can display the image with an orientation change
    *
    * It returns `null` otherwise, indicating that a viewport needs display set/type
    * changes in order to display the image.
@@ -21620,9 +21841,7 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
     if (!activeViewport) {
       console.warn('No active viewport found for', activeViewportId);
     }
-    if (activeViewport?.isReferenceViewable(metadata, {
-      withNavigation: true
-    })) {
+    if (activeViewport?.isReferenceViewable(metadata, WITH_NAVIGATION)) {
       return activeViewportId;
     }
 
@@ -21630,29 +21849,21 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
     // without considering orientation changes.
     for (const id of this.viewportsById.keys()) {
       const viewport = this.getCornerstoneViewport(id);
-      if (viewport?.isReferenceViewable(metadata, {
-        withNavigation: true
-      })) {
+      if (viewport?.isReferenceViewable(metadata, WITH_NAVIGATION)) {
         return id;
       }
     }
 
-    // No viewport is in the right display set/orientation to show this, so see if
-    // the active viewport could change orientations to show this
-    if (activeViewport?.isReferenceViewable(metadata, {
-      withNavigation: true,
-      withOrientation: true
-    })) {
-      return activeViewportId;
-    }
+    // Compute view-plane alignment scores for all viewports to prefer the one
+    // requiring the least orientation change when navigation-only is not possible.
+    const viewportAlignmentData = this.getViewportAlignmentData(metadata);
 
     // See if any viewport could show this with an orientation change
-    for (const id of this.viewportsById.keys()) {
+    for (const {
+      viewportId: id
+    } of viewportAlignmentData) {
       const viewport = this.getCornerstoneViewport(id);
-      if (viewport?.isReferenceViewable(metadata, {
-        withNavigation: true,
-        withOrientation: true
-      })) {
+      if (viewport?.isReferenceViewable(metadata, WITH_ORIENTATION)) {
         return id;
       }
     }
@@ -21662,24 +21873,51 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
   }
 
   /**
-   * Figures out which viewport to update when the viewport type needs to change.
-   * This may not be the active viewport if there is already a viewport showing
-   * the display set, but in the wrong orientation.
-   *
-   * The viewport will need to update the viewport type and/or display set to
-   * display the resulting data.
-   *
-   * The first choice will be a viewport already showing the correct display set,
-   * but showing it as a stack.
+   * Given a metadata instance containing a planeRestriction, returns the
+   * ordered list of best orientation match viewport ids.
    *
-   * Second choice is to see if there is a viewport already showing the right
-   * orientation for the image, but the wrong display set.  This fixes the
-   * case where the user is in MPR and a viewport other than active should be
-   * the one to change to display the iamge.
-   *
-   * Final choice is to use the provide activeViewportId.  This will cover
-   * changes to/from video and wsi viewports and other cases where no
-   * viewport is really even close to being able to display the measurement.
+   * This uses the planeRestriction preferentially as that one is more reliably
+   * filled than the viewport normal since it is created from data points on
+   * rehydration.
+   */
+  getViewportAlignmentData(metadata) {
+    const viewportAlignmentData = [];
+    const {
+      viewPlaneNormal: refViewPlaneNormal,
+      planeRestriction
+    } = metadata;
+    const inPlaneVector1 = planeRestriction?.inPlaneVector1;
+    const inPlaneVector2 = planeRestriction?.inPlaneVector2;
+    for (const id of this.viewportsById.keys()) {
+      const viewport = this.getCornerstoneViewport(id);
+      const {
+        viewPlaneNormal
+      } = viewport.getCamera();
+      if (!viewPlaneNormal) {
+        continue;
+      }
+      let alignmentScore = 0;
+      if (inPlaneVector1 || inPlaneVector2) {
+        const inPlane1Score = inPlaneVector1 ? -Math.abs(gl_matrix_esm/* vec3.dot */.eR.dot(viewPlaneNormal, inPlaneVector1)) : 0;
+        const inPlane2Score = inPlaneVector2 ? -Math.abs(gl_matrix_esm/* vec3.dot */.eR.dot(viewPlaneNormal, inPlaneVector2)) : 0;
+        alignmentScore = inPlane1Score + inPlane2Score;
+      } else if (refViewPlaneNormal) {
+        alignmentScore = Math.abs(gl_matrix_esm/* vec3.dot */.eR.dot(viewPlaneNormal, refViewPlaneNormal));
+      }
+      viewportAlignmentData.push({
+        viewportId: id,
+        alignmentScore
+      });
+    }
+
+    // Try best-aligned viewports first
+    viewportAlignmentData.sort((a, b) => b.alignmentScore - a.alignmentScore);
+    return viewportAlignmentData;
+  }
+
+  /**
+   * Figures out which viewport to update when the viewport type needs to change.
+   * Orchestrates the search strategies in order of preference.
    */
   findUpdateableViewportConfiguration(activeViewportId, measurement) {
     const {
@@ -21687,47 +21925,98 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
       displaySetInstanceUID
     } = measurement;
     const {
-      volumeId,
-      referencedImageId
-    } = metadata;
-    const {
-      displaySetService,
-      viewportGridService
+      displaySetService
     } = this.servicesManager.services;
     const displaySet = displaySetService.getDisplaySetByUID(displaySetInstanceUID);
+
+    // 1. Determine the target Viewport Type (Stack vs Volume)
+    const viewportType = this.determineTargetViewportType(displaySet, metadata);
+
+    // 2. Strategy: Find viewport already showing this volume
+    const volumeMatch = this.findViewportShowingVolume(metadata, displaySetInstanceUID, viewportType);
+    if (volumeMatch) {
+      return volumeMatch;
+    }
+
+    // 3. Strategy: Find viewport with compatible orientation (even if different display set)
+    const compatibleMatch = this.findViewportConvertibleToVolume(metadata, displaySetInstanceUID, viewportType);
+    if (compatibleMatch) {
+      return compatibleMatch;
+    }
+
+    // 4. Strategy: Find viewport with matching orientation via IOP
+    const orientationMatch = this.findViewportWithMatchingOrientation(metadata, displaySetInstanceUID, viewportType);
+    if (orientationMatch) {
+      return orientationMatch;
+    }
+
+    // 5. Fallback: Use the active viewport
+    return {
+      viewportId: activeViewportId,
+      displaySetInstanceUID,
+      viewportOptions: {
+        viewportType
+      }
+    };
+  }
+
+  /**
+   * Determines if the viewport should be what is specified in
+   * the viewportType of the display set, or stack if the display
+   * set isn't reconstructable and there is a referenced image id, otherwise
+   * volume.
+   *
+   * Expect there to be more rules in the future for different types of annotations/settings
+   * such as 3d annotations.
+   */
+  determineTargetViewportType(displaySet, metadata) {
     let {
       viewportType
     } = displaySet;
     if (!viewportType) {
-      if (referencedImageId && !displaySet.isReconstructable) {
+      if (metadata.referencedImageId && !displaySet.isReconstructable) {
         viewportType = esm.Enums.ViewportType.STACK;
-      } else if (volumeId) {
+      } else if (metadata.volumeId) {
         viewportType = 'volume';
       }
     }
+    return viewportType;
+  }
 
-    // Find viewports that could be updated to be volumes to show this view
-    // That prefers a viewport already showing the right display set.
-    if (volumeId) {
-      for (const id of this.viewportsById.keys()) {
-        const viewport = this.getCornerstoneViewport(id);
-        if (viewport?.isReferenceViewable(metadata, {
-          asVolume: true,
-          withNavigation: true
-        })) {
-          return {
-            viewportId: id,
-            displaySetInstanceUID,
-            viewportOptions: {
-              viewportType
-            }
-          };
-        }
+  /**
+   * Find viewports that could be updated to be volumes to show this view.
+   * Prefers a viewport already showing the right display set.
+   */
+  findViewportShowingVolume(metadata, displaySetInstanceUID, viewportType) {
+    if (!metadata.volumeId) {
+      return null;
+    }
+    for (const id of this.viewportsById.keys()) {
+      const viewport = this.getCornerstoneViewport(id);
+      if (viewport?.isReferenceViewable(metadata, {
+        asVolume: true,
+        withNavigation: true
+      })) {
+        return {
+          viewportId: id,
+          displaySetInstanceUID,
+          viewportOptions: {
+            viewportType
+          }
+        };
       }
     }
+    return null;
+  }
 
-    // Find a viewport in the correct orientation showing a different display set
-    // which could be used to display the annotation.
+  /**
+   * Find a viewport that could be converted to a volume to show this annotation,
+   * already showing the right display set.
+   */
+  findViewportConvertibleToVolume(metadata, displaySetInstanceUID, viewportType) {
+    const {
+      viewportGridService
+    } = this.servicesManager.services;
     const altMetadata = {
       ...metadata,
       volumeId: null,
@@ -21739,7 +22028,7 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
       if (!viewportDisplaySetUID || !viewport) {
         continue;
       }
-      if (volumeId) {
+      if (metadata.volumeId) {
         altMetadata.volumeId = viewportDisplaySetUID;
       }
       altMetadata.FrameOfReferenceUID = this._getFrameOfReferenceUID(viewportDisplaySetUID);
@@ -21756,15 +22045,24 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
         };
       }
     }
+    return null;
+  }
 
-    // Just display in the active viewport
-    return {
-      viewportId: activeViewportId,
-      displaySetInstanceUID,
-      viewportOptions: {
-        viewportType
-      }
-    };
+  /**
+   * Find a viewport with the closest orientation but on a different display set.
+   */
+  findViewportWithMatchingOrientation(metadata, displaySetInstanceUID, viewportType) {
+    const viewportAlignmentData = this.getViewportAlignmentData(metadata);
+    if (viewportAlignmentData?.length) {
+      return {
+        ...viewportAlignmentData[0],
+        displaySetInstanceUID,
+        viewportOptions: {
+          viewportType
+        }
+      };
+    }
+    return null;
   }
 
   /**
@@ -22161,7 +22459,10 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
     segmentationService.addSegmentationRepresentation(viewport.id, {
       segmentationId,
       predecessorImageId,
-      type: representationType
+      type: representationType,
+      config: {
+        blendMode: viewport?.getBlendMode?.() === 1 ? dist_esm_enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND : undefined
+      }
     });
 
     // store the segmentation presentation id in the viewport info
@@ -22390,7 +22691,10 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
       if (hydrated) {
         segmentationService.addSegmentationRepresentation(viewport.id, {
           segmentationId,
-          type: representationType
+          type: representationType,
+          config: {
+            blendMode: viewport?.getBlendMode?.() === 1 ? dist_esm_enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND : undefined
+          }
         });
       }
     });
@@ -23215,7 +23519,7 @@ const hasExportableContourData = contour => {
 
 function PanelSegmentation({
   children,
-  segmentationRepresentationType
+  segmentationRepresentationTypes
 }) {
   const {
     commandsManager,
@@ -23236,8 +23540,8 @@ function PanelSegmentation({
     [esm_enums.SegmentationRepresentations.Contour]: toolbarService.sections.contourSegmentationUtilities
   };
   const selectedSegmentationsForViewportMap = useSelectedSegmentationsForViewportStore(store => store.selectedSegmentationsForViewport[activeViewportId]);
-  const selectedSegmentationIdForType = segmentationRepresentationType ? selectedSegmentationsForViewportMap?.get(segmentationRepresentationType) : segmentationService?.getActiveSegmentation(activeViewportId)?.segmentationId;
-  const buttonSection = utilitiesSectionMap[segmentationRepresentationType];
+  const selectedSegmentationIdForType = segmentationRepresentationTypes ? segmentationRepresentationTypes.reduce((selectedSegmentation, type) => selectedSegmentation || (selectedSegmentationsForViewportMap?.has(type) ? selectedSegmentationsForViewportMap?.get(type) : undefined), undefined) : segmentationService?.getActiveSegmentation(activeViewportId)?.segmentationId;
+  const buttonSection = segmentationRepresentationTypes?.[0] ? utilitiesSectionMap[segmentationRepresentationTypes[0]] : undefined;
   const {
     activeToolOptions: activeUtilityOptions
   } = (0,src/* useActiveToolOptions */.KP)({
@@ -23326,7 +23630,7 @@ function PanelSegmentation({
         segmentIndex
       });
     },
-    onSegmentCopy: segmentationRepresentationType === esm_enums.SegmentationRepresentations.Contour ? (segmentationId, segmentIndex) => {
+    onSegmentCopy: segmentationRepresentationTypes?.[0] === esm_enums.SegmentationRepresentations.Contour ? (segmentationId, segmentIndex) => {
       commandsManager.run('copyContourSegment', {
         sourceSegmentInfo: {
           segmentationId,
@@ -23489,13 +23793,13 @@ function PanelSegmentation({
     disabled,
     data: segmentationsWithRepresentations,
     mode: segmentationTableMode,
-    title: `${segmentationRepresentationType ? `${segmentationRepresentationType} ` : ''}Segmentations`,
+    title: `${segmentationRepresentationTypes?.[0] ? `${segmentationRepresentationTypes[0]} ` : ''}Segmentations`,
     exportOptions,
     disableEditing,
     onSegmentationAdd,
     showAddSegment,
     renderInactiveSegmentations: handlers.getRenderInactiveSegmentations(),
-    segmentationRepresentationType,
+    segmentationRepresentationTypes,
     selectedSegmentationIdForType,
     ...handlers
   };
@@ -23556,16 +23860,17 @@ const workerFn = () => {
     name: 'histogram-worker' // name used by the browser to name the worker
   });
 };
+
+// Register worker once at module load time
+workerManager.registerWorker('histogram-worker', workerFn, WorkerOptions);
 const getViewportVolumeHistogram = async (viewport, volume, options) => {
-  workerManager.registerWorker('histogram-worker', workerFn, WorkerOptions);
   const volumeImageData = viewport.getImageData(volume.volumeId);
   if (!volumeImageData) {
     return undefined;
   }
   let scalarData = volume.scalarData;
   if (volume.numTimePoints > 1) {
-    const targetTimePoint = volume.numTimePoints - 1; // or any other time point you need
-    scalarData = volume.voxelManager.getTimePointScalarData(targetTimePoint);
+    scalarData = volume.voxelManager.getDimensionGroupScalarData(volume.numTimePoints);
   } else {
     scalarData = volume.voxelManager.getCompleteScalarDataArray();
   }
@@ -23614,6 +23919,9 @@ const getViewportVolumeHistogram = async (viewport, volume, options) => {
  * Gets node opacity from volume actor
  */
 const getNodeOpacity = (volumeActor, nodeIndex) => {
+  if (!volumeActor) {
+    return undefined;
+  }
   const volumeOpacity = volumeActor.getProperty().getScalarOpacity(0);
   const nodeValue = [];
   volumeOpacity.getNodeValue(nodeIndex, nodeValue);
@@ -23624,6 +23932,9 @@ const getNodeOpacity = (volumeActor, nodeIndex) => {
  * Checks if the opacity applied to the PET volume follows a specific pattern
  */
 const isPetVolumeWithDefaultOpacity = (volumeId, volumeActor) => {
+  if (!volumeActor) {
+    return false;
+  }
   const volume = esm.cache.getVolume(volumeId);
   if (!volume || volume.metadata.Modality !== 'PT') {
     return false;
@@ -23655,6 +23966,9 @@ const isPetVolumeWithDefaultOpacity = (volumeId, volumeActor) => {
  * Checks if volume has constant opacity
  */
 const isVolumeWithConstantOpacity = volumeActor => {
+  if (!volumeActor) {
+    return false;
+  }
   const volumeOpacity = volumeActor.getProperty().getScalarOpacity(0);
   const opacitySize = volumeOpacity.getSize();
   const firstNodeValue = [];
@@ -23681,7 +23995,7 @@ const getWindowLevelsData = async (viewport, viewportInfo, getVolumeOpacity) =>
   const viewportProperties = viewport.getProperties();
   const {
     voiRange
-  } = viewportProperties;
+  } = viewportProperties || {};
   const viewportVoi = voiRange ? {
     windowWidth: voiRange.upper - voiRange.lower,
     windowCenter: voiRange.lower + (voiRange.upper - voiRange.lower) / 2
@@ -24280,6 +24594,7 @@ function StudySummaryFromMetadata(props) {
 
 
 
+
 function StudyMeasurementsActions({
   items,
   StudyInstanceUID,
@@ -24289,6 +24604,9 @@ function StudyMeasurementsActions({
   const {
     commandsManager
   } = (0,src/* useSystem */.Jg)();
+  const {
+    t
+  } = (0,es/* useTranslation */.Bd)('MeasurementTable');
   const disabled = !items?.length;
   if (disabled) {
     return null;
@@ -24329,7 +24647,7 @@ function StudyMeasurementsActions({
         measurementFilter
       });
     }
-  }, /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.Add, null), "Create SR"), /*#__PURE__*/react.createElement(ui_next_src/* Button */.$nd, {
+  }, /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.Add, null), t('Create SR')), /*#__PURE__*/react.createElement(ui_next_src/* Button */.$nd, {
     size: "sm",
     variant: "ghost",
     className: "pl-0.5",
@@ -24343,7 +24661,7 @@ function StudyMeasurementsActions({
         measurementFilter
       });
     }
-  }, /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.Delete, null), "Delete")));
+  }, /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.Delete, null), t('Delete'))));
 }
 /* harmony default export */ const components_StudyMeasurementsActions = (StudyMeasurementsActions);
 ;// ../../../extensions/cornerstone/src/components/StudySummaryWithActions.tsx
@@ -24549,7 +24867,7 @@ const getPanelModule = ({
       configuration: {
         ...props?.configuration
       },
-      segmentationRepresentationType: props?.segmentationRepresentationType
+      segmentationRepresentationTypes: props?.segmentationRepresentationTypes
     });
   };
   const wrappedPanelSegmentationNoHeader = props => {
@@ -24560,17 +24878,17 @@ const getPanelModule = ({
       configuration: {
         ...props?.configuration
       },
-      segmentationRepresentationType: props?.segmentationRepresentationType
+      segmentationRepresentationTypes: props?.segmentationRepresentationTypes
     });
   };
   const wrappedPanelSegmentationWithTools = props => {
     const {
       t
-    } = (0,es/* useTranslation */.Bd)('SegmentationTable');
-    const tKey = `${props.segmentationRepresentationType ?? 'Segmentation'} tools`;
+    } = (0,es/* useTranslation */.Bd)('SegmentationPanel');
+    const tKey = `${props.segmentationRepresentationTypes?.[0] ?? 'Segmentation'} tools`;
     const tValue = t(tKey);
     return /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement(default_src.Toolbox, {
-      buttonSectionId: toolSectionMap[props.segmentationRepresentationType],
+      buttonSectionId: toolSectionMap[props.segmentationRepresentationTypes?.[0]],
       title: tValue
     }), /*#__PURE__*/react.createElement(PanelSegmentation, {
       commandsManager: commandsManager,
@@ -24579,7 +24897,7 @@ const getPanelModule = ({
       configuration: {
         ...props?.configuration
       },
-      segmentationRepresentationType: props?.segmentationRepresentationType
+      segmentationRepresentationTypes: props?.segmentationRepresentationTypes
     }));
   };
   return [{
@@ -24611,19 +24929,19 @@ const getPanelModule = ({
     name: 'panelSegmentationWithToolsLabelMap',
     iconName: 'tab-segmentation',
     iconLabel: 'Segmentation',
-    label: i18n_src/* default */.A.t('SegmentationTable:Labelmap'),
+    label: i18n_src/* default */.A.t('SegmentationPanel:Labelmap'),
     component: props => wrappedPanelSegmentationWithTools({
       ...props,
-      segmentationRepresentationType: esm_enums.SegmentationRepresentations.Labelmap
+      segmentationRepresentationTypes: [esm_enums.SegmentationRepresentations.Labelmap, esm_enums.SegmentationRepresentations.Surface]
     })
   }, {
     name: 'panelSegmentationWithToolsContour',
     iconName: 'tab-contours',
     iconLabel: 'Segmentation',
-    label: i18n_src/* default */.A.t('SegmentationTable:Contour'),
+    label: i18n_src/* default */.A.t('SegmentationPanel:Contour'),
     component: props => wrappedPanelSegmentationWithTools({
       ...props,
-      segmentationRepresentationType: esm_enums.SegmentationRepresentations.Contour
+      segmentationRepresentationTypes: [esm_enums.SegmentationRepresentations.Contour]
     })
   }];
 };
@@ -24663,7 +24981,7 @@ const handleSegmentChange = ({
   // Functions below use the segmentIndex object attribute so we have to do the conversion
   const segmentIndex = Object.values(segments)[newSelectedSegmentIndex]?.segmentIndex;
   segmentationService.setActiveSegment(segmentationId, segmentIndex);
-  segmentationService.jumpToSegmentCenter(segmentationId, segmentIndex, viewportId);
+  segmentationService.jumpToSegmentNext(segmentationId, segmentIndex, undefined, direction);
   selectedSegmentObjectIndex = newSelectedSegmentIndex;
 };
 ;// ../../../extensions/cornerstone/src/utils/isReferenceViewable.ts
@@ -25124,11 +25442,15 @@ const setUpAnnotationEventHandlers = () => {
 
 
 
+
 function MeasumentsMenu(props) {
   const {
     group,
     classNames
   } = props;
+  const {
+    t
+  } = (0,es/* useTranslation */.Bd)('MeasurementTable');
   if (!group.items?.length) {
     console.log('No items to iterate', group.items);
     return null;
@@ -25160,7 +25482,7 @@ function MeasumentsMenu(props) {
     size: "icon",
     variant: "ghost",
     className: `h-6 w-6 transition-opacity ${isSelected || !isVisible ? 'opacity-100' : 'opacity-50 group-hover:opacity-100'}`,
-    "aria-label": isVisible ? 'Hide' : 'Show',
+    "aria-label": isVisible ? t('Hide') : t('Show'),
     onClick: e => {
       e.stopPropagation();
       onAction(e, ['jumpToMeasurement', 'toggleVisibilityMeasurement']);
@@ -25189,7 +25511,7 @@ function MeasumentsMenu(props) {
     className: "text-foreground"
   }), /*#__PURE__*/react.createElement("span", {
     className: "pl-2"
-  }, "Delete")))));
+  }, t('Delete'))))));
 }
 /* harmony default export */ const MeasurementsMenu = (MeasumentsMenu);
 ;// ../../../extensions/cornerstone/src/components/PanelAccordionTrigger.tsx