@cornerstonejs/tools 4.9.0 → 4.9.2

package/dist/esm/stateManagement/segmentation/SegmentationRenderingEngine.js

@@ -1,6 +1,7 @@
 import { triggerEvent, eventTarget, Enums, getRenderingEngines, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { SegmentationRepresentations, Events as csToolsEvents, } from '../../enums';
 import Representations from '../../enums/SegmentationRepresentations';
+import { getSegmentation } from './getSegmentation';
 import { getSegmentationRepresentations } from './getSegmentationRepresentation';
 import surfaceDisplay from '../../tools/displayTools/Surface/surfaceDisplay';
 import contourDisplay from '../../tools/displayTools/Contour/contourDisplay';
@@ -9,6 +10,7 @@ import { addTool } from '../../store/addTool';
 import { state } from '../../store/state';
 import PlanarFreehandContourSegmentationTool from '../../tools/annotation/PlanarFreehandContourSegmentationTool';
 import { getToolGroupForViewport } from '../../store/ToolGroupManager';
+import { addDefaultSegmentationListener } from './segmentationEventManager';
 const renderers = {
     [Representations.Labelmap]: labelmapDisplay,
     [Representations.Contour]: contourDisplay,
@@ -102,15 +104,19 @@ class SegmentationRenderingEngine {
         if (!viewport) {
             return;
         }
-        const viewportRenderList = [];
         const segmentationRenderList = segmentationRepresentations.map((representation) => {
             if (representation.type === SegmentationRepresentations.Contour) {
                 this._addPlanarFreeHandToolIfAbsent(viewport);
             }
             const display = renderers[representation.type];
+            const segmentation = getSegmentation(representation.segmentationId);
+            const existingRepresentation = segmentation.representationData[representation.type] !== undefined;
             try {
-                const viewportId = display.render(viewport, representation);
-                viewportRenderList.push(viewportId);
+                display.render(viewport, representation).then(() => {
+                    if (!existingRepresentation) {
+                        addDefaultSegmentationListener(viewport, representation.segmentationId, representation.type);
+                    }
+                });
             }
             catch (error) {
                 console.error(error);

package/dist/esm/stateManagement/segmentation/index.d.ts

@@ -22,10 +22,11 @@ import { segmentationStyle } from './SegmentationStyle';
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
 import { getCurrentLabelmapImageIdsForViewport, getLabelmapImageIdsForImageId } from './getCurrentLabelmapImageIdForViewport';
 import { getActiveSegmentation } from './getActiveSegmentation';
+import { addSegmentationListener, addDefaultSegmentationListener, removeSegmentationListener, removeAllSegmentationListeners } from './segmentationEventManager';
 declare const helpers: {
     clearSegmentValue: typeof clearSegmentValue;
     convertStackToVolumeLabelmap: typeof convertStackToVolumeLabelmap;
     computeVolumeLabelmapFromStack: typeof computeVolumeLabelmapFromStack;
     convertVolumeToStackLabelmap: typeof convertVolumeToStackLabelmap;
 };
-export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, utilities, helpers, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, segmentationStyle, defaultSegmentationStateManager, getCurrentLabelmapImageIdsForViewport, getLabelmapImageIdsForImageId, getActiveSegmentation, };
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, addSegmentationListener, addDefaultSegmentationListener, removeSegmentationListener, removeAllSegmentationListeners, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, utilities, helpers, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, segmentationStyle, defaultSegmentationStateManager, getCurrentLabelmapImageIdsForViewport, getLabelmapImageIdsForImageId, getActiveSegmentation, };

package/dist/esm/stateManagement/segmentation/index.js

@@ -22,10 +22,11 @@ import { segmentationStyle } from './SegmentationStyle';
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
 import { getCurrentLabelmapImageIdsForViewport, getLabelmapImageIdsForImageId, } from './getCurrentLabelmapImageIdForViewport';
 import { getActiveSegmentation } from './getActiveSegmentation';
+import { addSegmentationListener, addDefaultSegmentationListener, removeSegmentationListener, removeAllSegmentationListeners, } from './segmentationEventManager';
 const helpers = {
     clearSegmentValue,
     convertStackToVolumeLabelmap,
     computeVolumeLabelmapFromStack,
     convertVolumeToStackLabelmap,
 };
-export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, utilities, helpers, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, segmentationStyle, defaultSegmentationStateManager, getCurrentLabelmapImageIdsForViewport, getLabelmapImageIdsForImageId, getActiveSegmentation, };
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, addSegmentationListener, addDefaultSegmentationListener, removeSegmentationListener, removeAllSegmentationListeners, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, utilities, helpers, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, segmentationStyle, defaultSegmentationStateManager, getCurrentLabelmapImageIdsForViewport, getLabelmapImageIdsForImageId, getActiveSegmentation, };

package/dist/esm/stateManagement/segmentation/internalAddSegmentationRepresentation.js

@@ -1,9 +1,11 @@
+import { getEnabledElementByViewportId } from '@cornerstonejs/core';
 import CORNERSTONE_COLOR_LUT from '../../constants/COLOR_LUT';
 import { triggerAnnotationRenderForViewportIds } from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { SegmentationRepresentations } from '../../enums';
-import { triggerSegmentationModified } from './triggerSegmentationEvents';
+import { triggerSegmentationModified, triggerSegmentationDataModified, } from './triggerSegmentationEvents';
 import { addColorLUT } from './addColorLUT';
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { addDefaultSegmentationListener } from './segmentationEventManager';
 import { getActiveSegmentIndex, setActiveSegmentIndex } from './segmentIndex';
 function internalAddSegmentationRepresentation(viewportId, representationInput) {
     const { segmentationId, config } = representationInput;
@@ -12,6 +14,10 @@ function internalAddSegmentationRepresentation(viewportId, representationInput)
         ...config,
     };
     defaultSegmentationStateManager.addSegmentationRepresentation(viewportId, segmentationId, representationInput.type, renderingConfig);
+    const { viewport } = getEnabledElementByViewportId(viewportId) || {};
+    if (viewport) {
+        addDefaultSegmentationListener(viewport, segmentationId, representationInput.type);
+    }
     if (!getActiveSegmentIndex(segmentationId)) {
         let firstSegmentIndex = 1;
         const segmentation = defaultSegmentationStateManager.getSegmentation(segmentationId);
@@ -26,6 +32,9 @@ function internalAddSegmentationRepresentation(viewportId, representationInput)
     if (representationInput.type === SegmentationRepresentations.Contour) {
         triggerAnnotationRenderForViewportIds([viewportId]);
     }
+    if (representationInput.type === SegmentationRepresentations.Surface) {
+        triggerSegmentationDataModified(segmentationId);
+    }
     triggerSegmentationModified(segmentationId);
 }
 function getColorLUTIndex(config) {

package/dist/esm/stateManagement/segmentation/removeSegmentationRepresentations.js

@@ -5,6 +5,7 @@ import { getSegmentationRepresentations } from './getSegmentationRepresentation'
 import { getEnabledElementByViewportId } from '@cornerstonejs/core';
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
 import { surfaceDisplay } from '../../tools/displayTools/Surface';
+import { removeSegmentationListener } from './segmentationEventManager';
 function removeSegmentationRepresentation(viewportId, specifier, immediate) {
     return _removeSegmentationRepresentations(viewportId, specifier, immediate);
 }
@@ -64,6 +65,7 @@ function _removeRepresentationObject(viewportId, segmentationId, type, immediate
         else if (representation.type === SegmentationRepresentations.Surface) {
             surfaceDisplay.removeRepresentation(viewportId, representation.segmentationId, immediate);
         }
+        removeSegmentationListener(representation.segmentationId, representation.type);
     });
     const { viewport } = getEnabledElementByViewportId(viewportId) || {};
     if (viewport) {

package/dist/esm/stateManagement/segmentation/segmentationEventManager.d.ts

@@ -0,0 +1,7 @@
+import { type Types } from '@cornerstonejs/core';
+import { SegmentationRepresentations } from '../../enums';
+export declare function addDefaultSegmentationListener(viewport: Types.IVolumeViewport | Types.IStackViewport, segmentationId: string, representationType: SegmentationRepresentations): void;
+declare function addSegmentationListener(segmentationId: string, representationType: string, updateFunction: (segmentationId: string) => Promise<void>): void;
+declare function removeSegmentationListener(segmentationId: string, representationType: string): void;
+declare function removeAllSegmentationListeners(segmentationId: string): void;
+export { addSegmentationListener, removeSegmentationListener, removeAllSegmentationListeners, };

package/dist/esm/stateManagement/segmentation/segmentationEventManager.js

@@ -0,0 +1,66 @@
+import { eventTarget } from '@cornerstonejs/core';
+import { Events, SegmentationRepresentations } from '../../enums';
+import { triggerSegmentationModified } from './triggerSegmentationEvents';
+import debounce from '../../utilities/debounce';
+import surfaceDisplay from '../../tools/displayTools/Surface/surfaceDisplay';
+import contourDisplay from '../../tools/displayTools/Contour/contourDisplay';
+import labelmapDisplay from '../../tools/displayTools/Labelmap/labelmapDisplay';
+const renderers = {
+    [SegmentationRepresentations.Labelmap]: labelmapDisplay,
+    [SegmentationRepresentations.Contour]: contourDisplay,
+    [SegmentationRepresentations.Surface]: surfaceDisplay,
+};
+const segmentationListeners = new Map();
+export function addDefaultSegmentationListener(viewport, segmentationId, representationType) {
+    const updateFunction = renderers[representationType].getUpdateFunction(viewport);
+    if (updateFunction) {
+        addSegmentationListener(segmentationId, representationType, updateFunction);
+    }
+}
+function addSegmentationListener(segmentationId, representationType, updateFunction) {
+    if (!segmentationListeners.has(segmentationId)) {
+        segmentationListeners.set(segmentationId, new Map());
+    }
+    const listenerMap = segmentationListeners.get(segmentationId);
+    if (listenerMap.has(representationType)) {
+        removeSegmentationListener(segmentationId, representationType);
+    }
+    const listener = createDebouncedSegmentationListener(segmentationId, updateFunction);
+    eventTarget.addEventListener(Events.SEGMENTATION_DATA_MODIFIED, listener);
+    listenerMap.set(representationType, listener);
+}
+function removeSegmentationListener(segmentationId, representationType) {
+    const listenerMap = segmentationListeners.get(segmentationId);
+    if (!listenerMap) {
+        return;
+    }
+    const listener = listenerMap.get(representationType);
+    if (!listener) {
+        return;
+    }
+    eventTarget.removeEventListener(Events.SEGMENTATION_DATA_MODIFIED, listener);
+    listenerMap.delete(representationType);
+}
+function removeAllSegmentationListeners(segmentationId) {
+    const listenerMap = segmentationListeners.get(segmentationId);
+    if (!listenerMap) {
+        return;
+    }
+    for (const listener of listenerMap.values()) {
+        eventTarget.removeEventListener(Events.SEGMENTATION_DATA_MODIFIED, listener);
+    }
+    segmentationListeners.delete(segmentationId);
+}
+function createDebouncedSegmentationListener(segmentationId, updateFunction) {
+    const debouncedHandler = debounce((event) => {
+        const eventSegmentationId = event.detail?.segmentationId;
+        if (eventSegmentationId === segmentationId) {
+            updateFunction(segmentationId);
+            triggerSegmentationModified(segmentationId);
+        }
+    }, 300);
+    return ((event) => {
+        debouncedHandler(event);
+    });
+}
+export { addSegmentationListener, removeSegmentationListener, removeAllSegmentationListeners, };

package/dist/esm/tools/displayTools/Contour/contourDisplay.d.ts

@@ -2,7 +2,9 @@ import type { StackViewport, Types } from '@cornerstonejs/core';
 import type { ContourRepresentation } from '../../../types/SegmentationStateTypes';
 declare function removeRepresentation(viewportId: string, segmentationId: string, renderImmediate?: boolean): void;
 declare function render(viewport: StackViewport | Types.IVolumeViewport, contourRepresentation: ContourRepresentation): Promise<void>;
+declare function getUpdateFunction(viewport: Types.IVolumeViewport | Types.IStackViewport): (segmentationId: string) => Promise<void>;
 declare const _default: {
+    getUpdateFunction: typeof getUpdateFunction;
     render: typeof render;
     removeRepresentation: typeof removeRepresentation;
 };

package/dist/esm/tools/displayTools/Contour/contourDisplay.js

@@ -33,7 +33,7 @@ async function render(viewport, contourRepresentation) {
         getPolySeg()?.canComputeRequestedRepresentation(segmentationId, Representations.Contour) &&
         !polySegConversionInProgressForViewportId.get(viewport.id)) {
         polySegConversionInProgressForViewportId.set(viewport.id, true);
-        contourData = await computeAndAddRepresentation(segmentationId, Representations.Contour, () => polySeg.computeContourData(segmentationId, { viewport }), () => undefined);
+        contourData = await computeAndAddRepresentation(segmentationId, Representations.Contour, () => polySeg.computeContourData(segmentationId, { viewport }));
         polySegConversionInProgressForViewportId.set(viewport.id, false);
     }
     else if (!contourData && !getPolySeg()) {
@@ -140,7 +140,11 @@ function _checkContourNormalsMatchViewport(annotationUIDsMap, viewportNormal) {
     }
     return true;
 }
+function getUpdateFunction(viewport) {
+    return null;
+}
 export default {
+    getUpdateFunction,
     render,
     removeRepresentation,
 };

package/dist/esm/tools/displayTools/Labelmap/labelmapDisplay.d.ts

@@ -3,7 +3,9 @@ import type { LabelmapRepresentation } from '../../../types/SegmentationStateTyp
 export declare const MAX_NUMBER_COLORS = 255;
 declare function removeRepresentation(viewportId: string, segmentationId: string, renderImmediate?: boolean): void;
 declare function render(viewport: Types.IStackViewport | Types.IVolumeViewport, representation: LabelmapRepresentation): Promise<void>;
+declare function getUpdateFunction(viewport: Types.IVolumeViewport | Types.IStackViewport): (segmentationId: string) => Promise<void> | null;
 declare const _default: {
+    getUpdateFunction: typeof getUpdateFunction;
     render: typeof render;
     removeRepresentation: typeof removeRepresentation;
 };

package/dist/esm/tools/displayTools/Labelmap/labelmapDisplay.js

@@ -48,7 +48,7 @@ async function render(viewport, representation) {
         !polySegConversionInProgress) {
         polySegConversionInProgress = true;
         const polySeg = getPolySeg();
-        labelmapData = await computeAndAddRepresentation(segmentationId, SegmentationRepresentations.Labelmap, () => polySeg.computeLabelmapData(segmentationId, { viewport }), () => null, () => {
+        labelmapData = await computeAndAddRepresentation(segmentationId, SegmentationRepresentations.Labelmap, () => polySeg.computeLabelmapData(segmentationId, { viewport }), () => {
             defaultSegmentationStateManager.processLabelmapRepresentationAddition(viewport.id, segmentationId);
             setTimeout(() => {
                 triggerSegmentationDataModified(segmentationId);
@@ -265,7 +265,11 @@ async function _addLabelmapToViewport(viewport, labelmapData, segmentationId, co
     const result = await addLabelmapToElement(viewport.element, labelmapData, segmentationId, config);
     return result || undefined;
 }
+function getUpdateFunction(viewport) {
+    return;
+}
 export default {
+    getUpdateFunction,
     render,
     removeRepresentation,
 };

package/dist/esm/tools/displayTools/Surface/surfaceDisplay.d.ts

@@ -2,9 +2,11 @@ import type { Types } from '@cornerstonejs/core';
 import type { SegmentationRepresentation } from '../../../types/SegmentationStateTypes';
 declare function removeRepresentation(viewportId: string, segmentationId: string, renderImmediate?: boolean): void;
 declare function render(viewport: Types.IVolumeViewport | Types.IStackViewport, representation: SegmentationRepresentation): Promise<void>;
+declare function getUpdateFunction(viewport: Types.IVolumeViewport | Types.IStackViewport): (segmentationId: string) => Promise<void>;
 declare const _default: {
+    getUpdateFunction: typeof getUpdateFunction;
     render: typeof render;
     removeRepresentation: typeof removeRepresentation;
 };
 export default _default;
-export { render, removeRepresentation };
+export { getUpdateFunction, render, removeRepresentation };

package/dist/esm/tools/displayTools/Surface/surfaceDisplay.js

@@ -29,7 +29,7 @@ async function render(viewport, representation) {
     if (!SurfaceData &&
         getPolySeg()?.canComputeRequestedRepresentation(segmentationId, Representations.Surface)) {
         const polySeg = getPolySeg();
-        SurfaceData = await computeAndAddRepresentation(segmentationId, Representations.Surface, () => polySeg.computeSurfaceData(segmentationId, { viewport }), () => polySeg.updateSurfaceData(segmentationId, { viewport }));
+        SurfaceData = await computeAndAddRepresentation(segmentationId, Representations.Surface, () => polySeg.computeSurfaceData(segmentationId, { viewport }));
         if (!SurfaceData) {
             throw new Error(`No Surface data found for segmentationId ${segmentationId} even we tried to compute it`);
         }
@@ -69,8 +69,13 @@ async function render(viewport, representation) {
     });
     viewport.render();
 }
+function getUpdateFunction(viewport) {
+    const polySeg = getPolySeg();
+    return (segmentationId) => polySeg.updateSurfaceData(segmentationId, { viewport });
+}
 export default {
+    getUpdateFunction,
     render,
     removeRepresentation,
 };
-export { render, removeRepresentation };
+export { getUpdateFunction, render, removeRepresentation };

package/dist/esm/utilities/contours/interpolation/interpolate.js

@@ -1,4 +1,4 @@
-import { triggerEvent, utilities } from '@cornerstonejs/core';
+import { eventTarget, triggerEvent, utilities } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
 import createPolylineToolData from './createPolylineToolData';
 import findAnnotationsForInterpolation from './findAnnotationForInterpolation';
@@ -55,6 +55,7 @@ function startInterpolation(viewportData) {
     };
     if (interpolationList.length) {
         triggerEvent(viewportData.viewport.element, EventTypes.ANNOTATION_INTERPOLATION_PROCESS_COMPLETED, eventDetails);
+        triggerEvent(eventTarget, EventTypes.ANNOTATION_INTERPOLATION_PROCESS_COMPLETED, eventDetails);
     }
 }
 function _linearlyInterpolateBetween(indices, annotationPair, interpolationData, eventData) {

package/dist/esm/utilities/segmentation/computeAndAddRepresentation.d.ts

@@ -1,3 +1,3 @@
 import type { SegmentationRepresentations } from '../../enums';
-declare function computeAndAddRepresentation<T>(segmentationId: string, type: SegmentationRepresentations, computeFunction: () => Promise<T>, updateFunction?: () => void, onComputationComplete?: () => void): Promise<T>;
+declare function computeAndAddRepresentation<T>(segmentationId: string, type: SegmentationRepresentations, computeFunction: () => Promise<T>, onComputationComplete?: () => void): Promise<T>;
 export { computeAndAddRepresentation };

package/dist/esm/utilities/segmentation/computeAndAddRepresentation.js

@@ -1,10 +1,5 @@
-import { eventTarget } from '@cornerstonejs/core';
-import { Events } from '../../enums';
 import addRepresentationData from '../../stateManagement/segmentation/internalAddRepresentationData';
-import { triggerSegmentationModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
-import debounce from '../debounce';
-const computedRepresentations = new Map();
-async function computeAndAddRepresentation(segmentationId, type, computeFunction, updateFunction, onComputationComplete) {
+async function computeAndAddRepresentation(segmentationId, type, computeFunction, onComputationComplete) {
     const data = await computeFunction();
     addRepresentationData({
         segmentationId,
@@ -12,34 +7,6 @@ async function computeAndAddRepresentation(segmentationId, type, computeFunction
         data,
     });
     onComputationComplete?.();
-    if (!computedRepresentations.has(segmentationId)) {
-        computedRepresentations.set(segmentationId, []);
-    }
-    const representations = computedRepresentations.get(segmentationId);
-    if (!representations.includes(type)) {
-        representations.push(type);
-    }
-    subscribeToSegmentationChanges(updateFunction);
-    triggerSegmentationModified(segmentationId);
     return data;
 }
-function subscribeToSegmentationChanges(updateFunction) {
-    const debouncedUpdateFunction = (event) => {
-        _debouncedSegmentationModified(event, updateFunction);
-    };
-    updateFunction._debouncedUpdateFunction = debouncedUpdateFunction;
-    eventTarget.removeEventListener(Events.SEGMENTATION_DATA_MODIFIED, updateFunction._debouncedUpdateFunction);
-    eventTarget.addEventListener(Events.SEGMENTATION_DATA_MODIFIED, updateFunction._debouncedUpdateFunction);
-}
-const _debouncedSegmentationModified = debounce((event, updateFunction) => {
-    const segmentationId = event.detail.segmentationId;
-    const representations = computedRepresentations.get(segmentationId);
-    if (!representations || !representations.length) {
-        return;
-    }
-    updateFunction(segmentationId);
-    if (representations.length) {
-        triggerSegmentationModified(segmentationId);
-    }
-}, 300);
 export { computeAndAddRepresentation };

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.9.0";
+export declare const version = "4.9.2";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '4.9.0';
+export const version = '4.9.2';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "4.9.0",
+  "version": "4.9.2",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -108,7 +108,7 @@
     "canvas": "3.2.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "4.9.0",
+    "@cornerstonejs/core": "4.9.2",
     "@kitware/vtk.js": "32.12.1",
     "@types/d3-array": "3.2.1",
     "@types/d3-interpolate": "3.0.4",
@@ -127,5 +127,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "8f00d5d14582cd878595324d8480e3d00a5c92a6"
+  "gitHead": "d128e0856504bc33713d061f6642122b27ae82e3"
 }