@ohif/app 3.13.0-beta.119 → 3.13.0-beta.120

package/dist/{6495.bundle.84b83aa091c338cd.js → 6495.bundle.a6764fdb8c0c252f.js}

@@ -4986,6 +4986,7 @@ __webpack_require__.d(__webpack_exports__, {
   CircleROIStartEndThresholdTool: () => (/* reexport safe */ _tools_index_js__rspack_import_13.pq),
   CircleROITool: () => (/* reexport safe */ _tools_index_js__rspack_import_13.Vl),
   CircleScissorsTool: () => (/* reexport safe */ _tools_index_js__rspack_import_13.G2),
+  ClickSegmentTool: () => (/* reexport safe */ _tools_index_js__rspack_import_13.Yk),
   CobbAngleTool: () => (/* reexport safe */ _tools_index_js__rspack_import_13.EV),
   CrosshairsTool: () => (/* reexport safe */ _tools_index_js__rspack_import_13.ep),
   DragProbeTool: () => (/* reexport safe */ _tools_index_js__rspack_import_13.j$),
@@ -5059,7 +5060,7 @@ __webpack_require__.d(__webpack_exports__, {
   store: () => (/* reexport module object */ _store_index_js__rspack_import_1),
   synchronizers: () => (/* reexport module object */ _synchronizers_index_js__rspack_import_5),
   utilities: () => (/* reexport module object */ _utilities_index_js__rspack_import_7),
-  version: () => (/* reexport safe */ (/* inlined export _version_js__rspack_import_4 */"5.4.12"))
+  version: () => (/* reexport safe */ (/* inlined export _version_js__rspack_import_4 */"5.4.13"))
 });
 /* import */ var _init_js__rspack_import_0 = __webpack_require__(70210);
 /* import */ var _store_index_js__rspack_import_1 = __webpack_require__(37872);
@@ -8065,182 +8066,6 @@ __webpack_require__.d(__webpack_exports__, {
 
 
 
-},
-88392(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
-__webpack_require__.d(__webpack_exports__, {
-  $n: () => (removeLabelmap),
-  AD: () => (registerLabelmap),
-  BS: () => (getLabelmapForVolumeId),
-  Hs: () => (getLabelmap),
-  M4: () => (getLabelmapForImageId),
-  kL: () => (getOrCreateLabelmapVolume),
-  m: () => (getLabelmaps)
-});
-/* import */ var _cornerstonejs_core__rspack_import_0 = __webpack_require__(88479);
-/* import */ var _normalizeLabelmapSegmentationData_js__rspack_import_1 = __webpack_require__(209);
-/* import */ var _labelmapImageIdMapping_js__rspack_import_2 = __webpack_require__(26372);
-
-
-
-function getLabelmap(segmentation, labelmapId) {
-    return (0,_normalizeLabelmapSegmentationData_js__rspack_import_1/* .ensureLabelmapState */.uk)(segmentation)?.labelmaps?.[labelmapId];
-}
-function getLabelmaps(segmentation) {
-    const labelmapState = (0,_normalizeLabelmapSegmentationData_js__rspack_import_1/* .ensureLabelmapState */.uk)(segmentation);
-    if (!labelmapState) {
-        return [];
-    }
-    return Object.values(labelmapState.labelmaps);
-}
-function registerLabelmap(segmentation, layer) {
-    const labelmapState = (0,_normalizeLabelmapSegmentationData_js__rspack_import_1/* .ensureLabelmapState */.uk)(segmentation);
-    if (!labelmapState) {
-        return;
-    }
-    labelmapState.labelmaps[layer.labelmapId] = layer;
-}
-function removeLabelmap(segmentation, labelmapId) {
-    const labelmapState = (0,_normalizeLabelmapSegmentationData_js__rspack_import_1/* .ensureLabelmapState */.uk)(segmentation);
-    if (!labelmapState) {
-        return;
-    }
-    const layer = labelmapState.labelmaps[labelmapId];
-    if (layer?.geometryVolumeId && _cornerstonejs_core__rspack_import_0.cache.getVolume(layer.geometryVolumeId)) {
-        _cornerstonejs_core__rspack_import_0.cache.removeVolumeLoadObject(layer.geometryVolumeId);
-    }
-    delete labelmapState.labelmaps[labelmapId];
-}
-function getOrCreateLabelmapVolume(layer) {
-    const mergedVolume = getOrCreateMergedStackLabelmapVolume(layer);
-    if (mergedVolume) {
-        return mergedVolume;
-    }
-    const existingVolumeId = layer.volumeId ?? layer.geometryVolumeId;
-    if (existingVolumeId) {
-        const cachedVolume = _cornerstonejs_core__rspack_import_0.cache.getVolume(existingVolumeId);
-        if (cachedVolume) {
-            return cachedVolume;
-        }
-    }
-    const imageIds = layer.imageIds ?? [];
-    if (!imageIds.length) {
-        return;
-    }
-    const volumeId = layer.volumeId ?? layer.geometryVolumeId ?? `${layer.labelmapId}-geometry`;
-    if (!layer.volumeId) {
-        layer.geometryVolumeId = volumeId;
-    }
-    const cachedVolume = _cornerstonejs_core__rspack_import_0.cache.getVolume(volumeId);
-    if (cachedVolume) {
-        return cachedVolume;
-    }
-    return _cornerstonejs_core__rspack_import_0.volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, imageIds);
-}
-function getOrCreateMergedStackLabelmapVolume(layer) {
-    if (layer.volumeId || !hasDuplicateReferencedImageIds(layer)) {
-        return;
-    }
-    const volumeId = layer.geometryVolumeId ?? `${layer.labelmapId}-geometry`;
-    const cachedVolume = _cornerstonejs_core__rspack_import_0.cache.getVolume(volumeId);
-    if (cachedVolume) {
-        return cachedVolume;
-    }
-    const imageIdsByReferencedImageId = new Map();
-    (0,_labelmapImageIdMapping_js__rspack_import_2/* .forEachLabelmapImageReference */.Zd)(layer, (referencedImageId, imageId) => {
-        const imageIdsForReference = imageIdsByReferencedImageId.get(referencedImageId) ?? [];
-        imageIdsForReference.push(imageId);
-        imageIdsByReferencedImageId.set(referencedImageId, imageIdsForReference);
-    });
-    const mergedReferencedImageIds = Array.from(imageIdsByReferencedImageId.keys());
-    if (!mergedReferencedImageIds.length) {
-        return;
-    }
-    let mergedImageIndex = 0;
-    const mergedImages = _cornerstonejs_core__rspack_import_0.imageLoader.createAndCacheDerivedImages(mergedReferencedImageIds, {
-        getDerivedImageId: () => `${volumeId}-image-${mergedImageIndex++}`,
-        targetBuffer: { type: 'Uint8Array' },
-    });
-    mergedImages.forEach((mergedImage) => {
-        const sourceImageIds = imageIdsByReferencedImageId.get(mergedImage.referencedImageId);
-        if (!sourceImageIds?.length) {
-            return;
-        }
-        const targetVoxelManager = mergedImage.voxelManager;
-        const scalarDataLength = targetVoxelManager.getScalarDataLength();
-        sourceImageIds.forEach((sourceImageId) => {
-            const sourceImage = _cornerstonejs_core__rspack_import_0.cache.getImage(sourceImageId);
-            const sourceVoxelManager = sourceImage?.voxelManager;
-            if (!sourceVoxelManager) {
-                return;
-            }
-            const sourceScalarDataLength = sourceVoxelManager.getScalarDataLength();
-            const length = Math.min(scalarDataLength, sourceScalarDataLength);
-            for (let index = 0; index < length; index++) {
-                const value = Number(sourceVoxelManager.getAtIndex(index));
-                if (value !== 0) {
-                    targetVoxelManager.setAtIndex(index, value);
-                }
-            }
-        });
-    });
-    layer.geometryVolumeId = volumeId;
-    return _cornerstonejs_core__rspack_import_0.volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, mergedImages.map((image) => image.imageId));
-}
-function hasDuplicateReferencedImageIds(layer) {
-    return (0,_labelmapImageIdMapping_js__rspack_import_2/* .hasMultipleLabelmapImagesPerReferencedImageId */.dm)(layer);
-}
-function getLabelmapIds(segmentation) {
-    return getLabelmaps(segmentation).map((layer) => layer.labelmapId);
-}
-function getLabelmapDataById(segmentation, labelmapId) {
-    const labelmapState = ensureLabelmapState(segmentation);
-    const layer = labelmapState?.labelmaps?.[labelmapId];
-    if (!labelmapState || !layer) {
-        return;
-    }
-    return {
-        volumeId: layer.volumeId,
-        referencedVolumeId: layer.referencedVolumeId,
-        imageIds: layer.imageIds,
-        referencedImageIds: layer.referencedImageIds,
-        sourceRepresentationName: labelmapState.sourceRepresentationName,
-        primaryLabelmapId: labelmapId,
-        labelmaps: {
-            [labelmapId]: layer,
-        },
-        segmentBindings: Object.fromEntries(Object.entries(labelmapState.segmentBindings).filter(([, binding]) => binding.labelmapId === labelmapId)),
-    };
-}
-function getScalarArrayLengthFromLabelmap(layer) {
-    if (layer.volumeId) {
-        return cache.getVolume(layer.volumeId)?.voxelManager?.getScalarDataLength();
-    }
-    const firstImageId = layer.imageIds?.[0];
-    const firstImage = firstImageId ? cache.getImage(firstImageId) : null;
-    if (!firstImage || !layer.imageIds?.length) {
-        return 0;
-    }
-    return firstImage.voxelManager.getScalarDataLength() * layer.imageIds.length;
-}
-function getConstructorNameForLabelmap(layer) {
-    if (layer.volumeId) {
-        return cache.getVolume(layer.volumeId)?.voxelManager?.getConstructor()
-            ?.name;
-    }
-    const imageId = layer.imageIds?.[0];
-    return imageId
-        ? cache.getImage(imageId)?.voxelManager?.getConstructor()?.name
-        : undefined;
-}
-function getLabelmapForImageId(segmentation, imageId) {
-    return getLabelmaps(segmentation).find((layer) => layer.imageIds?.includes(imageId));
-}
-function getLabelmapForVolumeId(segmentation, volumeId) {
-    return getLabelmaps(segmentation).find((layer) => layer.volumeId === volumeId || layer.geometryVolumeId === volumeId);
-}
-
-
-
 },
 59371(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
@@ -22262,6 +22087,771 @@ function defaultGetTextLines(data, targetId) {
 /* export default */ const __rspack_default_export = (CircleROITool);
 
 
+},
+62843(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  A: () => (__rspack_default_export)
+});
+/* import */ var _cornerstonejs_core__rspack_import_0 = __webpack_require__(88479);
+/* import */ var _base_GrowCutBaseTool_js__rspack_import_1 = __webpack_require__(47844);
+/* import */ var _utilities_segmentation_growCut_runFloodFillSegmentation_js__rspack_import_2 = __webpack_require__(55600);
+/* import */ var _utilities_segmentation_floodFillSliceLazy_js__rspack_import_3 = __webpack_require__(10621);
+/* import */ var _utilities_segmentation_growCut_intensityRange_adaptiveRegionIntensityRange_js__rspack_import_4 = __webpack_require__(81537);
+/* import */ var _utilities_segmentation_growCut_getViewportVoiMappingForVolume_js__rspack_import_5 = __webpack_require__(1967);
+/* import */ var _stateManagement_segmentation_index_js__rspack_import_6 = __webpack_require__(48735);
+/* import */ var _stateManagement_segmentation_triggerSegmentationEvents_js__rspack_import_7 = __webpack_require__(49256);
+/* import */ var _utilities_segmentation_createLabelmapMemo_js__rspack_import_8 = __webpack_require__(1732);
+/* import */ var _regionSegmentHoverCursors_js__rspack_import_9 = __webpack_require__(58690);
+/* import */ var _enums_index_js__rspack_import_10 = __webpack_require__(53870);
+
+
+
+
+
+
+
+
+
+
+
+const { growCutLog } = _cornerstonejs_core__rspack_import_0.utilities.logger;
+const HOVER_PROBE_THROTTLE_MS = 100;
+const PROBE_REUSE_DISTANCE_PX = 6;
+const PROBE_FRESH_MS = 1500;
+const EXPAND_STEP_FACTOR = 1.15;
+const SHRINK_STEP_FACTOR = 0.85;
+const MIN_COMPACTNESS = 0.08;
+const COMPACTNESS_CHECK_MIN_VOLUME_MM3 = 2000;
+const COMPUTE_BUDGET_MM3 = 2_000_000;
+const NOT_LESION_MESSAGE = 'The region here does not form a self-contained, lesion-like shape; nothing was segmented.';
+const DRY_RUN_YIELD_EVERY = 10_000;
+const CONSENSUS_MIN_NEIGHBOR_VOTES = 2;
+const VERDICT_CACHE_TTL_MS = 2500;
+const MAX_REJECTED_REGIONS = 8;
+class ClickSegmentTool extends _base_GrowCutBaseTool_js__rspack_import_1/* ["default"] */.A {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            maxDeltaK: 25,
+            maxDeltaIJ: 512,
+            actions: {
+                cancelInProgress: {
+                    method: 'cancelInProgress',
+                    bindings: [
+                        {
+                            key: 'Escape',
+                        },
+                    ],
+                },
+            },
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.segmentationInProgress = false;
+        this.hoverThrottleTimer = null;
+        this.pendingHoverEvent = null;
+        this.lastHoverElement = null;
+        this.lastProbe = null;
+        this.lastClick = null;
+        this.clickAbortController = null;
+        this.dryRunToken = null;
+        this.confirmedRegion = null;
+        this.rejectedRegions = [];
+    }
+    notifySegmentationError(message) {
+        const event = new CustomEvent(_cornerstonejs_core__rspack_import_0.Enums.Events.ERROR_EVENT, {
+            detail: {
+                type: 'Segmentation',
+                message,
+            },
+            cancelable: true,
+        });
+        _cornerstonejs_core__rspack_import_0.eventTarget.dispatchEvent(event);
+    }
+    cancelInProgress() {
+        return this.cancelActiveOperation();
+    }
+    cancelActiveOperation() {
+        if (!this.clickAbortController ||
+            this.clickAbortController.signal.aborted) {
+            return false;
+        }
+        this.clickAbortController.abort();
+        return true;
+    }
+    clearHoverState() {
+        if (this.hoverThrottleTimer !== null) {
+            window.clearTimeout(this.hoverThrottleTimer);
+            this.hoverThrottleTimer = null;
+        }
+        this.pendingHoverEvent = null;
+        this.lastProbe = null;
+        this.confirmedRegion = null;
+        this.rejectedRegions = [];
+        if (this.dryRunToken) {
+            this.dryRunToken.cancelled = true;
+            this.dryRunToken = null;
+        }
+        if (this.lastHoverElement) {
+            this.lastHoverElement.style.cursor = '';
+            this.lastHoverElement = null;
+        }
+    }
+    pointerOnConfirmedRegion(refVolume, viewport, world) {
+        const region = this.confirmedRegion;
+        if (!region ||
+            region.viewportId !== viewport.id ||
+            Date.now() > region.expiresAt) {
+            return false;
+        }
+        const ijk = _cornerstonejs_core__rspack_import_0.utilities.transformWorldToIndex(refVolume.imageData, world)
+            .map(Math.round);
+        for (let axis = 0; axis < 3; axis++) {
+            if (ijk[axis] < region.bbox.min[axis] ||
+                ijk[axis] > region.bbox.max[axis]) {
+                return false;
+            }
+        }
+        const [width, height] = refVolume.dimensions;
+        const scalar = Number(refVolume.voxelManager.getAtIndex(ijk[2] * width * height + ijk[1] * width + ijk[0]));
+        if (!Number.isFinite(scalar) ||
+            scalar < region.bandMin ||
+            scalar > region.bandMax) {
+            return false;
+        }
+        region.expiresAt = Date.now() + VERDICT_CACHE_TTL_MS;
+        return true;
+    }
+    static bandsAreSimilar(aMin, aMax, bMin, bMax) {
+        const edgeMatches = (a, b) => {
+            if (!Number.isFinite(a) || !Number.isFinite(b)) {
+                return a === b;
+            }
+            const scale = Math.max(Math.abs(a), Math.abs(b), 1e-6);
+            return Math.abs(a - b) <= 0.25 * scale;
+        };
+        return edgeMatches(aMin, bMin) && edgeMatches(aMax, bMax);
+    }
+    matchesRejectedRegion(viewportId, range) {
+        const now = Date.now();
+        this.rejectedRegions = this.rejectedRegions.filter((entry) => entry.expiresAt > now);
+        const seed = range.ijkStart;
+        const match = this.rejectedRegions.find((entry) => {
+            if (entry.viewportId !== viewportId) {
+                return false;
+            }
+            for (let axis = 0; axis < 3; axis++) {
+                if (seed[axis] < entry.bbox.min[axis] ||
+                    seed[axis] > entry.bbox.max[axis]) {
+                    return false;
+                }
+            }
+            return ClickSegmentTool.bandsAreSimilar(range.min, range.max, entry.bandMin, entry.bandMax);
+        });
+        if (match) {
+            match.expiresAt = now + VERDICT_CACHE_TTL_MS;
+            return true;
+        }
+        return false;
+    }
+    rememberRejectedRegion(viewportId, bbox, bandMin, bandMax) {
+        if (!bbox) {
+            return;
+        }
+        this.rejectedRegions.push({
+            viewportId,
+            bbox: {
+                min: [...bbox.min],
+                max: [...bbox.max],
+            },
+            bandMin,
+            bandMax,
+            expiresAt: Date.now() + VERDICT_CACHE_TTL_MS,
+        });
+        if (this.rejectedRegions.length > MAX_REJECTED_REGIONS) {
+            this.rejectedRegions.splice(0, this.rejectedRegions.length - MAX_REJECTED_REGIONS);
+        }
+    }
+    safeSpacing(volume) {
+        const spacing = volume.spacing ?? [1, 1, 1];
+        return [0, 1, 2].map((axis) => Number.isFinite(spacing[axis]) && spacing[axis] > 0 ? spacing[axis] : 1);
+    }
+    computeVoxelBudget(volume) {
+        const [sx, sy, sz] = this.safeSpacing(volume);
+        return Math.max(1000, Math.ceil(COMPUTE_BUDGET_MM3 / (sx * sy * sz)));
+    }
+    makeRegionShapeGate(volume) {
+        const spacing = this.safeSpacing(volume);
+        const voxelVolumeMm3 = spacing[0] * spacing[1] * spacing[2];
+        const maxDeltaK = this.configuration.maxDeltaK;
+        return ({ voxelCount, bbox }) => {
+            if (typeof maxDeltaK === 'number' && maxDeltaK >= 0) {
+                const kExtent = bbox.max[2] - bbox.min[2] + 1;
+                if (kExtent >= 2 * maxDeltaK + 1) {
+                    return false;
+                }
+            }
+            const volumeMm3 = voxelCount * voxelVolumeMm3;
+            if (volumeMm3 < COMPACTNESS_CHECK_MIN_VOLUME_MM3) {
+                return true;
+            }
+            let bboxMm3 = 1;
+            for (let axis = 0; axis < 3; axis++) {
+                bboxMm3 *= (bbox.max[axis] - bbox.min[axis] + 1) * spacing[axis];
+            }
+            return volumeMm3 / bboxMm3 >= MIN_COMPACTNESS;
+        };
+    }
+    onSetToolPassive() {
+        this.clearHoverState();
+    }
+    onSetToolDisabled() {
+        this.clearHoverState();
+    }
+    buildProbeOptions(viewport, element, referencedVolumeId) {
+        return {
+            viewport,
+            element,
+            referencedVolumeId,
+            voiMapping: (0,_utilities_segmentation_growCut_getViewportVoiMappingForVolume_js__rspack_import_5/* .getViewportVoiMappingForVolume */.K)(viewport, referencedVolumeId) ??
+                undefined,
+        };
+    }
+    mouseMoveCallback(evt) {
+        if (this.mode !== _enums_index_js__rspack_import_10.ToolModes.Active) {
+            return;
+        }
+        const { element } = evt.detail;
+        this.lastHoverElement = element;
+        if (this.segmentationInProgress) {
+            element.style.cursor = 'wait';
+            return;
+        }
+        this.queueHoverProbe(evt);
+    }
+    queueHoverProbe(evt) {
+        this.pendingHoverEvent = evt;
+        if (this.hoverThrottleTimer !== null) {
+            return;
+        }
+        this.flushHoverProbe();
+    }
+    flushHoverProbe() {
+        const evt = this.pendingHoverEvent;
+        this.pendingHoverEvent = null;
+        if (!evt) {
+            return;
+        }
+        void this.runHoverProbe(evt);
+        this.hoverThrottleTimer = window.setTimeout(() => {
+            this.hoverThrottleTimer = null;
+            if (this.pendingHoverEvent) {
+                this.flushHoverProbe();
+            }
+        }, HOVER_PROBE_THROTTLE_MS);
+    }
+    getViewportSliceIndex(viewport) {
+        const getSliceIndex = viewport.getSliceIndex;
+        if (typeof getSliceIndex !== 'function') {
+            return null;
+        }
+        try {
+            const sliceIndex = getSliceIndex.call(viewport);
+            return Number.isFinite(sliceIndex) ? sliceIndex : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async runHoverProbe(evt) {
+        if (this.mode !== _enums_index_js__rspack_import_10.ToolModes.Active || this.segmentationInProgress) {
+            return;
+        }
+        const { element, currentPoints } = evt.detail;
+        const enabledElement = (0,_cornerstonejs_core__rspack_import_0.getEnabledElement)(element);
+        const viewport = enabledElement?.viewport;
+        if (!viewport) {
+            return;
+        }
+        if (this.dryRunToken) {
+            this.dryRunToken.cancelled = true;
+            this.dryRunToken = null;
+        }
+        let state = 'unknown';
+        let dryRunInput = null;
+        try {
+            if (_stateManagement_segmentation_index_js__rspack_import_6.activeSegmentation.getActiveSegmentation(viewport.id)) {
+                const labelmapData = await this.getLabelmapSegmentationData(viewport);
+                if (labelmapData) {
+                    const { referencedVolumeId } = labelmapData;
+                    if (!this._isOrthogonalView(viewport, referencedVolumeId)) {
+                        state = 'blocked';
+                    }
+                    else {
+                        const refVolume = _cornerstonejs_core__rspack_import_0.cache.getVolume(referencedVolumeId);
+                        if (refVolume) {
+                            if (this.pointerOnConfirmedRegion(refVolume, viewport, currentPoints.world)) {
+                                state = 'plus';
+                            }
+                            else {
+                                const options = this.buildProbeOptions(viewport, element, referencedVolumeId);
+                                const probe = (0,_utilities_segmentation_growCut_intensityRange_adaptiveRegionIntensityRange_js__rspack_import_4/* .probeAdaptiveRegion */.Ti)(refVolume, currentPoints.world, options);
+                                if (!probe.viable || !probe.range) {
+                                    state = 'blocked';
+                                }
+                                else if (this.matchesRejectedRegion(viewport.id, probe.range)) {
+                                    state = 'blocked';
+                                }
+                                else if (!this.neighborsAgree(probe)) {
+                                    state = 'blocked';
+                                }
+                                else {
+                                    state = 'pending';
+                                    dryRunInput = { refVolume, range: probe.range };
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            growCutLog.debug('hover probe: could not evaluate', {
+                message: err instanceof Error ? err.message : String(err),
+            });
+            state = 'unknown';
+        }
+        const verdict = state === 'unknown'
+            ? null
+            : {
+                viewportId: viewport.id,
+                canvas: [...currentPoints.canvas],
+                sliceIndex: this.getViewportSliceIndex(viewport),
+                ok: state !== 'blocked',
+                at: Date.now(),
+            };
+        this.lastProbe = verdict;
+        element.style.cursor =
+            state === 'plus'
+                ? _regionSegmentHoverCursors_js__rspack_import_9/* .PLUS_CURSOR */.ys
+                : state === 'blocked'
+                    ? _regionSegmentHoverCursors_js__rspack_import_9/* .BLOCKED_CURSOR */.kC
+                    : _regionSegmentHoverCursors_js__rspack_import_9/* .PENDING_CURSOR */.t5;
+        if (state === 'pending' && dryRunInput && verdict) {
+            const token = { cancelled: false };
+            this.dryRunToken = token;
+            void this.runConfinementDryRun(dryRunInput.refVolume, dryRunInput.range, token, verdict, element);
+        }
+    }
+    neighborsAgree(probe) {
+        const joinLevels = probe.clickNeighborJoinLevels;
+        const tolerance = probe.toleranceBytes;
+        if (!joinLevels || typeof tolerance !== 'number') {
+            return true;
+        }
+        let votes = 0;
+        let evaluated = 0;
+        for (const joinLevel of joinLevels) {
+            if (joinLevel === null) {
+                continue;
+            }
+            evaluated++;
+            if (joinLevel >= 0 && joinLevel <= tolerance) {
+                votes++;
+            }
+        }
+        return evaluated < CONSENSUS_MIN_NEIGHBOR_VOTES
+            ? votes === evaluated
+            : votes >= CONSENSUS_MIN_NEIGHBOR_VOTES;
+    }
+    async runConfinementDryRun(refVolume, range, token, verdict, element) {
+        const { dimensions } = refVolume;
+        const [width, height, depth] = dimensions;
+        const pixelsPerSlice = width * height;
+        const voxelManager = refVolume.voxelManager;
+        const { min, max } = range;
+        const shapeGate = this.makeRegionShapeGate(refVolume);
+        try {
+            const { truncated, voxelCount, bbox } = await (0,_utilities_segmentation_floodFillSliceLazy_js__rspack_import_3/* .floodFill3dSliceLazy */.x)((x, y, z) => Number(voxelManager.getAtIndex(z * pixelsPerSlice + y * width + x)), [...range.ijkStart], {
+                width,
+                height,
+                depth,
+                equals: (val) => typeof val === 'number' &&
+                    Number.isFinite(val) &&
+                    val >= min &&
+                    val <= max,
+                yieldEvery: DRY_RUN_YIELD_EVERY,
+                maxDeltaK: this.configuration.maxDeltaK,
+                maxDeltaIJ: this.configuration.maxDeltaIJ,
+                isCancelled: () => token.cancelled,
+                maxVoxels: this.computeVoxelBudget(refVolume),
+                shouldContinue: shapeGate,
+            });
+            if (token.cancelled) {
+                return;
+            }
+            const lesionLike = !truncated && bbox && shapeGate({ voxelCount, bbox });
+            if (lesionLike) {
+                this.confirmedRegion = {
+                    viewportId: verdict.viewportId,
+                    bbox,
+                    bandMin: min,
+                    bandMax: max,
+                    expiresAt: Date.now() + VERDICT_CACHE_TTL_MS,
+                };
+                if (this.lastProbe === verdict) {
+                    verdict.ok = true;
+                    element.style.cursor = _regionSegmentHoverCursors_js__rspack_import_9/* .PLUS_CURSOR */.ys;
+                }
+            }
+            else {
+                this.rememberRejectedRegion(verdict.viewportId, bbox, min, max);
+                if (this.lastProbe === verdict) {
+                    verdict.ok = false;
+                    element.style.cursor = _regionSegmentHoverCursors_js__rspack_import_9/* .BLOCKED_CURSOR */.kC;
+                }
+            }
+        }
+        catch (err) {
+            growCutLog.debug('hover dry-run: could not evaluate', {
+                message: err instanceof Error ? err.message : String(err),
+            });
+        }
+        finally {
+            if (this.dryRunToken === token) {
+                this.dryRunToken = null;
+            }
+        }
+    }
+    probeAppliesToClick(viewport, canvas) {
+        const probe = this.lastProbe;
+        if (!probe || probe.viewportId !== viewport.id) {
+            return false;
+        }
+        if (Date.now() - probe.at > PROBE_FRESH_MS) {
+            return false;
+        }
+        if (probe.sliceIndex !== this.getViewportSliceIndex(viewport)) {
+            return false;
+        }
+        const dx = canvas[0] - probe.canvas[0];
+        const dy = canvas[1] - probe.canvas[1];
+        return Math.sqrt(dx * dx + dy * dy) <= PROBE_REUSE_DISTANCE_PX;
+    }
+    async preMouseDownCallback(evt) {
+        if (this.segmentationInProgress) {
+            return false;
+        }
+        const { currentPoints, element } = evt.detail;
+        const { world: worldPoint, canvas: canvasPoint } = currentPoints;
+        const enabledElement = element ? (0,_cornerstonejs_core__rspack_import_0.getEnabledElement)(element) : undefined;
+        if (enabledElement?.viewport &&
+            this.probeAppliesToClick(enabledElement.viewport, canvasPoint) &&
+            this.lastProbe?.ok === false) {
+            growCutLog.info('click ignored: hover probe reported no proper region', {
+                canvasPoint,
+            });
+            return false;
+        }
+        let setupOk = false;
+        try {
+            setupOk = await super.preMouseDownCallback(evt);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Click segmentation failed.';
+            growCutLog.info('ClickSegment: click setup rejected', { message });
+            this.notifySegmentationError(message);
+            return false;
+        }
+        if (!setupOk || !this.growCutData) {
+            return false;
+        }
+        const clickData = this.growCutData;
+        this.growCutData = null;
+        void this.runClick(clickData, worldPoint, element).catch((err) => {
+            const message = err instanceof Error ? err.message : 'Click segmentation failed.';
+            this.notifySegmentationError(message);
+            growCutLog.error('ClickSegment: segmentation failed', { message });
+        });
+        return true;
+    }
+    async runClick(clickData, worldPoint, element) {
+        const { segmentation, viewportId, renderingEngineId } = clickData;
+        const { referencedVolumeId, labelmapVolumeId, segmentIndex } = segmentation;
+        const renderingEngine = (0,_cornerstonejs_core__rspack_import_0.getRenderingEngine)(renderingEngineId);
+        const viewport = renderingEngine?.getViewport(viewportId);
+        if (!viewport) {
+            throw new Error('ClickSegment: viewport not found for click.');
+        }
+        const refVolume = _cornerstonejs_core__rspack_import_0.cache.getVolume(referencedVolumeId);
+        const labelmapVolume = _cornerstonejs_core__rspack_import_0.cache.getVolume(labelmapVolumeId);
+        if (!refVolume || !labelmapVolume) {
+            throw new Error('ClickSegment: referenced or labelmap volume not in cache.');
+        }
+        const probe = (0,_utilities_segmentation_growCut_intensityRange_adaptiveRegionIntensityRange_js__rspack_import_4/* .probeAdaptiveRegion */.Ti)(refVolume, worldPoint, this.buildProbeOptions(viewport, viewport.element, referencedVolumeId));
+        if (!probe.viable || !probe.range || !probe.expandContext) {
+            growCutLog.info('ClickSegment: click found no meaningful region', {
+                reason: probe.reason,
+                regionAreaMm2: probe.regionAreaMm2,
+            });
+            this.notifySegmentationError('No meaningful region at the clicked location. Move the pointer until the plus cursor appears.');
+            return;
+        }
+        growCutLog.info('ClickSegment: click', {
+            worldPoint,
+            toleranceBytes: probe.toleranceBytes,
+            regionAreaMm2: probe.regionAreaMm2,
+            band: { min: probe.range.min, max: probe.range.max },
+        });
+        const memo = this.beginLabelmapMemo(segmentation, labelmapVolume);
+        let filledPoints;
+        try {
+            filledPoints = await this.fillWithRange(probe.range, {
+                segmentation,
+                viewportId,
+                renderingEngineId,
+            }, viewport, labelmapVolume, element, memo);
+        }
+        finally {
+            this.doneEditMemo();
+        }
+        this.lastClick = {
+            expandContext: probe.expandContext,
+            toleranceBytes: probe.expandContext.chosenToleranceBytes,
+            worldPoint: [...worldPoint],
+            filledPoints,
+            segmentation,
+            viewportId,
+            renderingEngineId,
+        };
+        growCutLog.info('ClickSegment: click complete', {
+            filledVoxels: filledPoints.length,
+            segmentIndex,
+        });
+    }
+    async fillWithRange(range, target, viewport, labelmapVolume, element, memo) {
+        const { segmentation } = target;
+        const { referencedVolumeId, segmentIndex, segmentationId } = segmentation;
+        this.segmentationInProgress = true;
+        if (element) {
+            element.style.cursor = 'wait';
+        }
+        const abortController = new AbortController();
+        this.clickAbortController = abortController;
+        let filledPoints = [];
+        let notLesionLike = false;
+        try {
+            const referencedVolume = _cornerstonejs_core__rspack_import_0.cache.getVolume(referencedVolumeId);
+            if (!referencedVolume) {
+                throw new Error('ClickSegment: referenced volume is no longer cached; cannot fill.');
+            }
+            const result = await (0,_utilities_segmentation_growCut_runFloodFillSegmentation_js__rspack_import_2/* .runFloodFillSegmentation */.ZC)({
+                referencedVolumeId,
+                worldPosition: this.indexToWorld(referencedVolume, range.ijkStart),
+                viewport,
+                labelmapVolume,
+                options: {
+                    segmentIndex,
+                    getIntensityRange: () => range,
+                    element: viewport.element,
+                    applyExternalIslandRemoval: true,
+                    applyInternalIslandRemoval: true,
+                    maxDeltaK: this.configuration.maxDeltaK,
+                    maxDeltaIJ: this.configuration.maxDeltaIJ,
+                    isCancelled: () => abortController.signal.aborted,
+                    maxVoxels: this.computeVoxelBudget(referencedVolume),
+                    shouldContinueRegion: this.makeRegionShapeGate(referencedVolume),
+                    historyVoxelManager: memo?.voxelManager,
+                    onRejected: ({ voxelCount, bbox }) => {
+                        notLesionLike = true;
+                        growCutLog.info('ClickSegment: fill rejected by shape gate', {
+                            voxelCount,
+                            bbox,
+                        });
+                    },
+                    onCommitted: (points) => {
+                        filledPoints = points;
+                    },
+                },
+            });
+            if (!result) {
+                if (abortController.signal.aborted) {
+                    throw new Error('ClickSegment: fill cancelled.');
+                }
+                throw new Error(notLesionLike
+                    ? NOT_LESION_MESSAGE
+                    : 'ClickSegment: fill produced no result (band rejected).');
+            }
+            (0,_stateManagement_segmentation_triggerSegmentationEvents_js__rspack_import_7.triggerSegmentationDataModified)(segmentationId);
+            return filledPoints;
+        }
+        finally {
+            if (this.clickAbortController === abortController) {
+                this.clickAbortController = null;
+            }
+            this.segmentationInProgress = false;
+            if (element) {
+                element.style.cursor = _regionSegmentHoverCursors_js__rspack_import_9/* .PENDING_CURSOR */.t5;
+            }
+        }
+    }
+    indexToWorld(volume, ijk) {
+        return _cornerstonejs_core__rspack_import_0.utilities.transformIndexToWorld(volume.imageData, ijk);
+    }
+    beginLabelmapMemo(segmentation, labelmapVolume) {
+        const memo = _utilities_segmentation_createLabelmapMemo_js__rspack_import_8.createLabelmapMemo(segmentation.segmentationId, labelmapVolume.voxelManager);
+        this.memo = memo;
+        return memo;
+    }
+    curveSizeAt(context, toleranceBytes) {
+        let size = 0;
+        for (const [level, levelSize] of context.growthCurve) {
+            if (level > toleranceBytes) {
+                break;
+            }
+            size = levelSize;
+        }
+        return size;
+    }
+    pickNextTolerance(direction) {
+        const lastClick = this.lastClick;
+        if (!lastClick) {
+            return null;
+        }
+        const { expandContext, toleranceBytes } = lastClick;
+        const currentSize = this.curveSizeAt(expandContext, toleranceBytes);
+        if (direction > 0) {
+            for (const [level, size] of expandContext.growthCurve) {
+                if (level <= toleranceBytes) {
+                    continue;
+                }
+                if (size >= Math.max(currentSize + 1, currentSize * EXPAND_STEP_FACTOR)) {
+                    return level;
+                }
+            }
+            return null;
+        }
+        for (let index = expandContext.growthCurve.length - 1; index >= 0; index--) {
+            const [level, size] = expandContext.growthCurve[index];
+            if (level >= toleranceBytes) {
+                continue;
+            }
+            if (size <= Math.min(currentSize - 1, currentSize * SHRINK_STEP_FACTOR)) {
+                return level;
+            }
+        }
+        return null;
+    }
+    expand() {
+        this.stepTolerance(1);
+    }
+    shrink() {
+        this.stepTolerance(-1);
+    }
+    refresh() {
+        const lastClick = this.lastClick;
+        if (!lastClick || this.segmentationInProgress) {
+            return;
+        }
+        void this.refillAtTolerance(lastClick.toleranceBytes).catch((err) => {
+            growCutLog.error('ClickSegment: refresh failed', {
+                message: err instanceof Error ? err.message : String(err),
+            });
+        });
+    }
+    stepTolerance(direction) {
+        if (this.segmentationInProgress) {
+            return;
+        }
+        const lastClick = this.lastClick;
+        if (!lastClick) {
+            growCutLog.info('ClickSegment: no click to expand/shrink yet');
+            return;
+        }
+        const next = this.pickNextTolerance(direction);
+        if (next === null) {
+            growCutLog.info('ClickSegment: no further step available', {
+                direction: direction > 0 ? 'expand' : 'shrink',
+                toleranceBytes: lastClick.toleranceBytes,
+            });
+            return;
+        }
+        growCutLog.info('ClickSegment: stepping tolerance', {
+            direction: direction > 0 ? 'expand' : 'shrink',
+            fromToleranceBytes: lastClick.toleranceBytes,
+            toToleranceBytes: next,
+            predictedRegionPx: this.curveSizeAt(lastClick.expandContext, next),
+        });
+        const previousTolerance = lastClick.toleranceBytes;
+        void this.refillAtTolerance(next).catch((err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            if (message === NOT_LESION_MESSAGE && direction > 0) {
+                growCutLog.info('ClickSegment: expand blocked by the lesion shape gate; previous result kept', { previousTolerance });
+                this.notifySegmentationError('Expanding further would leak beyond a lesion-like shape; kept the previous result.');
+                return;
+            }
+            growCutLog.error('ClickSegment: expand/shrink failed', { message });
+        });
+    }
+    async refillAtTolerance(toleranceBytes) {
+        const lastClick = this.lastClick;
+        if (!lastClick) {
+            return;
+        }
+        const { segmentation, viewportId, renderingEngineId } = lastClick;
+        const labelmapVolume = _cornerstonejs_core__rspack_import_0.cache.getVolume(segmentation.labelmapVolumeId);
+        const renderingEngine = (0,_cornerstonejs_core__rspack_import_0.getRenderingEngine)(renderingEngineId);
+        const viewport = renderingEngine?.getViewport(viewportId);
+        if (!labelmapVolume || !viewport) {
+            growCutLog.warn('ClickSegment: labelmap or viewport gone; cannot expand/shrink');
+            return;
+        }
+        const memo = this.beginLabelmapMemo(segmentation, labelmapVolume);
+        try {
+            const { voxelManager } = labelmapVolume;
+            const historyVm = memo.voxelManager;
+            const [width, height] = labelmapVolume.dimensions;
+            const pixelsPerSlice = width * height;
+            const { segmentIndex } = segmentation;
+            const clearedIndices = [];
+            for (const [x, y, z] of lastClick.filledPoints) {
+                const index = z * pixelsPerSlice + y * width + x;
+                if (voxelManager.getAtIndex(index) === segmentIndex) {
+                    historyVm.setAtIndex(index, 0);
+                    clearedIndices.push(index);
+                }
+            }
+            const range = (0,_utilities_segmentation_growCut_intensityRange_adaptiveRegionIntensityRange_js__rspack_import_4/* .resolveAdaptiveBandAtTolerance */.CN)(lastClick.expandContext, toleranceBytes);
+            try {
+                const filledPoints = await this.fillWithRange(range, {
+                    segmentation,
+                    viewportId,
+                    renderingEngineId,
+                }, viewport, labelmapVolume, this.lastHoverElement ?? undefined, memo);
+                lastClick.toleranceBytes = toleranceBytes;
+                lastClick.filledPoints = filledPoints;
+                growCutLog.info('ClickSegment: refill complete', {
+                    toleranceBytes,
+                    filledVoxels: filledPoints.length,
+                });
+            }
+            catch (err) {
+                for (const index of clearedIndices) {
+                    historyVm.setAtIndex(index, segmentIndex);
+                }
+                (0,_stateManagement_segmentation_triggerSegmentationEvents_js__rspack_import_7.triggerSegmentationDataModified)(segmentation.segmentationId);
+                throw err;
+            }
+        }
+        finally {
+            this.doneEditMemo();
+        }
+    }
+}
+ClickSegmentTool.toolName = 'ClickSegment';
+/* export default */ const __rspack_default_export = (ClickSegmentTool);
+
+
 },
 6902(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
@@ -31674,12 +32264,12 @@ __webpack_require__.d(__webpack_exports__, {
   EV: () => (/* reexport safe */ _annotation_CobbAngleTool_js__rspack_import_39.A),
   Eb: () => (/* reexport safe */ _VolumeCroppingControlTool_js__rspack_import_4.A),
   FE: () => (/* reexport safe */ _ScaleOverlayTool_js__rspack_import_18.A),
-  Fz: () => (/* reexport safe */ _segmentation_SegmentBidirectionalTool_js__rspack_import_59.A),
-  G2: () => (/* reexport safe */ _segmentation_CircleScissorsTool_js__rspack_import_49.A),
-  IX: () => (/* reexport safe */ _segmentation_SegmentSelectTool_js__rspack_import_58.A),
+  Fz: () => (/* reexport safe */ _segmentation_SegmentBidirectionalTool_js__rspack_import_60.A),
+  G2: () => (/* reexport safe */ _segmentation_CircleScissorsTool_js__rspack_import_50.A),
+  IX: () => (/* reexport safe */ _segmentation_SegmentSelectTool_js__rspack_import_59.A),
   Ix: () => (/* reexport safe */ _annotation_LivewireContourSegmentationTool_js__rspack_import_36.A),
   J2: () => (/* reexport safe */ _annotation_SplineROITool_js__rspack_import_31.A),
-  LK: () => (/* reexport safe */ _segmentation_LabelmapEditWithContour_js__rspack_import_62.A),
+  LK: () => (/* reexport safe */ _segmentation_LabelmapEditWithContour_js__rspack_import_63.A),
   LW: () => (/* reexport safe */ _annotation_LengthTool_js__rspack_import_23.A),
   M$: () => (/* reexport safe */ _AdvancedMagnifyTool_js__rspack_import_13.A),
   Mu: () => (/* reexport safe */ _annotation_BidirectionalTool_js__rspack_import_21.A),
@@ -31693,12 +32283,13 @@ __webpack_require__.d(__webpack_exports__, {
   So: () => (/* reexport safe */ _TrackballRotateTool_js__rspack_import_2.A),
   T8: () => (/* reexport safe */ _annotation_UltrasoundPleuraBLineTool_UltrasoundPleuraBLineTool_js__rspack_import_41.A),
   TG: () => (/* reexport safe */ _WindowLevelRegionTool_js__rspack_import_6.A),
-  TR: () => (/* reexport safe */ _segmentation_RectangleROIThresholdTool_js__rspack_import_51.A),
-  Tc: () => (/* reexport safe */ _annotation_WholeBodySegmentTool_js__rspack_import_46.A),
-  Uj: () => (/* reexport safe */ _segmentation_PaintFillTool_js__rspack_import_55.A),
+  TR: () => (/* reexport safe */ _segmentation_RectangleROIThresholdTool_js__rspack_import_52.A),
+  Tc: () => (/* reexport safe */ _annotation_WholeBodySegmentTool_js__rspack_import_47.A),
+  Uj: () => (/* reexport safe */ _segmentation_PaintFillTool_js__rspack_import_56.A),
   Vl: () => (/* reexport safe */ _annotation_CircleROITool_js__rspack_import_29.A),
   X8: () => (/* reexport safe */ _ReferenceLinesTool_js__rspack_import_14.A),
-  Xr: () => (/* reexport safe */ _OrientationMarkerTool_js__rspack_import_56.A),
+  Xr: () => (/* reexport safe */ _OrientationMarkerTool_js__rspack_import_57.A),
+  Yk: () => (/* reexport safe */ _annotation_ClickSegmentTool_js__rspack_import_46.A),
   Ys: () => (/* reexport safe */ _annotation_LivewireContourTool_js__rspack_import_35.A),
   ae: () => (/* reexport safe */ _StackScrollTool_js__rspack_import_7.A),
   ao: () => (/* reexport safe */ _annotation_ArrowAnnotateTool_js__rspack_import_37.A),
@@ -31708,28 +32299,28 @@ __webpack_require__.d(__webpack_exports__, {
   ep: () => (/* reexport safe */ _CrosshairsTool_js__rspack_import_11.A),
   ex: () => (/* reexport safe */ _annotation_PlanarFreehandROITool_js__rspack_import_33.A),
   hz: () => (/* reexport safe */ _annotation_LabelTool_js__rspack_import_22.A),
-  il: () => (/* reexport safe */ _segmentation_LabelmapBaseTool_js__rspack_import_47.A),
+  il: () => (/* reexport safe */ _segmentation_LabelmapBaseTool_js__rspack_import_48.A),
   j$: () => (/* reexport safe */ _annotation_DragProbeTool_js__rspack_import_26.A),
-  ls: () => (/* reexport safe */ _segmentation_BrushTool_js__rspack_import_54.A),
+  ls: () => (/* reexport safe */ _segmentation_BrushTool_js__rspack_import_55.A),
   m8: () => (/* reexport safe */ _annotation_HeightTool_js__rspack_import_24.A),
-  mX: () => (/* reexport safe */ _segmentation_RectangleROIStartEndThresholdTool_js__rspack_import_52.A),
+  mX: () => (/* reexport safe */ _segmentation_RectangleROIStartEndThresholdTool_js__rspack_import_53.A),
   nJ: () => (/* reexport safe */ _annotation_ETDRSGridTool_js__rspack_import_30.A),
   oS: () => (/* reexport safe */ _base_index_js__rspack_import_0.oS),
   oi: () => (/* reexport safe */ _annotation_UltrasoundDirectionalTool_js__rspack_import_40.A),
-  pq: () => (/* reexport safe */ _segmentation_CircleROIStartEndThresholdTool_js__rspack_import_53.A),
+  pq: () => (/* reexport safe */ _segmentation_CircleROIStartEndThresholdTool_js__rspack_import_54.A),
   qD: () => (/* reexport safe */ _annotation_EllipticalROITool_js__rspack_import_28.A),
   qT: () => (/* reexport safe */ _annotation_SplineContourSegmentationTool_js__rspack_import_32.A),
   qi: () => (/* reexport safe */ _annotation_PlanarFreehandContourSegmentationTool_js__rspack_import_34.A),
   sR: () => (/* reexport safe */ _annotation_RegionSegmentPlusTool_js__rspack_import_45.A),
-  td: () => (/* reexport safe */ _segmentation_RectangleScissorsTool_js__rspack_import_48.A),
-  u9: () => (/* reexport safe */ _segmentation_SegmentLabelTool_js__rspack_import_61.A),
+  td: () => (/* reexport safe */ _segmentation_RectangleScissorsTool_js__rspack_import_49.A),
+  u9: () => (/* reexport safe */ _segmentation_SegmentLabelTool_js__rspack_import_62.A),
   uJ: () => (/* reexport safe */ _MIPJumpToClickTool_js__rspack_import_10.A),
-  v: () => (/* reexport safe */ _OrientationControllerTool_js__rspack_import_57.A),
+  v: () => (/* reexport safe */ _OrientationControllerTool_js__rspack_import_58.A),
   wR: () => (/* reexport safe */ _annotation_RegionSegmentTool_js__rspack_import_44.A),
   wh: () => (/* reexport safe */ _base_index_js__rspack_import_0.wh),
   xI: () => (/* reexport safe */ _ReferenceCursors_js__rspack_import_17.A),
   yT: () => (/* reexport safe */ _annotation_AngleTool_js__rspack_import_38.A),
-  zH: () => (/* reexport safe */ _segmentation_SphereScissorsTool_js__rspack_import_50.A)
+  zH: () => (/* reexport safe */ _segmentation_SphereScissorsTool_js__rspack_import_51.A)
 });
 /* import */ var _base_index_js__rspack_import_0 = __webpack_require__(84962);
 /* import */ var _PanTool_js__rspack_import_1 = __webpack_require__(30507);
@@ -31777,23 +32368,25 @@ __webpack_require__.d(__webpack_exports__, {
 /* import */ var _AnnotationEraserTool_js__rspack_import_43 = __webpack_require__(39447);
 /* import */ var _annotation_RegionSegmentTool_js__rspack_import_44 = __webpack_require__(41589);
 /* import */ var _annotation_RegionSegmentPlusTool_js__rspack_import_45 = __webpack_require__(20053);
-/* import */ var _annotation_WholeBodySegmentTool_js__rspack_import_46 = __webpack_require__(19146);
-/* import */ var _segmentation_LabelmapBaseTool_js__rspack_import_47 = __webpack_require__(28182);
-/* import */ var _segmentation_RectangleScissorsTool_js__rspack_import_48 = __webpack_require__(37661);
-/* import */ var _segmentation_CircleScissorsTool_js__rspack_import_49 = __webpack_require__(69288);
-/* import */ var _segmentation_SphereScissorsTool_js__rspack_import_50 = __webpack_require__(74161);
-/* import */ var _segmentation_RectangleROIThresholdTool_js__rspack_import_51 = __webpack_require__(98283);
-/* import */ var _segmentation_RectangleROIStartEndThresholdTool_js__rspack_import_52 = __webpack_require__(43372);
-/* import */ var _segmentation_CircleROIStartEndThresholdTool_js__rspack_import_53 = __webpack_require__(97125);
-/* import */ var _segmentation_BrushTool_js__rspack_import_54 = __webpack_require__(70947);
-/* import */ var _segmentation_PaintFillTool_js__rspack_import_55 = __webpack_require__(64702);
-/* import */ var _OrientationMarkerTool_js__rspack_import_56 = __webpack_require__(87452);
-/* import */ var _OrientationControllerTool_js__rspack_import_57 = __webpack_require__(8342);
-/* import */ var _segmentation_SegmentSelectTool_js__rspack_import_58 = __webpack_require__(69318);
-/* import */ var _segmentation_SegmentBidirectionalTool_js__rspack_import_59 = __webpack_require__(44391);
-/* import */ var _segmentation_strategies_index_js__rspack_import_60 = __webpack_require__(62831);
-/* import */ var _segmentation_SegmentLabelTool_js__rspack_import_61 = __webpack_require__(97198);
-/* import */ var _segmentation_LabelmapEditWithContour_js__rspack_import_62 = __webpack_require__(54267);
+/* import */ var _annotation_ClickSegmentTool_js__rspack_import_46 = __webpack_require__(62843);
+/* import */ var _annotation_WholeBodySegmentTool_js__rspack_import_47 = __webpack_require__(19146);
+/* import */ var _segmentation_LabelmapBaseTool_js__rspack_import_48 = __webpack_require__(28182);
+/* import */ var _segmentation_RectangleScissorsTool_js__rspack_import_49 = __webpack_require__(37661);
+/* import */ var _segmentation_CircleScissorsTool_js__rspack_import_50 = __webpack_require__(69288);
+/* import */ var _segmentation_SphereScissorsTool_js__rspack_import_51 = __webpack_require__(74161);
+/* import */ var _segmentation_RectangleROIThresholdTool_js__rspack_import_52 = __webpack_require__(98283);
+/* import */ var _segmentation_RectangleROIStartEndThresholdTool_js__rspack_import_53 = __webpack_require__(43372);
+/* import */ var _segmentation_CircleROIStartEndThresholdTool_js__rspack_import_54 = __webpack_require__(97125);
+/* import */ var _segmentation_BrushTool_js__rspack_import_55 = __webpack_require__(70947);
+/* import */ var _segmentation_PaintFillTool_js__rspack_import_56 = __webpack_require__(64702);
+/* import */ var _OrientationMarkerTool_js__rspack_import_57 = __webpack_require__(87452);
+/* import */ var _OrientationControllerTool_js__rspack_import_58 = __webpack_require__(8342);
+/* import */ var _segmentation_SegmentSelectTool_js__rspack_import_59 = __webpack_require__(69318);
+/* import */ var _segmentation_SegmentBidirectionalTool_js__rspack_import_60 = __webpack_require__(44391);
+/* import */ var _segmentation_strategies_index_js__rspack_import_61 = __webpack_require__(62831);
+/* import */ var _segmentation_SegmentLabelTool_js__rspack_import_62 = __webpack_require__(97198);
+/* import */ var _segmentation_LabelmapEditWithContour_js__rspack_import_63 = __webpack_require__(54267);
+
 
 
 
@@ -42485,6 +43078,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
   createLabelmapMemo: () => (createLabelmapMemo),
   createRleMemo: () => (createRleMemo),
+  memoAsStep: () => (memoAsStep),
   restoreMemo: () => (restoreMemo)
 });
 /* import */ var _cornerstonejs_core__rspack_import_0 = __webpack_require__(88479);
@@ -42495,14 +43089,46 @@ const { VoxelManager, RLEVoxelMap } = _cornerstonejs_core__rspack_import_0.utili
 function createLabelmapMemo(segmentationId, segmentationVoxelManager) {
     return createRleMemo(segmentationId, segmentationVoxelManager);
 }
+function memoAsStep(memo) {
+    return {
+        undo: () => memo.restoreMemo(true),
+        redo: () => memo.restoreMemo(false),
+    };
+}
 function restoreMemo(isUndo) {
-    const { segmentationVoxelManager, undoVoxelManager, redoVoxelManager } = this;
-    const useVoxelManager = isUndo === false ? redoVoxelManager : undoVoxelManager;
-    useVoxelManager.forEach(({ value, pointIJK }) => {
-        segmentationVoxelManager.setAtIJKPoint(pointIJK, value);
-    });
-    const slices = useVoxelManager.getArrayOfModifiedSlices();
-    (0,_stateManagement_segmentation_triggerSegmentationEvents_js__rspack_import_1.triggerSegmentationDataModified)(this.segmentationId, slices);
+    const undo = isUndo !== false;
+    const priorSteps = this.priorSteps ?? [];
+    const postSteps = this.postSteps ?? [];
+    const restoreVoxelChanges = () => {
+        const { segmentationVoxelManager, undoVoxelManager, redoVoxelManager } = this;
+        const useVoxelManager = undo ? undoVoxelManager : redoVoxelManager;
+        if (!useVoxelManager) {
+            return;
+        }
+        useVoxelManager.forEach(({ value, pointIJK }) => {
+            segmentationVoxelManager.setAtIJKPoint(pointIJK, value);
+        });
+        const slices = useVoxelManager.getArrayOfModifiedSlices();
+        (0,_stateManagement_segmentation_triggerSegmentationEvents_js__rspack_import_1.triggerSegmentationDataModified)(this.segmentationId, slices);
+    };
+    if (undo) {
+        for (let i = postSteps.length - 1; i >= 0; i--) {
+            postSteps[i].undo();
+        }
+        restoreVoxelChanges();
+        for (let i = priorSteps.length - 1; i >= 0; i--) {
+            priorSteps[i].undo();
+        }
+    }
+    else {
+        for (const step of priorSteps) {
+            step.redo();
+        }
+        restoreVoxelChanges();
+        for (const step of postSteps) {
+            step.redo();
+        }
+    }
 }
 function createRleMemo(segmentationId, segmentationVoxelManager) {
     const voxelManager = VoxelManager.createRLEHistoryVoxelManager(segmentationVoxelManager);
@@ -42521,8 +43147,9 @@ function commitMemo() {
     if (this.redoVoxelManager) {
         return true;
     }
+    const hasSteps = !!(this.priorSteps?.length || this.postSteps?.length);
     if (!this.voxelManager.modifiedSlices.size) {
-        return false;
+        return hasSteps;
     }
     const { segmentationVoxelManager } = this;
     const undoVoxelManager = VoxelManager.createRLEHistoryVoxelManager(segmentationVoxelManager);
@@ -45123,7 +45750,7 @@ __webpack_require__.d(__webpack_exports__, {
 
 },
 80274() {
-const version = '5.4.12';
+const version = '5.4.13';
 
 
 },