@ohif/app 3.13.0-beta.122 → 3.13.0-beta.123

package/dist/{1206.bundle.e04ca1efe6f987ba.js → 1206.bundle.8ca95ea92d278d25.js}

@@ -9,7 +9,7 @@ __webpack_require__.d(__webpack_exports__, {
 /* import */ var prop_types__rspack_import_1 = __webpack_require__(97598);
 /* import */ var prop_types__rspack_import_1_default = /*#__PURE__*/__webpack_require__.n(prop_types__rspack_import_1);
 /* import */ var _ohif_ui_next__rspack_import_2 = __webpack_require__(39987);
-/* import */ var _ohif_extension_cornerstone__rspack_import_3 = __webpack_require__(86714);
+/* import */ var _ohif_extension_cornerstone__rspack_import_3 = __webpack_require__(75609);
 /* import */ var _cornerstonejs_tools__rspack_import_4 = __webpack_require__(55526);
 /* import */ var _getContextModule__rspack_import_5 = __webpack_require__(28835);
 /* import */ var _cornerstonejs_core__rspack_import_6 = __webpack_require__(88479);

package/dist/{1602.bundle.cd2e106bd1438fbb.js → 1602.bundle.adc9c42f3f0cee10.js}

@@ -1114,10 +1114,10 @@ function WorkflowPanel({
 
 
 
-// EXTERNAL MODULE: ../../../extensions/default/src/index.ts + 147 modules
-var default_src = __webpack_require__(7825);
-// EXTERNAL MODULE: ../../../extensions/cornerstone/src/index.tsx + 200 modules
-var cornerstone_src = __webpack_require__(86714);
+// EXTERNAL MODULE: ../../../extensions/default/src/index.ts + 148 modules
+var default_src = __webpack_require__(50904);
+// EXTERNAL MODULE: ../../../extensions/cornerstone/src/index.tsx + 211 modules
+var cornerstone_src = __webpack_require__(75609);
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone-dynamic-volume/src/panels/DynamicExport.tsx
 
 

package/dist/{2493.bundle.f3b6a64d158365da.js → 2493.bundle.d16ea70ddcc1fb6b.js}

@@ -34559,11 +34559,24 @@ class DefaultPlanarDataProvider {
             const imageIds = imageVolume.imageIds
                 ? imageVolume.imageIds
                 : dataSet.imageIds;
+            let volumeInitialImageIdIndex = initialImageIdIndex;
+            if (initialImageIdIndex !== undefined && imageIds !== dataSet.imageIds) {
+                const requestedImageId = dataSet.imageIds[initialImageIdIndex];
+                const remappedIndex = imageIds.indexOf(requestedImageId);
+                if (remappedIndex >= 0) {
+                    volumeInitialImageIdIndex = remappedIndex;
+                }
+                else {
+                    console.warn(`[PlanarViewport] initialImageIdIndex remap failed: imageId ` +
+                        `"${requestedImageId}" not found in the volume imageIds; ` +
+                        `using the original index ${initialImageIdIndex}`);
+                }
+            }
             return {
                 id: dataId,
                 type: 'image',
                 imageIds,
-                initialImageIdIndex,
+                initialImageIdIndex: volumeInitialImageIdIndex,
                 acquisitionOrientation: options.acquisitionOrientation,
                 imageData: dataSet.imageData,
                 imageVolume,
@@ -38838,6 +38851,7 @@ function getPlanarResolvedViewForReference(args) {
 
 
 
+
 class PlanarViewReferenceController {
     constructor(host) {
         this.host = host;
@@ -39086,7 +39100,7 @@ class PlanarViewReferenceController {
         const effectiveViewPlaneNormal = refViewPlaneNormal ?? currentViewPlaneNormal;
         const isOppositeNormal = !shouldReorient &&
             this.areNormalsOpposite(currentViewPlaneNormal, effectiveViewPlaneNormal);
-        const nextImageIdIndex = this.resolveVolumeReferenceImageIdIndex(referenceContext, normalizedViewRef, effectiveViewPlaneNormal, isOppositeNormal);
+        const sliceTarget = this.resolveVolumeReferenceSliceTarget(referenceContext, normalizedViewRef, effectiveViewPlaneNormal, isOppositeNormal);
         const viewStatePatch = {};
         if (shouldReorient && refViewPlaneNormal) {
             viewStatePatch.orientation = {
@@ -39099,8 +39113,9 @@ class PlanarViewReferenceController {
             };
         }
         const sliceWorldPoint = normalizedViewRef.cameraFocalPoint ??
-            (typeof nextImageIdIndex === 'number'
-                ? this.host.getVolumeSliceWorldPointForImageIdIndex(nextImageIdIndex)
+            sliceTarget?.sliceWorldPoint ??
+            (typeof sliceTarget?.imageIdIndex === 'number'
+                ? this.host.getVolumeSliceWorldPointForImageIdIndex(sliceTarget.imageIdIndex)
                 : undefined);
         if (sliceWorldPoint) {
             viewStatePatch.slice = {
@@ -39178,7 +39193,7 @@ class PlanarViewReferenceController {
             (!planeRestriction.inPlaneVector2 ||
                 (0,utilities_isEqual/* ["default"] */.Ay)(0, esm/* .vec3.dot */.eR.Om(viewPlaneNormal, planeRestriction.inPlaneVector2))));
     }
-    resolveVolumeReferenceImageIdIndex(referenceContext, viewRef, effectiveViewPlaneNormal, isOppositeNormal) {
+    resolveVolumeReferenceSliceTarget(referenceContext, viewRef, effectiveViewPlaneNormal, isOppositeNormal) {
         const { rendering } = referenceContext;
         if (rendering.renderMode !== types/* .ActorRenderMode.CPU_VOLUME */.T.CPU_VOLUME &&
             rendering.renderMode !== types/* .ActorRenderMode.VTK_VOLUME_SLICE */.T.VTK_VOLUME_SLICE) {
@@ -39192,21 +39207,35 @@ class PlanarViewReferenceController {
             const targetSliceIndex = isOppositeNormal
                 ? maxImageIdIndex - viewRef.sliceIndex
                 : viewRef.sliceIndex;
-            return Math.min(Math.max(0, targetSliceIndex), maxImageIdIndex);
+            return {
+                imageIdIndex: Math.min(Math.max(0, targetSliceIndex), maxImageIdIndex),
+            };
         }
         const referencedImageIndex = this.findImageIdIndexByReference(imageIds, viewRef.referencedImageId, viewRef.referencedImageURI);
         if (typeof referencedImageIndex === 'number') {
-            return referencedImageIndex;
+            return this.toVolumeSliceTarget(rendering.imageVolume, referencedImageIndex);
         }
         const targetPoint = viewRef.cameraFocalPoint ?? viewRef.planeRestriction?.point;
         if (targetPoint) {
             const referencedImageId = (0,getClosestImageId/* ["default"] */.A)(rendering.imageVolume, targetPoint, effectiveViewPlaneNormal);
-            return this.findImageIdIndexByReference(imageIds, referencedImageId);
+            const closestImageIndex = this.findImageIdIndexByReference(imageIds, referencedImageId);
+            if (typeof closestImageIndex === 'number') {
+                return this.toVolumeSliceTarget(rendering.imageVolume, closestImageIndex);
+            }
+            return;
         }
         if (typeof viewRef.sliceIndex === 'number') {
-            return Math.min(Math.max(0, viewRef.sliceIndex), maxImageIdIndex);
+            return {
+                imageIdIndex: Math.min(Math.max(0, viewRef.sliceIndex), maxImageIdIndex),
+            };
         }
     }
+    toVolumeSliceTarget(imageVolume, imageIdListIndex) {
+        const sliceWorldPoint = (0,planarSliceBasis/* .getVolumeImageIdIndexWorldPoint */.xH)(imageVolume, imageIdListIndex);
+        return sliceWorldPoint
+            ? { sliceWorldPoint }
+            : { imageIdIndex: imageIdListIndex };
+    }
     getImageIdsForReferenceContext(referenceContext) {
         return (referenceContext.data.imageVolume?.imageIds ||
             referenceContext.data.imageIds);
@@ -40309,6 +40338,15 @@ class PlanarViewport extends GenericViewport/* ["default"] */.A {
         const initialImageIdIndex = orientation === enums.OrientationAxis.ACQUISITION
             ? planarData.initialImageIdIndex
             : undefined;
+        if (typeof initialImageIdIndex === 'number') {
+            const sliceWorldPoint = (0,planarSliceBasis/* .getVolumeImageIdIndexWorldPoint */.xH)(planarData.imageVolume, initialImageIdIndex);
+            if (sliceWorldPoint) {
+                return {
+                    kind: 'volumePoint',
+                    sliceWorldPoint,
+                };
+            }
+        }
         const { sliceBasis } = createSliceBasis({
             canvasHeight: height,
             canvasWidth: width,
@@ -41861,6 +41899,7 @@ __webpack_require__.d(__webpack_exports__, {
   vu: () => (/* binding */ createPlanarCpuVolumeSliceBasis),
   IY: () => (/* binding */ createPlanarImageSliceBasis),
   P8: () => (/* binding */ createPlanarVolumeSliceBasis),
+  xH: () => (/* binding */ getVolumeImageIdIndexWorldPoint),
   Dn: () => (/* binding */ resolvePlanarVolumeImageIdIndex),
   LK: () => (/* binding */ shouldUsePlanarCpuVolumeSliceBasis)
 });
@@ -42068,6 +42107,23 @@ function getGeometricImageVolumeCenter(imageVolume, viewPlaneNormal) {
     }
     return esm/* .vec3.scale */.eR.hs(center, center, 1 / corners.length);
 }
+function getVolumeImageIdIndexWorldPoint(imageVolume, imageIdIndex) {
+    const imageData = imageVolume?.imageData;
+    if (!imageData) {
+        return;
+    }
+    const dimensions = imageData.getDimensions();
+    const flatToGroupLocal = imageVolume.flatImageIdIndexToImageIdIndex;
+    const groupLocalIndex = typeof flatToGroupLocal === 'function'
+        ? flatToGroupLocal.call(imageVolume, Math.max(0, imageIdIndex))
+        : imageIdIndex;
+    const k = Math.min(Math.max(0, groupLocalIndex), dimensions[2] - 1);
+    return imageData.indexToWorld([
+        (dimensions[0] - 1) / 2,
+        (dimensions[1] - 1) / 2,
+        k,
+    ]);
+}
 function getSliceMetrics(args) {
     const { imageVolume, viewPlaneNormal } = args;
     const corners = buildImageVolumeCorners(imageVolume);
@@ -81342,7 +81398,7 @@ function worldToImageCoords(imageId, worldCoords) {
 },
 22202() {
 "use strict";
-const version = '5.4.13';
+const version = '5.4.17';
 
 
 },
@@ -82115,7 +82171,7 @@ const TransferSyntaxes = {
 
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/metadata/dist/esm/version.js
-const version = '5.4.13';
+const version = '5.4.17';
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/metadata/dist/esm/metaData.js
 
@@ -96438,7 +96494,7 @@ __webpack_require__.d(logging_namespaceObject, {
 
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/utils/dist/esm/version.js
-const version = '5.4.13';
+const version = '5.4.17';
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/utils/dist/esm/utilities/object/asArray.js
 function asArray(item) {

package/dist/{7231.bundle.1063d727ad99108a.js → 2623.bundle.983a376f7b7e86a5.js}

@@ -1,6 +1,6 @@
 "use strict";
-(globalThis["rspackChunk"] = globalThis["rspackChunk"] || []).push([[7231], {
-3538(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+(globalThis["rspackChunk"] = globalThis["rspackChunk"] || []).push([[2623], {
+27074(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 // ESM COMPAT FLAG
 __webpack_require__.r(__webpack_exports__);
 
@@ -27,12 +27,74 @@ var prop_types = __webpack_require__(97598);
 var prop_types_default = /*#__PURE__*/__webpack_require__.n(prop_types);
 // EXTERNAL MODULE: ../../../extensions/cornerstone/src/utils/getLegacyViewportType.ts
 var getLegacyViewportType = __webpack_require__(50342);
+;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/utils/viewportDataShape.ts
+
+
+/**
+ * Pre-mount classification of a viewport's bound data (viewportData from
+ * CornerstoneCacheService), for code that runs before — or independently of —
+ * a live viewport instance (overlays, scrollbars). Native ("next") viewports
+ * collapse stack/volume onto a single PLANAR_NEXT viewportType, so these
+ * helpers classify by the persisted dataShapeType and the data shape itself
+ * (imageIds = stack, volume/volumeId = volume) instead of the runtime type.
+ *
+ * For classification of a LIVE viewport instance, use
+ * `getViewportAdapter(viewport).getShape()` instead.
+ */
+
+/** The primary (non-overlay) datum of a viewportData. */
+function getPrimaryViewportDatum(viewportData) {
+  return Array.isArray(viewportData?.data) ? viewportData.data[0] : viewportData?.data;
+}
+
+/** True when the primary datum is volume-shaped (volume/volumeId present). */
+function isVolumeViewportData(viewportData) {
+  const firstData = getPrimaryViewportDatum(viewportData);
+  return !!(firstData && (firstData.volume || firstData.volumeId));
+}
+
+/**
+ * The stack/volume shape a viewportData was built for, transparent across the
+ * native type collapse: the persisted dataShapeType when present (set by
+ * CornerstoneCacheService on the native path), else the legacy viewportType.
+ */
+function getViewportDataShapeType(viewportData) {
+  return viewportData?.dataShapeType ?? viewportData?.viewportType;
+}
+
+/**
+ * The slice-navigation event for this viewport's content. Resolved from the
+ * legacy viewportType when it is meaningful, else from the bound data shape —
+ * which is known immediately, unlike a runtime content-mode check that may not
+ * be ready while a native viewport is still binding. Native viewports emit the
+ * same STACK_NEW_IMAGE / VOLUME_NEW_IMAGE events as legacy.
+ */
+function getSliceEventName(viewportData) {
+  const {
+    viewportType
+  } = viewportData;
+  const firstData = getPrimaryViewportDatum(viewportData);
+  return viewportType === esm.Enums.ViewportType.STACK && esm.Enums.Events.STACK_NEW_IMAGE || viewportType === esm.Enums.ViewportType.ORTHOGRAPHIC && esm.Enums.Events.VOLUME_NEW_IMAGE || isVolumeViewportData(viewportData) && esm.Enums.Events.VOLUME_NEW_IMAGE || firstData?.imageIds && esm.Enums.Events.STACK_NEW_IMAGE || esm.Enums.Events.IMAGE_RENDERED;
+}
+
+/**
+ * The slice count for a viewport. `viewport.getNumberOfSlices()` can be
+ * premature while a native viewport is still binding its data (it returns 1
+ * until then). For an image stack the count is known from the bound data, so
+ * prefer that and only fall back to the viewport for volume/MPR (where the
+ * count depends on orientation).
+ */
+function getViewportSliceCount(viewportData, viewport) {
+  const firstData = getPrimaryViewportDatum(viewportData);
+  return !isVolumeViewportData(viewportData) && firstData?.imageIds?.length || viewport.getNumberOfSlices();
+}
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/Viewport/Overlays/ViewportImageScrollbar.tsx
 
 
 
 
 
+
 function CornerstoneImageScrollbar({
   viewportData,
   viewportId,
@@ -76,9 +138,9 @@ function CornerstoneImageScrollbar({
     }
     try {
       const imageIndex = viewport.getCurrentImageIdIndex();
-      const numberOfSlices = viewport.getNumberOfSlices();
+      const numberOfSlices = getViewportSliceCount(viewportData, viewport);
       setImageSliceData({
-        imageIndex: imageIndex,
+        imageIndex,
         numberOfSlices
       });
     } catch (error) {
@@ -89,10 +151,7 @@ function CornerstoneImageScrollbar({
     if (!viewportData) {
       return;
     }
-    const {
-      viewportType
-    } = viewportData;
-    const eventId = viewportType === esm.Enums.ViewportType.STACK && esm.Enums.Events.STACK_NEW_IMAGE || viewportType === esm.Enums.ViewportType.ORTHOGRAPHIC && esm.Enums.Events.VOLUME_NEW_IMAGE || esm.Enums.Events.IMAGE_RENDERED;
+    const eventId = getSliceEventName(viewportData);
     const updateIndex = event => {
       const viewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
       if (!viewport || (0,getLegacyViewportType/* .isVolume3DViewportType */.Ov)(viewport)) {
@@ -132,6 +191,8 @@ CornerstoneImageScrollbar.propTypes = {
   servicesManager: (prop_types_default()).object.isRequired
 };
 /* export default */ const ViewportImageScrollbar = (CornerstoneImageScrollbar);
+// EXTERNAL MODULE: ../../../extensions/cornerstone/src/services/ViewportService/adapter/index.ts + 3 modules
+var ViewportService_adapter = __webpack_require__(71166);
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/Viewport/Overlays/ViewportSliceProgressScrollbar/helpers.ts
 
 
@@ -156,11 +217,18 @@ function isProgressFullMode(viewportData, viewport) {
   if (!viewportData || !viewport || (0,getLegacyViewportType/* .isVolume3DViewportType */.Ov)(viewport)) {
     return false;
   }
-  if (viewportData.viewportType === esm.Enums.ViewportType.STACK) {
+
+  // A stack renders the full progress UI; an acquisition-plane volume is the
+  // volume-mode equivalent. The adapter classifies both lanes (legacy by
+  // viewport type / isInAcquisitionPlane; native by content mode + view-state
+  // orientation, since PLANAR_NEXT collapses the runtime type).
+  const adapter = (0,ViewportService_adapter/* .getViewportAdapter */.qU)(viewport);
+  const shape = adapter.getShape();
+  if (shape === 'stack') {
     return true;
   }
-  if (viewportData.viewportType === esm.Enums.ViewportType.ORTHOGRAPHIC) {
-    return !!viewport.isInAcquisitionPlane?.();
+  if (shape === 'volume') {
+    return adapter.isInAcquisitionPlane();
   }
   return false;
 }
@@ -174,6 +242,7 @@ function getImageIdFromCacheEvent(event) {
 
 
 
+
 function useProgressScrollbarMode({
   viewportData,
   viewportId,
@@ -242,23 +311,51 @@ function useViewportSliceSync({
     if (!viewportData) {
       return;
     }
-    const viewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
-    if (viewport && !(0,getLegacyViewportType/* .isVolume3DViewportType */.Ov)(viewport)) {
+
+    // Last values we pushed, so re-seeding on camera changes does not churn React
+    // state on pure pan/zoom (which keep the slice geometry unchanged).
+    const lastSlice = {
+      imageIndex: -1,
+      numberOfSlices: -1
+    };
+    const pushSliceData = (imageIndex, numberOfSlices) => {
+      if (imageIndex === lastSlice.imageIndex && numberOfSlices === lastSlice.numberOfSlices) {
+        return;
+      }
+      lastSlice.imageIndex = imageIndex;
+      lastSlice.numberOfSlices = numberOfSlices;
+      setImageSliceData({
+        imageIndex,
+        numberOfSlices
+      });
+    };
+
+    // Seeds the shared slice state from the live viewport. Re-run on the initial
+    // effect and on camera/orientation changes (below).
+    const syncFromViewport = () => {
+      const viewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
+      if (!viewport || (0,getLegacyViewportType/* .isVolume3DViewportType */.Ov)(viewport)) {
+        return;
+      }
       try {
         const currentImageIndex = viewport.getCurrentImageIdIndex();
-        const currentNumberOfSlices = viewport.getNumberOfSlices();
-        setImageSliceData({
-          imageIndex: currentImageIndex,
-          numberOfSlices: currentNumberOfSlices
-        });
+        const currentNumberOfSlices = getViewportSliceCount(viewportData, viewport);
+        pushSliceData(currentImageIndex, currentNumberOfSlices);
       } catch (error) {
         console.warn(error);
       }
-    }
-    const {
-      viewportType
-    } = viewportData;
-    const eventId = viewportType === esm.Enums.ViewportType.STACK && esm.Enums.Events.STACK_NEW_IMAGE || viewportType === esm.Enums.ViewportType.ORTHOGRAPHIC && esm.Enums.Events.VOLUME_NEW_IMAGE || esm.Enums.Events.IMAGE_RENDERED;
+    };
+    syncFromViewport();
+
+    // A post-mount camera carry (e.g. the layout-selector MPR protocol restoring
+    // the prior stack slice onto the freshly-mounted volume viewport) moves the
+    // camera and fires its slice events synchronously during the mount — before
+    // these listeners attach and around the initial seed above — so the scrollbar
+    // can latch the mount-time index instead of the carried slice. Re-seed once on
+    // the next frame, after the mount+carry settles; pushSliceData makes it a
+    // no-op when nothing changed (no churn/flicker).
+    const reseedRaf = requestAnimationFrame(syncFromViewport);
+    const eventId = getSliceEventName(viewportData);
     const updateIndex = event => {
       const viewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
       if (!viewport || (0,getLegacyViewportType/* .isVolume3DViewportType */.Ov)(viewport)) {
@@ -269,14 +366,20 @@ function useViewportSliceSync({
         return;
       }
       const nextNumberOfSlices = viewport.getNumberOfSlices();
-      setImageSliceData({
-        imageIndex: nextImageIndex,
-        numberOfSlices: nextNumberOfSlices
-      });
+      pushSliceData(nextImageIndex, nextNumberOfSlices);
     };
     element.addEventListener(eventId, updateIndex);
+    // Native ("next") viewports keep the same viewportData across a stack->volume
+    // transition or an orientation change, so this effect does not re-run and the
+    // slice-navigation event above may not fire until the first scroll, leaving the
+    // scrollbar unseeded (or stale, with a now-wrong slice count). CAMERA_MODIFIED
+    // fires on those orientation/geometry changes, so re-seed from the viewport
+    // then; the pushSliceData guard makes pan/zoom (same geometry) a no-op.
+    element.addEventListener(esm.Enums.Events.CAMERA_MODIFIED, syncFromViewport);
     return () => {
+      cancelAnimationFrame(reseedRaf);
       element.removeEventListener(eventId, updateIndex);
+      element.removeEventListener(esm.Enums.Events.CAMERA_MODIFIED, syncFromViewport);
     };
   }, [viewportData, element, viewportId, cornerstoneViewportService, setImageSliceData]);
 }
@@ -674,6 +777,8 @@ var hooks = __webpack_require__(2242);
 
 
 
+
+
 const EPSILON = 1e-4;
 const {
   formatPN,
@@ -850,7 +955,7 @@ function getDisplaySets(viewportData, displaySetService) {
 }
 const getInstanceNumber = (viewportData, viewportId, imageIndex, cornerstoneViewportService) => {
   let instanceNumber;
-  switch (viewportData.viewportType) {
+  switch (getViewportDataShapeType(viewportData)) {
     case esm.Enums.ViewportType.STACK:
       instanceNumber = _getInstanceNumberFromStack(viewportData, imageIndex);
       break;
@@ -901,10 +1006,10 @@ function _getInstanceNumberFromVolume(viewportData, viewportId, cornerstoneViewp
   if (!cornerstoneViewport) {
     return;
   }
-  const camera = cornerstoneViewport.getCamera();
-  const {
-    viewPlaneNormal
-  } = camera;
+  const viewPlaneNormal = (0,ViewportService_adapter/* .getViewportAdapter */.qU)(cornerstoneViewport).getViewPlaneNormal();
+  if (!viewPlaneNormal) {
+    return;
+  }
   // checking if camera is looking at the acquisition plane (defined by the direction on the volume)
 
   const scanAxisNormal = direction.slice(6, 9);
@@ -1055,6 +1160,7 @@ var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
 
 
 
+
 const {
   getOrientationStringLPS,
   invertOrientationStringLPS
@@ -1094,7 +1200,10 @@ function ViewportOrientationMarkers({
       console.log(`ViewportOrientationMarkers :: No viewport (${viewportId})`);
       return '';
     }
-    if (viewportData.viewportType === 'stack') {
+
+    // Use the persisted data shape, not viewportType: a native stack reports
+    // PLANAR_NEXT, which would skip this synthetic-IOP default-cosine guard.
+    if (getViewportDataShapeType(viewportData) === esm.Enums.ViewportType.STACK) {
       const imageIndex = imageSliceData.imageIndex;
       const imageId = viewportData.data[0].imageIds?.[imageIndex];
 

package/dist/{3330.bundle.b1297ef8c94e5440.js → 3330.bundle.1b8bc8f7c4071336.js}

@@ -8252,7 +8252,7 @@ const onSegmentationDataModified = function (evt) {
     if (representationData.Labelmap) {
         onLabelmapSegmentationDataModified(evt);
     }
-    triggerSegmentationRenderBySegmentationId(segmentationId);
+    triggerSegmentationRenderForModified(segmentationId);
 };
 /* export default */ const segmentation_segmentationDataModifiedEventListener = ((/* unused pure expression or super */ null && (onSegmentationDataModified)));
 
@@ -10217,7 +10217,7 @@ var COLOR_LUT = __webpack_require__(69501);
 
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/version.js
-const version = '5.4.13';
+const version = '5.4.17';
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/viewportPresentation.js
 var viewportPresentation = __webpack_require__(88299);
@@ -36585,6 +36585,50 @@ function triggerSegmentationRender(viewportId) {
 function triggerSegmentationRenderBySegmentationId(segmentationId) {
     segmentationRenderingEngine.renderSegmentation(segmentationId);
 }
+const DEFERRED_SEGMENTATION_RENDER_DELAY_MS = 240;
+const deferredSegmentationRenderTimers = new Map();
+function isProjectionHeavySegmentationViewport(viewport) {
+    const blendMode = viewport.getBlendMode?.();
+    if (blendMode === Enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND) {
+        return true;
+    }
+    const planarViewport = viewport;
+    if (typeof planarViewport.getDisplaySetPresentation !== 'function') {
+        return false;
+    }
+    const dataIds = [];
+    const sourceDataId = planarViewport.getSourceDataId?.();
+    if (sourceDataId) {
+        dataIds.push(sourceDataId);
+    }
+    planarViewport.getActors?.().forEach((actorEntry) => {
+        if (actorEntry.representationUID) {
+            dataIds.push(String(actorEntry.representationUID));
+        }
+    });
+    return dataIds.some((dataId) => (planarViewport.getDisplaySetPresentation(dataId)?.slabThickness ?? 0) > 0);
+}
+function triggerSegmentationRenderForModified(segmentationId) {
+    const viewportIds = segmentationRenderingEngine._getViewportIdsForSegmentation(segmentationId);
+    viewportIds.forEach((viewportId) => {
+        const { viewport } = getEnabledElementByViewportId(viewportId) || {};
+        if (!viewport) {
+            return;
+        }
+        if (!isProjectionHeavySegmentationViewport(viewport)) {
+            segmentationRenderingEngine.renderSegmentationsForViewport(viewportId);
+            return;
+        }
+        const existingTimer = deferredSegmentationRenderTimers.get(viewportId);
+        if (existingTimer !== undefined) {
+            clearTimeout(existingTimer);
+        }
+        deferredSegmentationRenderTimers.set(viewportId, setTimeout(() => {
+            deferredSegmentationRenderTimers.delete(viewportId);
+            segmentationRenderingEngine.renderSegmentationsForViewport(viewportId);
+        }, DEFERRED_SEGMENTATION_RENDER_DELAY_MS));
+    });
+}
 const segmentationRenderingEngine = new SegmentationRenderingEngine();
 
 

package/dist/{3500.bundle.153e80b55f1dedb4.js → 3500.bundle.642aa0112968cf71.js}

@@ -641,7 +641,7 @@ function _extends() { return _extends = Object.assign ? Object.assign.bind() : f
 
 
 const Component = /*#__PURE__*/react.lazy(() => {
-  return Promise.all(/* import() */ [__webpack_require__.e(8432), __webpack_require__.e(5642), __webpack_require__.e(9402), __webpack_require__.e(2343), __webpack_require__.e(5910)]).then(__webpack_require__.bind(__webpack_require__, 67329));
+  return Promise.all(/* import() */ [__webpack_require__.e(8478), __webpack_require__.e(89), __webpack_require__.e(5910)]).then(__webpack_require__.bind(__webpack_require__, 67329));
 });
 const OHIFCornerstoneRTViewport = props => {
   return /*#__PURE__*/react.createElement(react.Suspense, {