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

package/dist/{2690.bundle.f5dc28ac498de122.js → 3568.bundle.45dc681ef6890166.js}

@@ -1,5 +1,5 @@
 "use strict";
-(globalThis["rspackChunk"] = globalThis["rspackChunk"] || []).push([[2690], {
+(globalThis["rspackChunk"] = globalThis["rspackChunk"] || []).push([[3568], {
 69501(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
   A: () => (__rspack_default_export)
@@ -855,6 +855,182 @@ function getVolumeViewportLabelmapImageMapperState(viewport) {
 
 
 
+},
+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);
+}
+
+
+
 },
 9484(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
@@ -1707,6 +1883,19 @@ function defaultGetTextLines(data, targetId) {
 /* export default */ const __rspack_default_export = (BidirectionalTool);
 
 
+},
+58690(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  kC: () => (BLOCKED_CURSOR),
+  t5: () => (PENDING_CURSOR),
+  ys: () => (PLUS_CURSOR)
+});
+const CIRCLE_CURSOR = "url(\"data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='24'%20height='24'%3E%3Ccircle%20cx='12'%20cy='12'%20r='9'%20fill='none'%20stroke='%2300dc82'%20stroke-width='2'/%3E%3C/svg%3E\") 12 12, crosshair";
+const PLUS_CURSOR = "url(\"data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='24'%20height='24'%3E%3Ccircle%20cx='12'%20cy='12'%20r='9'%20fill='none'%20stroke='%2300dc82'%20stroke-width='2'/%3E%3Cpath%20d='M12%208v8M8%2012h8'%20stroke='%2300dc82'%20stroke-width='2'%20stroke-linecap='round'/%3E%3C/svg%3E\") 12 12, copy";
+const BLOCKED_CURSOR = "url(\"data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='24'%20height='24'%3E%3Ccircle%20cx='12'%20cy='12'%20r='9'%20fill='none'%20stroke='%23ff5a5a'%20stroke-width='2'/%3E%3Cpath%20d='M5.7%205.7L18.3%2018.3'%20stroke='%23ff5a5a'%20stroke-width='2'%20stroke-linecap='round'/%3E%3C/svg%3E\") 12 12, not-allowed";
+const PENDING_CURSOR = "url(\"data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='24'%20height='24'%3E%3Ccircle%20cx='12'%20cy='12'%20r='9'%20fill='none'%20stroke='%23a0a6ad'%20stroke-width='2'%20stroke-dasharray='4%203'/%3E%3C/svg%3E\") 12 12, progress";
+
+
 },
 47844(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
@@ -4432,6 +4621,7 @@ class BrushTool extends _LabelmapBaseTool_js__rspack_import_9/* ["default"] */.A
             };
             this._hoverData = this.createHoverData(element, canvasPoint);
             if (!this._hoverData) {
+                this._editData = null;
                 return false;
             }
             this._calculateCursor(element, canvasPoint);
@@ -5964,6 +6154,180 @@ function lpad(string, character, length) {
 /* export default */ const __rspack_default_export = (floodFill);
 
 
+},
+10621(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  x: () => (floodFill3dSliceLazy)
+});
+const FLOOD_SLICE_FLAG_VISITED = 1;
+async function floodFill3dSliceLazy(getter, seed, options) {
+    const { width: w, height: h, depth: d, equals, ensureSliceLoaded, yieldEvery = 500, planar = false, maxDeltaK, maxDeltaIJ, isCancelled, maxVoxels, shouldContinue, validateEvery = 2048, } = options;
+    const [sx, sy, sz] = seed;
+    if (sx < 0 || sx >= w || sy < 0 || sy >= h || sz < 0 || sz >= d) {
+        return {
+            sliceMasks: new Map(),
+            voxelCount: 0,
+            truncated: false,
+            bbox: null,
+        };
+    }
+    if (ensureSliceLoaded) {
+        await ensureSliceLoaded(sz);
+    }
+    const startNode = getter(sx, sy, sz);
+    if (!equals(startNode, startNode)) {
+        return {
+            sliceMasks: new Map(),
+            voxelCount: 0,
+            truncated: false,
+            bbox: null,
+        };
+    }
+    const frameSize = w * h;
+    const sliceMasks = new Map();
+    function sliceFlags(z) {
+        let a = sliceMasks.get(z);
+        if (!a) {
+            a = new Uint8Array(frameSize);
+            sliceMasks.set(z, a);
+        }
+        return a;
+    }
+    function isVisited(z, x, y) {
+        const a = sliceMasks.get(z);
+        if (!a) {
+            return false;
+        }
+        return (a[y * w + x] & FLOOD_SLICE_FLAG_VISITED) !== 0;
+    }
+    function setVisited(z, x, y) {
+        sliceFlags(z)[y * w + x] |= FLOOD_SLICE_FLAG_VISITED;
+    }
+    function pack(x, y, z) {
+        return z * frameSize + y * w + x;
+    }
+    function unpack(p) {
+        const x = p % w;
+        const t1 = Math.floor(p / w);
+        const y = t1 % h;
+        const z = Math.floor(t1 / h);
+        return [x, y, z];
+    }
+    const dirs = planar
+        ? [
+            [1, 0, 0],
+            [-1, 0, 0],
+            [0, 1, 0],
+            [0, -1, 0],
+        ]
+        : [
+            [1, 0, 0],
+            [-1, 0, 0],
+            [0, 1, 0],
+            [0, -1, 0],
+            [0, 0, 1],
+            [0, 0, -1],
+        ];
+    const queue = [];
+    let qh = 0;
+    queue.push(pack(sx, sy, sz));
+    setVisited(sz, sx, sy);
+    let minX = sx;
+    let maxX = sx;
+    let minY = sy;
+    let maxY = sy;
+    let minZ = sz;
+    let maxZ = sz;
+    const currentBBox = () => ({
+        min: [minX, minY, minZ],
+        max: [maxX, maxY, maxZ],
+    });
+    let steps = 0;
+    let truncated = false;
+    let nextValidateAt = validateEvery;
+    while (qh < queue.length) {
+        if (isCancelled?.()) {
+            break;
+        }
+        if (maxVoxels !== undefined && queue.length > maxVoxels) {
+            truncated = true;
+            break;
+        }
+        if (shouldContinue && queue.length >= nextValidateAt) {
+            nextValidateAt += validateEvery;
+            if (!shouldContinue({ voxelCount: queue.length, bbox: currentBBox() })) {
+                truncated = true;
+                break;
+            }
+        }
+        steps++;
+        if (yieldEvery > 0 && steps % yieldEvery === 0) {
+            await new Promise((r) => setTimeout(r, 0));
+        }
+        const p = queue[qh++];
+        const [x, y, z] = unpack(p);
+        for (let di = 0; di < dirs.length; di++) {
+            const nx = x + dirs[di][0];
+            const ny = y + dirs[di][1];
+            const nz = z + dirs[di][2];
+            if (nx < 0 || nx >= w || ny < 0 || ny >= h || nz < 0 || nz >= d) {
+                continue;
+            }
+            if (maxDeltaK >= 0 && Math.abs(nz - sz) > maxDeltaK) {
+                continue;
+            }
+            if (maxDeltaIJ >= 0 &&
+                (Math.abs(nx - sx) > maxDeltaIJ || Math.abs(ny - sy) > maxDeltaIJ)) {
+                continue;
+            }
+            if (planar && nz !== sz) {
+                continue;
+            }
+            if (isVisited(nz, nx, ny)) {
+                continue;
+            }
+            if (ensureSliceLoaded) {
+                await ensureSliceLoaded(nz);
+                if (isCancelled?.()) {
+                    break;
+                }
+            }
+            const nv = getter(nx, ny, nz);
+            if (!equals(nv, startNode)) {
+                continue;
+            }
+            setVisited(nz, nx, ny);
+            queue.push(pack(nx, ny, nz));
+            if (nx < minX) {
+                minX = nx;
+            }
+            else if (nx > maxX) {
+                maxX = nx;
+            }
+            if (ny < minY) {
+                minY = ny;
+            }
+            else if (ny > maxY) {
+                maxY = ny;
+            }
+            if (nz < minZ) {
+                minZ = nz;
+            }
+            else if (nz > maxZ) {
+                maxZ = nz;
+            }
+        }
+    }
+    const voxelCount = queue.length;
+    return {
+        sliceMasks,
+        voxelCount,
+        truncated,
+        bbox: voxelCount > 0 ? currentBBox() : null,
+    };
+}
+
+
 },
 91662(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
@@ -6242,6 +6606,34 @@ const DEFAULT_NEGATIVE_SEEDS_COUNT = 70;
 const MAX_NEGATIVE_SEED_ATTEMPTS_MULTIPLIER = 50;
 
 
+},
+1967(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  K: () => (getViewportVoiMappingForVolume)
+});
+function getViewportVoiMappingForVolume(viewport, volumeId) {
+    const getProps = viewport.getProperties;
+    if (typeof getProps !== 'function') {
+        return null;
+    }
+    const props = volumeId
+        ? getProps.call(viewport, volumeId)
+        : getProps.call(viewport);
+    if (!props?.voiRange) {
+        return null;
+    }
+    const { lower, upper } = props.voiRange;
+    if (typeof lower !== 'number' || typeof upper !== 'number') {
+        return null;
+    }
+    return {
+        voiRange: { lower, upper },
+        VOILUTFunction: props.VOILUTFunction,
+        invert: props.invert === true,
+    };
+}
+
+
 },
 20326(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
@@ -6397,90 +6789,1540 @@ fn main(
 
 
 },
-14386(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+81537(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  e: () => (runGrowCut)
+  CN: () => (resolveAdaptiveBandAtTolerance),
+  Ti: () => (probeAdaptiveRegion)
 });
 /* import */ var _cornerstonejs_core__rspack_import_0 = __webpack_require__(88479);
-/* import */ var _growCutShader_js__rspack_import_1 = __webpack_require__(20326);
+/* import */ var _getViewportVoiMappingForVolume_js__rspack_import_1 = __webpack_require__(1967);
+/* import */ var _constants_js__rspack_import_2 = __webpack_require__(29735);
 
 
-const GB = 1024 * 1024 * 1024;
-const WEBGPU_MEMORY_LIMIT = 1.99 * GB;
-const DEFAULT_GROWCUT_OPTIONS = {
-    windowSize: 3,
-    maxProcessingTime: 30000,
-    inspection: {
-        numCyclesInterval: 5,
-        numCyclesBelowThreshold: 3,
-        threshold: 1e-4,
-    },
-};
-async function runGrowCut(referenceVolumeId, labelmapVolumeId, options = DEFAULT_GROWCUT_OPTIONS) {
-    const workGroupSize = [8, 8, 4];
-    const { windowSize, maxProcessingTime } = Object.assign({}, DEFAULT_GROWCUT_OPTIONS, options);
-    const inspection = Object.assign({}, DEFAULT_GROWCUT_OPTIONS.inspection, options.inspection);
-    const volume = _cornerstonejs_core__rspack_import_0.cache.getVolume(referenceVolumeId);
-    const labelmap = _cornerstonejs_core__rspack_import_0.cache.getVolume(labelmapVolumeId);
-    const [columns, rows, numSlices] = volume.dimensions;
-    if (labelmap.dimensions[0] !== columns ||
-        labelmap.dimensions[1] !== rows ||
-        labelmap.dimensions[2] !== numSlices) {
-        throw new Error('Volume and labelmap must have the same size');
+
+const { transformWorldToIndex, mapScalarToViewportVoiIntensity, mapViewportVoiIntensityToScalar, getVolumeDirectionVectors, } = _cornerstonejs_core__rspack_import_0.utilities;
+const { growCutLog: log } = _cornerstonejs_core__rspack_import_0.utilities.logger;
+const WINDOW_RADIUS_PX = 96;
+const SEED_SNAP_RADIUS_PX = 4;
+const MIN_REGION_PX = 6;
+const MIN_REGION_MM2 = 8;
+const MAX_REGION_WINDOW_FRACTION = 0.6;
+const FLAT_CONTRAST_BYTES = 10;
+const MIN_TOLERANCE_BYTES = 2;
+const MIN_PLATEAU_WIDTH_BYTES = 4;
+const QUIET_GAIN_ABS_PX = 3;
+const QUIET_GAIN_FRACTION = 0.02;
+function medianOf(values) {
+    if (!values.length) {
+        return 0;
     }
-    let numIterations = Math.floor(Math.sqrt(rows ** 2 + columns ** 2 + numSlices ** 2) / 2);
-    numIterations = Math.min(numIterations, 500);
-    const labelmapData = labelmap.voxelManager.getCompleteScalarDataArray();
-    let volumePixelData = volume.voxelManager.getCompleteScalarDataArray();
-    if (!(volumePixelData instanceof Float32Array)) {
-        volumePixelData = new Float32Array(volumePixelData);
+    const sorted = values.slice().sort((a, b) => a - b);
+    return sorted[Math.floor(sorted.length / 2)];
+}
+function rawBandForTolerance(context, toleranceBytes) {
+    const { seedByte, polarity, voiMapping, rawWindow, seedScalar } = context;
+    const thresholdByte = Math.max(0, Math.min(255, polarity > 0 ? seedByte - toleranceBytes : seedByte + toleranceBytes));
+    const includedExtremeByte = polarity > 0 ? 255 : 0;
+    const rawFromByte = (byte) => voiMapping
+        ? mapViewportVoiIntensityToScalar(byte / 255, voiMapping)
+        : rawWindow.min + (byte / 255) * rawWindow.span;
+    const rawThreshold = rawFromByte(thresholdByte);
+    const rawExtreme = rawFromByte(includedExtremeByte);
+    let min;
+    let max;
+    if (rawExtreme >= rawThreshold) {
+        min = rawThreshold;
+        max = Infinity;
     }
-    const requiredLimits = {
-        maxStorageBufferBindingSize: WEBGPU_MEMORY_LIMIT,
-        maxBufferSize: WEBGPU_MEMORY_LIMIT,
+    else {
+        min = -Infinity;
+        max = rawThreshold;
+    }
+    if (Number.isFinite(seedScalar)) {
+        min = Math.min(min, seedScalar);
+        max = Math.max(max, seedScalar);
+    }
+    return { min, max };
+}
+function resolveAdaptiveBandAtTolerance(context, toleranceBytes) {
+    const tolerance = Math.max(0, Math.min(255, Math.round(toleranceBytes)));
+    const { min, max } = rawBandForTolerance(context, tolerance);
+    return {
+        min,
+        max,
+        ijkStart: [...context.seedIjk],
+        diagnostics: {
+            neighborhoodMean: Number.isFinite(context.seedScalar)
+                ? context.seedScalar
+                : 0,
+            neighborhoodStdDev: 0,
+            clickedVoxelValue: Number.isFinite(context.seedScalar)
+                ? context.seedScalar
+                : 0,
+            positiveStdDevMultiplier: 1,
+            neighborhoodRadius: SEED_SNAP_RADIUS_PX,
+            strategy: 'adaptiveRegion:atTolerance',
+            adaptive: {
+                toleranceBytes: tolerance,
+                regionSizePx: -1,
+                backgroundByte: -1,
+                seedByte: context.seedByte,
+                seedSnapped: false,
+                windowSize: [0, 0],
+                polarity: context.polarity,
+            },
+        },
     };
-    const adapter = await navigator.gpu?.requestAdapter();
-    const device = await adapter.requestDevice({ requiredLimits });
-    const BUFFER_SIZE = volumePixelData.byteLength;
-    const UPDATED_VOXELS_COUNTER_BUFFER_SIZE = numIterations * Uint32Array.BYTES_PER_ELEMENT;
-    const BOUNDS_BUFFER_SIZE = 6 * Int32Array.BYTES_PER_ELEMENT;
-    const shaderModule = device.createShaderModule({
-        code: _growCutShader_js__rspack_import_1/* ["default"] */.A,
-    });
-    const numIterationIndex = 3;
-    const paramsArrayValues = new Uint32Array([
-        columns,
-        rows,
-        numSlices,
-        0,
-    ]);
-    const gpuParamsBuffer = device.createBuffer({
-        size: paramsArrayValues.byteLength,
-        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
-    });
-    const gpuVolumePixelDataBuffer = device.createBuffer({
-        size: BUFFER_SIZE,
-        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-    });
-    device.queue.writeBuffer(gpuVolumePixelDataBuffer, 0, volumePixelData);
-    const gpuLabelmapBuffers = [0, 1].map(() => device.createBuffer({
-        size: BUFFER_SIZE,
-        usage: GPUBufferUsage.STORAGE |
-            GPUBufferUsage.COPY_SRC |
-            GPUBufferUsage.COPY_DST,
-    }));
-    device.queue.writeBuffer(gpuLabelmapBuffers[0], 0, new Uint32Array(labelmapData));
-    const gpuStrengthBuffers = [0, 1].map(() => {
-        const strengthBuffer = device.createBuffer({
-            size: BUFFER_SIZE,
-            usage: GPUBufferUsage.STORAGE |
-                GPUBufferUsage.COPY_SRC |
-                GPUBufferUsage.COPY_DST,
-        });
-        return strengthBuffer;
+}
+function probeAdaptiveRegionCore(input) {
+    const { dimensions, getScalar, ijkClick, voiMapping } = input;
+    const inPlaneAxes = input.inPlaneAxes ?? [0, 1];
+    const inPlaneSpacing = input.inPlaneSpacing ?? [1, 1];
+    for (let axis = 0; axis < 3; axis++) {
+        if (ijkClick[axis] < 0 || ijkClick[axis] >= dimensions[axis]) {
+            return { viable: false, reason: 'outside-volume', range: null };
+        }
+    }
+    const [axisA, axisB] = inPlaneAxes;
+    const a0 = Math.max(0, ijkClick[axisA] - WINDOW_RADIUS_PX);
+    const a1 = Math.min(dimensions[axisA] - 1, ijkClick[axisA] + WINDOW_RADIUS_PX);
+    const b0 = Math.max(0, ijkClick[axisB] - WINDOW_RADIUS_PX);
+    const b1 = Math.min(dimensions[axisB] - 1, ijkClick[axisB] + WINDOW_RADIUS_PX);
+    const wA = a1 - a0 + 1;
+    const wB = b1 - b0 + 1;
+    const windowArea = wA * wB;
+    const spacingA = Number.isFinite(inPlaneSpacing[0]) && inPlaneSpacing[0] > 0
+        ? inPlaneSpacing[0]
+        : 1;
+    const spacingB = Number.isFinite(inPlaneSpacing[1]) && inPlaneSpacing[1] > 0
+        ? inPlaneSpacing[1]
+        : 1;
+    const pxAreaMm2 = spacingA * spacingB;
+    const minRegionPx = Math.max(MIN_REGION_PX, Math.ceil(MIN_REGION_MM2 / pxAreaMm2));
+    const maxRegionPx = Math.max(minRegionPx + 1, Math.floor(windowArea * MAX_REGION_WINDOW_FRACTION));
+    const scalarAt = (x, y) => {
+        const ijk = [...ijkClick];
+        ijk[axisA] = a0 + x;
+        ijk[axisB] = b0 + y;
+        return Number(getScalar(ijk[0], ijk[1], ijk[2]));
+    };
+    const rawValues = new Float64Array(windowArea);
+    let rawMinInWindow = Infinity;
+    let rawMaxInWindow = -Infinity;
+    for (let y = 0; y < wB; y++) {
+        for (let x = 0; x < wA; x++) {
+            const v = scalarAt(x, y);
+            rawValues[y * wA + x] = v;
+            if (Number.isFinite(v)) {
+                if (v < rawMinInWindow) {
+                    rawMinInWindow = v;
+                }
+                if (v > rawMaxInWindow) {
+                    rawMaxInWindow = v;
+                }
+            }
+        }
+    }
+    if (!Number.isFinite(rawMinInWindow)) {
+        return { viable: false, reason: 'outside-volume', range: null };
+    }
+    const rawSpan = rawMaxInWindow - rawMinInWindow || 1;
+    const bytes = new Int16Array(windowArea);
+    for (let idx = 0; idx < windowArea; idx++) {
+        const v = rawValues[idx];
+        if (!Number.isFinite(v)) {
+            bytes[idx] = -1;
+            continue;
+        }
+        const mapped = voiMapping
+            ? mapScalarToViewportVoiIntensity(v, voiMapping)
+            : (v - rawMinInWindow) / rawSpan;
+        bytes[idx] = Math.max(0, Math.min(255, Math.round(mapped * 255)));
+    }
+    const ringBytes = [];
+    for (let x = 0; x < wA; x++) {
+        if (bytes[x] >= 0) {
+            ringBytes.push(bytes[x]);
+        }
+        const bottom = (wB - 1) * wA + x;
+        if (wB > 1 && bytes[bottom] >= 0) {
+            ringBytes.push(bytes[bottom]);
+        }
+    }
+    for (let y = 1; y < wB - 1; y++) {
+        const left = y * wA;
+        const right = y * wA + (wA - 1);
+        if (bytes[left] >= 0) {
+            ringBytes.push(bytes[left]);
+        }
+        if (wA > 1 && bytes[right] >= 0) {
+            ringBytes.push(bytes[right]);
+        }
+    }
+    const backgroundByte = medianOf(ringBytes);
+    const clickX = ijkClick[axisA] - a0;
+    const clickY = ijkClick[axisB] - b0;
+    let seedX = clickX;
+    let seedY = clickY;
+    let bestContrast = -1;
+    let bestDist = Infinity;
+    const snapR2 = SEED_SNAP_RADIUS_PX * SEED_SNAP_RADIUS_PX;
+    for (let dy = -SEED_SNAP_RADIUS_PX; dy <= SEED_SNAP_RADIUS_PX; dy++) {
+        for (let dx = -SEED_SNAP_RADIUS_PX; dx <= SEED_SNAP_RADIUS_PX; dx++) {
+            if (dx * dx + dy * dy > snapR2) {
+                continue;
+            }
+            const x = clickX + dx;
+            const y = clickY + dy;
+            if (x < 0 || x >= wA || y < 0 || y >= wB) {
+                continue;
+            }
+            const byte = bytes[y * wA + x];
+            if (byte < 0) {
+                continue;
+            }
+            const contrast = Math.abs(byte - backgroundByte);
+            const dist = dx * dx + dy * dy;
+            if (contrast > bestContrast ||
+                (contrast === bestContrast && dist < bestDist)) {
+                bestContrast = contrast;
+                bestDist = dist;
+                seedX = x;
+                seedY = y;
+            }
+        }
+    }
+    if (bestContrast < 0) {
+        return { viable: false, reason: 'outside-volume', range: null };
+    }
+    if (bestContrast < FLAT_CONTRAST_BYTES) {
+        return { viable: false, reason: 'flat-region', range: null };
+    }
+    const seedPixelByte = bytes[seedY * wA + seedX];
+    const polarity = seedPixelByte >= backgroundByte ? 1 : -1;
+    const elevation = (byte) => polarity > 0 ? byte : 255 - byte;
+    const seedNeighborhood = [];
+    for (let dy = -1; dy <= 1; dy++) {
+        for (let dx = -1; dx <= 1; dx++) {
+            const x = seedX + dx;
+            const y = seedY + dy;
+            if (x < 0 || x >= wA || y < 0 || y >= wB) {
+                continue;
+            }
+            const byte = bytes[y * wA + x];
+            if (byte >= 0 &&
+                Math.abs(byte - seedPixelByte) <= Math.abs(byte - backgroundByte)) {
+                seedNeighborhood.push(byte);
+            }
+        }
+    }
+    const v0 = seedNeighborhood.length
+        ? medianOf(seedNeighborhood)
+        : seedPixelByte;
+    const h0 = elevation(v0);
+    const cost = (idx) => {
+        const byte = bytes[idx];
+        if (byte < 0) {
+            return -1;
+        }
+        return Math.max(0, h0 - elevation(byte));
+    };
+    const buckets = new Array(256);
+    const pushToBucket = (level, idx) => {
+        let bucket = buckets[level];
+        if (!bucket) {
+            bucket = [];
+            buckets[level] = bucket;
+        }
+        bucket.push(idx);
+    };
+    const visited = new Uint8Array(windowArea);
+    const seedIdx = seedY * wA + seedX;
+    const seedCost = cost(seedIdx);
+    if (seedCost < 0) {
+        return { viable: false, reason: 'flat-region', range: null };
+    }
+    pushToBucket(seedCost, seedIdx);
+    visited[seedIdx] = 1;
+    const curve = [];
+    const clickIdx = clickY * wA + clickX;
+    let clickJoinLevel = -1;
+    const neighborOffsets = [
+        [-1, 0],
+        [1, 0],
+        [0, -1],
+        [0, 1],
+    ];
+    const clickNeighborJoinLevels = [];
+    const neighborWatch = new Map();
+    neighborOffsets.forEach(([dx, dy], slot) => {
+        const x = clickX + dx;
+        const y = clickY + dy;
+        if (x < 0 || x >= wA || y < 0 || y >= wB) {
+            clickNeighborJoinLevels.push(null);
+            return;
+        }
+        clickNeighborJoinLevels.push(-1);
+        neighborWatch.set(y * wA + x, slot);
     });
-    const gpuCounterBuffer = device.createBuffer({
-        size: UPDATED_VOXELS_COUNTER_BUFFER_SIZE,
+    let size = 0;
+    let borderTouchLevel = -1;
+    let explosionLevel = -1;
+    outer: for (let level = 0; level < 256; level++) {
+        const bucket = buckets[level];
+        if (bucket?.length) {
+            for (let bi = 0; bi < bucket.length; bi++) {
+                const idx = bucket[bi];
+                if (visited[idx] === 2) {
+                    continue;
+                }
+                visited[idx] = 2;
+                size++;
+                if (idx === clickIdx) {
+                    clickJoinLevel = level;
+                }
+                const watchSlot = neighborWatch.get(idx);
+                if (watchSlot !== undefined) {
+                    clickNeighborJoinLevels[watchSlot] = level;
+                }
+                const x = idx % wA;
+                const y = Math.floor(idx / wA);
+                if (borderTouchLevel < 0 &&
+                    (x === 0 || x === wA - 1 || y === 0 || y === wB - 1)) {
+                    borderTouchLevel = level;
+                }
+                if (size > maxRegionPx) {
+                    explosionLevel = level;
+                    break outer;
+                }
+                const neighbors = [idx - 1, idx + 1, idx - wA, idx + wA];
+                const canLeft = x > 0;
+                const canRight = x < wA - 1;
+                const canUp = y > 0;
+                const canDown = y < wB - 1;
+                const allowed = [canLeft, canRight, canUp, canDown];
+                for (let n = 0; n < 4; n++) {
+                    if (!allowed[n]) {
+                        continue;
+                    }
+                    const nIdx = neighbors[n];
+                    if (visited[nIdx] !== 0) {
+                        continue;
+                    }
+                    const nCost = cost(nIdx);
+                    if (nCost < 0) {
+                        continue;
+                    }
+                    visited[nIdx] = 1;
+                    pushToBucket(Math.max(level, nCost), nIdx);
+                }
+            }
+            bucket.length = 0;
+        }
+        const lastSize = curve.length ? curve[curve.length - 1].size : 0;
+        if (size > lastSize) {
+            curve.push({ level, size });
+        }
+    }
+    const growthEndLevel = explosionLevel >= 0 ? explosionLevel - 1 : 255;
+    const runs = [];
+    {
+        let runStart = -1;
+        let currentSize = 0;
+        let ci = 0;
+        const closeRun = (endLevel, sizeAtEnd) => {
+            if (runStart >= 0 && endLevel >= runStart) {
+                runs.push({
+                    startLevel: runStart,
+                    endLevel,
+                    width: endLevel - runStart,
+                    size: sizeAtEnd,
+                });
+            }
+            runStart = -1;
+        };
+        for (let level = 0; level <= growthEndLevel; level++) {
+            const sizeBefore = currentSize;
+            let gain = 0;
+            if (ci < curve.length && curve[ci].level === level) {
+                gain = curve[ci].size - currentSize;
+                currentSize = curve[ci].size;
+                ci++;
+            }
+            const quietThreshold = Math.max(QUIET_GAIN_ABS_PX, Math.floor(sizeBefore * QUIET_GAIN_FRACTION));
+            if (currentSize > 0 && gain <= quietThreshold) {
+                if (runStart < 0) {
+                    runStart = level;
+                }
+            }
+            else {
+                closeRun(level - 1, sizeBefore);
+            }
+        }
+        closeRun(growthEndLevel, currentSize);
+    }
+    let best = null;
+    for (const run of runs) {
+        const endLevel = borderTouchLevel >= 0
+            ? Math.min(run.endLevel, borderTouchLevel - 1)
+            : run.endLevel;
+        if (endLevel < run.startLevel) {
+            continue;
+        }
+        const clipped = {
+            ...run,
+            endLevel,
+            width: endLevel - run.startLevel,
+        };
+        if (clipped.size < minRegionPx || clipped.size > maxRegionPx) {
+            continue;
+        }
+        if (!best || clipped.width > best.width) {
+            best = clipped;
+        }
+    }
+    const selectionDebug = () => ({
+        growthCurve: curve.map((p) => [p.level, p.size]),
+        quietRuns: runs.map((run) => [
+            run.startLevel,
+            run.endLevel,
+            run.size,
+        ]),
+        seedByte: v0,
+        backgroundByte,
+        polarity,
+        borderTouchLevel,
+        explosionLevel,
+        clickJoinLevel,
+        minRegionPx,
+        maxRegionPx,
+        pxAreaMm2,
+    });
+    if (!best || best.width < MIN_PLATEAU_WIDTH_BYTES) {
+        const stableButSmall = runs.find((run) => run.size < minRegionPx &&
+            run.width >= MIN_PLATEAU_WIDTH_BYTES &&
+            (borderTouchLevel < 0 || run.startLevel < borderTouchLevel));
+        const failSize = best?.size ?? stableButSmall?.size ?? size;
+        return {
+            viable: false,
+            reason: stableButSmall ? 'too-small' : 'unbounded',
+            range: null,
+            regionSizePx: failSize,
+            regionAreaMm2: failSize * pxAreaMm2,
+            debug: selectionDebug(),
+        };
+    }
+    let toleranceBytes = best.startLevel + Math.floor(best.width / 2);
+    toleranceBytes = Math.min(Math.max(toleranceBytes, MIN_TOLERANCE_BYTES), best.endLevel);
+    const toleranceScale = input.toleranceScale && input.toleranceScale > 0 ? input.toleranceScale : 1;
+    toleranceBytes = Math.max(1, Math.min(255, Math.round(toleranceBytes * toleranceScale)));
+    const chosen = best;
+    if (clickJoinLevel < 0 || clickJoinLevel > toleranceBytes) {
+        return {
+            viable: false,
+            reason: 'off-target',
+            range: null,
+            regionSizePx: chosen.size,
+            regionAreaMm2: chosen.size * pxAreaMm2,
+            debug: selectionDebug(),
+        };
+    }
+    const seedIjk = [...ijkClick];
+    seedIjk[axisA] = a0 + seedX;
+    seedIjk[axisB] = b0 + seedY;
+    const seedScalar = rawValues[seedIdx];
+    const clickedScalar = rawValues[clickY * wA + clickX];
+    const expandContext = {
+        seedByte: v0,
+        polarity,
+        voiMapping: voiMapping ?? null,
+        rawWindow: { min: rawMinInWindow, span: rawSpan },
+        seedIjk,
+        seedScalar: Number.isFinite(seedScalar) ? seedScalar : 0,
+        growthCurve: curve.map((p) => [p.level, p.size]),
+        chosenToleranceBytes: toleranceBytes,
+        growthEndLevel,
+        pxAreaMm2,
+    };
+    const { min: rawLo, max: rawHi } = rawBandForTolerance(expandContext, toleranceBytes);
+    return {
+        viable: true,
+        reason: 'ok',
+        regionSizePx: chosen.size,
+        regionAreaMm2: chosen.size * pxAreaMm2,
+        toleranceBytes,
+        clickNeighborJoinLevels,
+        expandContext,
+        range: {
+            min: rawLo,
+            max: rawHi,
+            ijkStart: seedIjk,
+            diagnostics: {
+                neighborhoodMean: Number.isFinite(seedScalar) ? seedScalar : 0,
+                neighborhoodStdDev: 0,
+                clickedVoxelValue: Number.isFinite(clickedScalar) ? clickedScalar : 0,
+                positiveStdDevMultiplier: toleranceScale,
+                neighborhoodRadius: SEED_SNAP_RADIUS_PX,
+                strategy: 'adaptiveRegion',
+                adaptive: {
+                    toleranceBytes,
+                    regionSizePx: chosen.size,
+                    regionAreaMm2: chosen.size * pxAreaMm2,
+                    backgroundByte,
+                    seedByte: v0,
+                    polarity,
+                    seedSnapped: seedX !== clickX || seedY !== clickY,
+                    windowSize: [wA, wB],
+                    growthCurve: curve.map((p) => [p.level, p.size]),
+                    explosionLevel,
+                    borderTouchLevel,
+                },
+            },
+        },
+    };
+}
+function resolveInPlaneAxes(referencedVolume, viewport) {
+    if (!viewport) {
+        return [0, 1];
+    }
+    try {
+        const camera = viewport.getCamera();
+        const { ijkVecSliceDir } = getVolumeDirectionVectors(referencedVolume.imageData, camera);
+        const abs = ijkVecSliceDir.map(Math.abs);
+        let sliceAxis = 0;
+        if (abs[1] >= abs[0] && abs[1] >= abs[2]) {
+            sliceAxis = 1;
+        }
+        else if (abs[2] >= abs[0] && abs[2] >= abs[1]) {
+            sliceAxis = 2;
+        }
+        const axes = [0, 1, 2].filter((axis) => axis !== sliceAxis);
+        return [axes[0], axes[1]];
+    }
+    catch {
+        return [0, 1];
+    }
+}
+function probeAdaptiveRegion(referencedVolume, worldPosition, options) {
+    const { dimensions, imageData, spacing } = referencedVolume;
+    const voxelManager = referencedVolume.voxelManager;
+    const [width, height] = dimensions;
+    const pixelsPerSlice = width * height;
+    const ijkClick = transformWorldToIndex(imageData, worldPosition).map(Math.round);
+    const voiMapping = options?.voiMapping ??
+        (options?.viewport && options?.referencedVolumeId
+            ? (0,_getViewportVoiMappingForVolume_js__rspack_import_1/* .getViewportVoiMappingForVolume */.K)(options.viewport, options.referencedVolumeId)
+            : null);
+    const toleranceScale = options?.positiveStdDevMultiplier
+        ? options.positiveStdDevMultiplier / (/* inlined export .DEFAULT_POSITIVE_STD_DEV_MULTIPLIER */1.8)
+        : 1;
+    const inPlaneAxes = resolveInPlaneAxes(referencedVolume, options?.viewport);
+    const inPlaneSpacing = [
+        spacing?.[inPlaneAxes[0]] ?? 1,
+        spacing?.[inPlaneAxes[1]] ?? 1,
+    ];
+    const result = probeAdaptiveRegionCore({
+        dimensions,
+        getScalar: (i, j, k) => Number(voxelManager.getAtIndex(k * pixelsPerSlice + j * width + i)),
+        ijkClick,
+        inPlaneAxes,
+        inPlaneSpacing,
+        voiMapping,
+        toleranceScale,
+    });
+    log.debug('adaptiveRegion probe', {
+        ijkClick,
+        viable: result.viable,
+        reason: result.reason,
+        regionSizePx: result.regionSizePx,
+        regionAreaMm2: result.regionAreaMm2,
+        toleranceBytes: result.toleranceBytes,
+        band: result.range
+            ? { min: result.range.min, max: result.range.max }
+            : null,
+    });
+    return result;
+}
+const getAdaptiveRegionIntensityRange = (referencedVolume, worldPosition, options) => {
+    const probe = probeAdaptiveRegion(referencedVolume, worldPosition, options);
+    if (!probe.viable) {
+        log.info('adaptiveRegion: no proper region at click', {
+            reason: probe.reason,
+            regionSizePx: probe.regionSizePx,
+            regionAreaMm2: probe.regionAreaMm2,
+            debug: probe.debug,
+        });
+        return null;
+    }
+    return probe.range;
+};
+
+
+},
+55600(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  ZC: () => (/* binding */ runFloodFillSegmentation)
+});
+
+// UNUSED EXPORTS: default, getDisplayVoiSnapshot, getPositiveIntensityRange, getPositiveIntensityRangeRaw, getPositiveIntensityRangeVoiMapped
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(88479);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/islandRemoval.js
+var segmentation_islandRemoval = __webpack_require__(29827);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/floodFillIslandRemoval.js
+
+
+const { logger } = esm.utilities;
+const { growCutLog: islandRemovalLog } = logger;
+
+class FloodFillIslandRemoval extends segmentation_islandRemoval/* ["default"] */.A {
+    constructor(options) {
+        super(options);
+        this.verboseLogging = false;
+        this.usingPreviewLayer = false;
+        this.internalFilledPoints = [];
+        this.verboseLogging = options?.verboseLogging ?? this.verboseLogging;
+    }
+    initialize(viewport, segmentationVoxels, options) {
+        this.usingPreviewLayer = !!segmentationVoxels.sourceVoxelManager;
+        const initialized = super.initialize(viewport, segmentationVoxels, options);
+        if (initialized && this.verboseLogging) {
+            const { segmentSet } = this;
+            islandRemovalLog.info('islandRemoval: initialize', {
+                segmentIndex: this.segmentIndex,
+                previewSegmentIndex: this.previewSegmentIndex,
+                segmentSetDimensions: {
+                    width: segmentSet.width,
+                    height: segmentSet.height,
+                    depth: segmentSet.depth,
+                },
+                boundsIJKPrime: segmentSet.normalizer.boundsIJKPrime,
+                clickedPoints: this.selectedPoints,
+                segmentVoxelsInPlaneGrid: FloodFillIslandRemoval.countRleValueVolume(segmentSet, segmentation_islandRemoval/* .SegmentationEnum.SEGMENT */.a.SEGMENT),
+            });
+        }
+        return initialized;
+    }
+    static countRleValueVolume(segmentSet, value) {
+        let n = 0;
+        segmentSet.forEach((_baseIndex, rle) => {
+            if (rle.value === value) {
+                n += rle.end - rle.start;
+            }
+        });
+        return n;
+    }
+    floodFillSegmentIsland() {
+        if (this.verboseLogging) {
+            const { selectedPoints, segmentSet } = this;
+            const { fromIJK } = segmentSet.normalizer;
+            for (const clickedPoint of selectedPoints) {
+                const ijkPrime = fromIJK(clickedPoint);
+                const atClick = segmentSet.get(segmentSet.toIndex(ijkPrime));
+                if (atClick !== segmentation_islandRemoval/* .SegmentationEnum.SEGMENT */.a.SEGMENT) {
+                    islandRemovalLog.info('islandRemoval: floodFillSegmentIsland click skipped (not SEGMENT)', {
+                        clickedPointVolumeIJK: clickedPoint,
+                        ijkPrime,
+                        segmentSetAtIndex: atClick,
+                    });
+                }
+            }
+        }
+        const floodedCount = super.floodFillSegmentIsland();
+        if (this.verboseLogging) {
+            islandRemovalLog.info('islandRemoval: floodFillSegmentIsland done', {
+                totalIslandVoxels: floodedCount,
+                islandVoxelsAfterFlood: FloodFillIslandRemoval.countRleValueVolume(this.segmentSet, segmentation_islandRemoval/* .SegmentationEnum.ISLAND */.a.ISLAND),
+            });
+        }
+        return floodedCount;
+    }
+    removeExternalIslands() {
+        const { previewVoxelManager, segmentSet } = this;
+        const { toIJK } = segmentSet.normalizer;
+        const sourceVoxelManager = previewVoxelManager.sourceVoxelManager ?? previewVoxelManager;
+        if (!this.usingPreviewLayer) {
+            islandRemovalLog.warn('islandRemoval: removeExternalIslands has no preview layer; ' +
+                'external island cleanup of accepted voxels is skipped. ' +
+                'Run island removal through a preview layer to clear external islands.');
+            return 0;
+        }
+        let clearedVoxels = 0;
+        const callback = (index, rle) => {
+            const [, jPrime, kPrime] = segmentSet.toIJK(index);
+            if (rle.value !== segmentation_islandRemoval/* .SegmentationEnum.ISLAND */.a.ISLAND) {
+                for (let iPrime = rle.start; iPrime < rle.end; iPrime++) {
+                    const clearPoint = toIJK([iPrime, jPrime, kPrime]);
+                    const sourceVal = sourceVoxelManager.getAtIJKPoint(clearPoint);
+                    if (sourceVal === this.previewSegmentIndex) {
+                        previewVoxelManager.setAtIJKPoint(clearPoint, null);
+                        clearedVoxels += 1;
+                    }
+                }
+            }
+        };
+        segmentSet.forEach(callback, { rowModified: true });
+        if (this.verboseLogging) {
+            islandRemovalLog.info('islandRemoval: removeExternalIslands', {
+                clearedVoxels,
+            });
+        }
+        return clearedVoxels;
+    }
+    removeInternalIslands() {
+        this.internalFilledPoints = [];
+        const modifiedSlices = super.removeInternalIslands();
+        if (this.verboseLogging) {
+            islandRemovalLog.info('islandRemoval: removeInternalIslands', {
+                modifiedSliceCount: modifiedSlices?.length,
+                internalFilledPoints: this.internalFilledPoints.length,
+                maxInternalRemove: this.maxInternalRemove,
+            });
+        }
+        return modifiedSlices;
+    }
+    onInternalPointFilled(point) {
+        this.internalFilledPoints.push(point);
+    }
+    getInternalFilledPoints() {
+        return this.internalFilledPoints;
+    }
+}
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/floodFillSliceLazy.js
+var floodFillSliceLazy = __webpack_require__(10621);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/commitSliceMasksToLabelmap.js
+
+
+const { VoxelManager } = esm.utilities;
+function commitSliceMasksToLabelmapVolume({ labelmapVolume, sliceMasks, width: w, height: h, paintIndex, historyVoxelManager, }) {
+    const floodedPoints = [];
+    let voxelCount = 0;
+    const vm = labelmapVolume.voxelManager;
+    const historyWriter = historyVoxelManager;
+    const [labelmapWidth, labelmapHeight, depth] = labelmapVolume.dimensions;
+    if (labelmapWidth !== w || labelmapHeight !== h) {
+        throw new Error(`commitSliceMasksToLabelmapVolume: labelmap in-plane dimensions ` +
+            `${labelmapWidth}x${labelmapHeight} do not match mask dimensions ${w}x${h}`);
+    }
+    const frameSize = w * h;
+    const expectedLen = frameSize * depth;
+    const zs = Array.from(sliceMasks.keys()).sort((a, b) => a - b);
+    for (let zi = 0; zi < zs.length; zi++) {
+        const z = zs[zi];
+        if (z < 0 || z >= depth) {
+            continue;
+        }
+        const flags = sliceMasks.get(z);
+        if (!flags || flags.length !== frameSize) {
+            continue;
+        }
+        let sliceTouched = false;
+        let minX = Infinity;
+        let minY = Infinity;
+        let maxX = -Infinity;
+        let maxY = -Infinity;
+        const appendRunFlooded = (y, x0, x1) => {
+            for (let xi = x0; xi < x1; xi++) {
+                floodedPoints.push([xi, y, z]);
+            }
+            voxelCount += x1 - x0;
+            sliceTouched = true;
+            minX = Math.min(minX, x0);
+            maxX = Math.max(maxX, x1 - 1);
+            minY = Math.min(minY, y);
+            maxY = Math.max(maxY, y);
+        };
+        const denseScalar = !historyWriter &&
+            vm.scalarData &&
+            vm.scalarData.length >= expectedLen &&
+            typeof vm.scalarData.fill === 'function';
+        if (denseScalar) {
+            const base = z * frameSize;
+            const data = vm.scalarData;
+            for (let y = 0; y < h; y++) {
+                const row = y * w;
+                for (let x = 0; x < w;) {
+                    const li = row + x;
+                    if (!(flags[li] & (/* inlined export .FLOOD_SLICE_FLAG_VISITED */1))) {
+                        x++;
+                        continue;
+                    }
+                    const x0 = x;
+                    while (x < w && flags[row + x] & (/* inlined export .FLOOD_SLICE_FLAG_VISITED */1)) {
+                        x++;
+                    }
+                    data.fill(paintIndex, base + row + x0, base + row + x);
+                    appendRunFlooded(y, x0, x);
+                }
+            }
+        }
+        else {
+            const imageIds = labelmapVolume.imageIds;
+            const image = imageIds?.length && z < imageIds.length
+                ? esm.cache.getImage(imageIds[z])
+                : null;
+            const svm = image?.voxelManager;
+            if (!historyWriter &&
+                svm?.scalarData &&
+                svm.scalarData.length >= frameSize &&
+                typeof svm.scalarData.fill === 'function') {
+                const data = svm.scalarData;
+                for (let y = 0; y < h; y++) {
+                    const row = y * w;
+                    for (let x = 0; x < w;) {
+                        const li = row + x;
+                        if (!(flags[li] & (/* inlined export .FLOOD_SLICE_FLAG_VISITED */1))) {
+                            x++;
+                            continue;
+                        }
+                        const x0 = x;
+                        while (x < w && flags[row + x] & (/* inlined export .FLOOD_SLICE_FLAG_VISITED */1)) {
+                            x++;
+                        }
+                        data.fill(paintIndex, row + x0, row + x);
+                        appendRunFlooded(y, x0, x);
+                    }
+                }
+                svm.modifiedSlices.add(z);
+            }
+            else {
+                const writer = historyWriter ?? vm;
+                for (let y = 0; y < h; y++) {
+                    const row = y * w;
+                    for (let x = 0; x < w; x++) {
+                        if (!(flags[row + x] & (/* inlined export .FLOOD_SLICE_FLAG_VISITED */1))) {
+                            continue;
+                        }
+                        const index = z * frameSize + row + x;
+                        writer.setAtIndex(index, paintIndex);
+                        floodedPoints.push([x, y, z]);
+                        voxelCount++;
+                        sliceTouched = true;
+                        minX = Math.min(minX, x);
+                        maxX = Math.max(maxX, x);
+                        minY = Math.min(minY, y);
+                        maxY = Math.max(maxY, y);
+                    }
+                }
+            }
+        }
+        if (sliceTouched) {
+            vm.modifiedSlices.add(z);
+            if (Number.isFinite(minX) &&
+                Number.isFinite(minY) &&
+                Number.isFinite(maxX) &&
+                Number.isFinite(maxY)) {
+                VoxelManager.addBounds(vm.boundsIJK, [minX, minY, z]);
+                VoxelManager.addBounds(vm.boundsIJK, [maxX, maxY, z]);
+            }
+        }
+    }
+    return { floodedPoints, voxelCount };
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/createEnsureSliceLoadedForVolume.js
+
+function createEnsureSliceLoadedForVolume(volume) {
+    const numSlices = volume.dimensions[2];
+    const imageIds = volume.imageIds;
+    if (!imageIds?.length) {
+        return async () => undefined;
+    }
+    const loadedSlices = new Set();
+    const inFlight = new Map();
+    return async function ensureSliceLoaded(z) {
+        if (!Number.isFinite(z) || z < 0 || z >= numSlices) {
+            return;
+        }
+        if (loadedSlices.has(z)) {
+            return;
+        }
+        const existing = inFlight.get(z);
+        if (existing) {
+            return existing;
+        }
+        const imageId = imageIds[z];
+        if (!imageId) {
+            return;
+        }
+        const promise = esm.imageLoader.loadImage(imageId)
+            .then(() => {
+            loadedSlices.add(z);
+        })
+            .finally(() => {
+            inFlight.delete(z);
+        });
+        inFlight.set(z, promise);
+        return promise;
+    };
+}
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/growCut/constants.js
+var constants = __webpack_require__(29735);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/growCut/neighborhoodStats.js
+function calculateNeighborhoodStatsVM(voxelManager, dimensions, centerIjk, radius, mapValue) {
+    const [width, height, numSlices] = dimensions;
+    let sum = 0;
+    let sumSq = 0;
+    let count = 0;
+    const [cx, cy, cz] = centerIjk.map(Math.round);
+    for (let z = cz - radius; z <= cz + radius; z++) {
+        if (z < 0 || z >= numSlices) {
+            continue;
+        }
+        for (let y = cy - radius; y <= cy + radius; y++) {
+            if (y < 0 || y >= height) {
+                continue;
+            }
+            for (let x = cx - radius; x <= cx + radius; x++) {
+                if (x < 0 || x >= width) {
+                    continue;
+                }
+                const raw = Number(voxelManager.getAtIJK(x, y, z));
+                const value = mapValue ? mapValue(raw) : raw;
+                sum += value;
+                sumSq += value * value;
+                count++;
+            }
+        }
+    }
+    if (count === 0) {
+        if (cx >= 0 &&
+            cx < width &&
+            cy >= 0 &&
+            cy < height &&
+            cz >= 0 &&
+            cz < numSlices) {
+            const raw = Number(voxelManager.getAtIJK(cx, cy, cz));
+            const centerValue = mapValue ? mapValue(raw) : raw;
+            return { mean: centerValue, stdDev: 0, count: 1 };
+        }
+        return { mean: 0, stdDev: 0, count: 0 };
+    }
+    const mean = sum / count;
+    const variance = sumSq / count - mean * mean;
+    const stdDev = Math.sqrt(Math.max(0, variance));
+    return { mean, stdDev, count };
+}
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/growCut/getViewportVoiMappingForVolume.js
+var getViewportVoiMappingForVolume = __webpack_require__(1967);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/growCut/runFloodFillSegmentation.js
+
+
+
+
+
+
+
+
+const { transformWorldToIndex, mapScalarToViewportVoiIntensity, mapMappedBandToRawRange, } = esm.utilities;
+const { growCutLog: log } = esm.utilities.logger;
+const ENABLE_VERBOSE_FLOOD_FILL_LOGS = false;
+const timeStart = (label) => {
+    if (ENABLE_VERBOSE_FLOOD_FILL_LOGS) {
+        console.time(label);
+    }
+};
+const timeEnd = (label) => {
+    if (ENABLE_VERBOSE_FLOOD_FILL_LOGS) {
+        console.timeEnd(label);
+    }
+};
+const FLOOD_FILL_PREP_TIMING_LABEL = 'cornerstone.tools: floodFill: prep';
+const FLOOD_FILL_PREP_REF_META = 'cornerstone.tools: floodFill: prep: ref_volume_meta';
+const FLOOD_FILL_RANGE_TIMING_LABEL = 'cornerstone.tools: floodFill: intensityRange';
+const FLOOD_FILL_RUN_TIMING_LABEL = 'cornerstone.tools: floodFill: fillAndIslandRemoval';
+const FLOOD_FILL_ISLAND_EXTERNAL_TIMING_LABEL = 'cornerstone.tools: floodFill: islandRemoval:external';
+const FLOOD_FILL_ISLAND_INTERNAL_TIMING_LABEL = 'cornerstone.tools: floodFill: islandRemoval:internal';
+function getDisplayVoiSnapshot(viewport, referencedVolumeId) {
+    const getProps = viewport.getProperties;
+    if (typeof getProps !== 'function') {
+        return null;
+    }
+    const props = referencedVolumeId
+        ? getProps.call(viewport, referencedVolumeId)
+        : getProps.call(viewport);
+    const voiRange = props?.voiRange;
+    if (!voiRange ||
+        typeof voiRange.lower !== 'number' ||
+        typeof voiRange.upper !== 'number') {
+        return null;
+    }
+    const { lower, upper } = voiRange;
+    return {
+        lower,
+        upper,
+        windowWidth: upper - lower,
+        windowCenter: (lower + upper) / 2,
+    };
+}
+function getPositiveIntensityRangeRaw(referencedVolume, worldPosition, options) {
+    const { dimensions, imageData: refImageData } = referencedVolume;
+    const [width, height, numSlices] = dimensions;
+    const referenceVolumeVoxelManager = referencedVolume.voxelManager;
+    const neighborhoodRadius = options?.initialNeighborhoodRadius ?? (/* inlined export .DEFAULT_NEIGHBORHOOD_RADIUS */1);
+    const positiveK = options?.positiveStdDevMultiplier ?? (/* inlined export .DEFAULT_POSITIVE_STD_DEV_MULTIPLIER */1.8);
+    const ijkStart = transformWorldToIndex(refImageData, worldPosition).map(Math.round);
+    if (ijkStart[0] < 0 ||
+        ijkStart[0] >= width ||
+        ijkStart[1] < 0 ||
+        ijkStart[1] >= height ||
+        ijkStart[2] < 0 ||
+        ijkStart[2] >= numSlices) {
+        log.warn('intensity range: click outside volume', {
+            ijkStart,
+            dimensions: [width, height, numSlices],
+        });
+        return null;
+    }
+    const initialStats = calculateNeighborhoodStatsVM(referenceVolumeVoxelManager, dimensions, ijkStart, neighborhoodRadius);
+    if (initialStats.count === 0) {
+        const seedScalar = Number(referenceVolumeVoxelManager.getAtIJKPoint(ijkStart));
+        initialStats.mean = seedScalar;
+        initialStats.stdDev = 0;
+    }
+    const min = initialStats.mean - positiveK * initialStats.stdDev;
+    const max = initialStats.mean + positiveK * initialStats.stdDev;
+    const startValue = referenceVolumeVoxelManager.getAtIJKPoint(ijkStart);
+    if (startValue < min || startValue > max) {
+        log.warn('intensity range: clicked voxel intensity is outside the calculated positive range');
+        return null;
+    }
+    return {
+        min,
+        max,
+        ijkStart,
+        diagnostics: {
+            neighborhoodMean: initialStats.mean,
+            neighborhoodStdDev: initialStats.stdDev,
+            clickedVoxelValue: startValue,
+            positiveStdDevMultiplier: positiveK,
+            neighborhoodRadius,
+            strategy: 'meanStdRaw',
+        },
+    };
+}
+function getPositiveIntensityRangeVoiMapped(referencedVolume, worldPosition, voiMapping, options) {
+    const { dimensions, imageData: refImageData } = referencedVolume;
+    const [width, height, numSlices] = dimensions;
+    const referenceVolumeVoxelManager = referencedVolume.voxelManager;
+    const neighborhoodRadius = options?.initialNeighborhoodRadius ?? (/* inlined export .DEFAULT_NEIGHBORHOOD_RADIUS */1);
+    const positiveK = options?.positiveStdDevMultiplier ?? (/* inlined export .DEFAULT_POSITIVE_STD_DEV_MULTIPLIER */1.8);
+    const ijkStart = transformWorldToIndex(refImageData, worldPosition).map(Math.round);
+    if (ijkStart[0] < 0 ||
+        ijkStart[0] >= width ||
+        ijkStart[1] < 0 ||
+        ijkStart[1] >= height ||
+        ijkStart[2] < 0 ||
+        ijkStart[2] >= numSlices) {
+        log.info('intensity range (VOI-mapped): click outside volume', {
+            ijkStart,
+            dimensions: [width, height, numSlices],
+        });
+        return null;
+    }
+    const mapFn = (v) => mapScalarToViewportVoiIntensity(v, voiMapping);
+    const initialStats = calculateNeighborhoodStatsVM(referenceVolumeVoxelManager, dimensions, ijkStart, neighborhoodRadius, mapFn);
+    if (initialStats.count === 0) {
+        const seedScalar = Number(referenceVolumeVoxelManager.getAtIJKPoint(ijkStart));
+        initialStats.mean = mapFn(seedScalar);
+        initialStats.stdDev = 0;
+    }
+    let yMin = initialStats.mean - positiveK * initialStats.stdDev;
+    let yMax = initialStats.mean + positiveK * initialStats.stdDev;
+    yMin = Math.max(0, Math.min(1, yMin));
+    yMax = Math.max(0, Math.min(1, yMax));
+    if (yMin > yMax) {
+        const t = yMin;
+        yMin = yMax;
+        yMax = t;
+    }
+    const { rawMin, rawMax } = mapMappedBandToRawRange(yMin, yMax, voiMapping);
+    const startValue = Number(referenceVolumeVoxelManager.getAtIJKPoint(ijkStart));
+    const bandLo = Math.min(rawMin, rawMax);
+    const bandHi = Math.max(rawMin, rawMax);
+    const min = Math.min(bandLo, startValue);
+    const max = Math.max(bandHi, startValue);
+    return {
+        min,
+        max,
+        ijkStart,
+        diagnostics: {
+            neighborhoodMean: initialStats.mean,
+            neighborhoodStdDev: initialStats.stdDev,
+            clickedVoxelValue: startValue,
+            positiveStdDevMultiplier: positiveK,
+            neighborhoodRadius,
+            strategy: 'meanStdVoiMapped',
+            mappedBand: { min: yMin, max: yMax },
+        },
+    };
+}
+function getPositiveIntensityRange(referencedVolume, worldPosition, options) {
+    if (options?.voiMapping) {
+        return getPositiveIntensityRangeVoiMapped(referencedVolume, worldPosition, options.voiMapping, options);
+    }
+    return getPositiveIntensityRangeRaw(referencedVolume, worldPosition, options);
+}
+function resolveIntensityRange(referencedVolume, worldPosition, viewport, referencedVolumeId, options, rangeContext) {
+    if (options.getIntensityRange) {
+        const fromGetter = options.getIntensityRange(referencedVolume, worldPosition, rangeContext);
+        if (!fromGetter) {
+            log.warn('flood fill intensity range: strategy/custom getIntensityRange returned null (e.g. missing canvasPoint/VOI for canvas-disk, click outside volume, or fixed-% rejection)', { referencedVolumeId, worldPosition });
+        }
+        return fromGetter;
+    }
+    const voiFromViewport = (0,getViewportVoiMappingForVolume/* .getViewportVoiMappingForVolume */.K)(viewport, referencedVolumeId);
+    const merged = {
+        ...rangeContext,
+        voiMapping: voiFromViewport ?? undefined,
+    };
+    let result = getPositiveIntensityRange(referencedVolume, worldPosition, merged);
+    if (!result && merged.voiMapping) {
+        log.info('flood fill intensity range: VOI-mapped mean±σ failed; falling back to raw mean±σ', { referencedVolumeId });
+        result = getPositiveIntensityRange(referencedVolume, worldPosition, {
+            ...merged,
+            voiMapping: undefined,
+        });
+    }
+    if (!result) {
+        log.warn('flood fill intensity range: default mean±σ (VOI + raw fallback) could not resolve a band', { referencedVolumeId, worldPosition });
+    }
+    return result;
+}
+function assertFloodFillLabelmapMatchesRef(referencedVolume, labelmapVolume) {
+    const [rw, rh, rd] = referencedVolume.dimensions;
+    const [lw, lh, ld] = labelmapVolume.dimensions;
+    if (rw !== lw || rh !== lh || rd !== ld) {
+        throw new Error(`runFloodFillSegmentation: labelmap dimensions [${lw},${lh},${ld}] must match referenced volume [${rw},${rh},${rd}]`);
+    }
+}
+function resolveFloodPaintIndices(segmentIndex, explicitPreview) {
+    if (explicitPreview !== undefined) {
+        return {
+            paintIndex: explicitPreview,
+            usePreview: explicitPreview !== segmentIndex,
+        };
+    }
+    if (segmentIndex === 255) {
+        return { paintIndex: 255, usePreview: false };
+    }
+    return { paintIndex: 255, usePreview: true };
+}
+function promotePreviewSegmentToFinal(readVoxelManager, writeVoxelManager, preview, final, points, numPixelsPerSlice, width) {
+    for (let i = 0; i < points.length; i++) {
+        const [x, y, z] = points[i];
+        const index = z * numPixelsPerSlice + y * width + x;
+        if (readVoxelManager.getAtIndex(index) === preview) {
+            writeVoxelManager.setAtIndex(index, final);
+        }
+    }
+}
+async function runFloodFillSegmentation({ referencedVolumeId, worldPosition, viewport, labelmapVolume, options = {}, }) {
+    timeStart(FLOOD_FILL_PREP_TIMING_LABEL);
+    const referencedVolume = esm.cache.getVolume(referencedVolumeId);
+    assertFloodFillLabelmapMatchesRef(referencedVolume, labelmapVolume);
+    const labelmap = labelmapVolume;
+    const segmentIndex = options.segmentIndex ?? 1;
+    const { paintIndex, usePreview } = resolveFloodPaintIndices(segmentIndex, options.floodPreviewSegmentIndex);
+    timeStart(FLOOD_FILL_PREP_REF_META);
+    const [volMin, volMax] = referencedVolume.voxelManager.getRange();
+    const displayVoi = getDisplayVoiSnapshot(viewport, referencedVolumeId);
+    log.info('segmentation path: flood fill (floodfill_full)', {
+        referencedVolumeId,
+        volumeScalarRange: { min: volMin, max: volMax },
+        displayVoi,
+        floodPreview: usePreview ? paintIndex : null,
+        segmentIndex,
+    });
+    timeEnd(FLOOD_FILL_PREP_REF_META);
+    timeEnd(FLOOD_FILL_PREP_TIMING_LABEL);
+    const voiMapping = (0,getViewportVoiMappingForVolume/* .getViewportVoiMappingForVolume */.K)(viewport, referencedVolumeId);
+    const rangeContext = {
+        positiveStdDevMultiplier: options.positiveStdDevMultiplier,
+        initialNeighborhoodRadius: options.initialNeighborhoodRadius,
+        viewport,
+        element: options.element,
+        referencedVolumeId,
+        canvasPoint: options.canvasPoint,
+        canvasDiskRadiusPx: options.intensitySamplingDiskRadiusCanvasPx,
+        voiMapping: voiMapping ?? undefined,
+    };
+    timeStart(FLOOD_FILL_RANGE_TIMING_LABEL);
+    const rangeResult = resolveIntensityRange(referencedVolume, worldPosition, viewport, referencedVolumeId, options, rangeContext);
+    timeEnd(FLOOD_FILL_RANGE_TIMING_LABEL);
+    if (!rangeResult) {
+        log.warn('flood fill: aborted before fill (no intensity range)', {
+            referencedVolumeId,
+            worldPosition,
+        });
+        return null;
+    }
+    const { min: rangeMin, max: rangeMax, ijkStart, diagnostics } = rangeResult;
+    let clampedRangeMin = rangeMin;
+    let clampedRangeMax = rangeMax;
+    const MAX_WL_BAND_FRACTION = 0.2;
+    if (voiMapping && diagnostics?.mappedBand) {
+        const mapped = diagnostics.mappedBand;
+        const mappedLo = Math.max(0, Math.min(1, Math.min(mapped.min, mapped.max)));
+        const mappedHi = Math.max(0, Math.min(1, Math.max(mapped.min, mapped.max)));
+        const mappedWidth = mappedHi - mappedLo;
+        if (mappedWidth > MAX_WL_BAND_FRACTION) {
+            const seedScalarPreClamp = Number(referencedVolume.voxelManager.getAtIJKPoint(ijkStart));
+            const seedMapped = Math.max(0, Math.min(1, mapScalarToViewportVoiIntensity(seedScalarPreClamp, voiMapping)));
+            const half = MAX_WL_BAND_FRACTION / 2;
+            const clippedMappedLo = Math.max(0, seedMapped - half);
+            const clippedMappedHi = Math.min(1, seedMapped + half);
+            const { rawMin: clipRawMin, rawMax: clipRawMax } = mapMappedBandToRawRange(clippedMappedLo, clippedMappedHi, voiMapping);
+            clampedRangeMin = Math.min(clipRawMin, clipRawMax, seedScalarPreClamp);
+            clampedRangeMax = Math.max(clipRawMin, clipRawMax, seedScalarPreClamp);
+            log.info('flood fill: clipped wide WL band around seed', {
+                maxWlBandFraction: MAX_WL_BAND_FRACTION,
+                originalMappedBand: {
+                    min: mappedLo,
+                    max: mappedHi,
+                    width: mappedWidth,
+                },
+                clippedMappedBand: {
+                    min: clippedMappedLo,
+                    max: clippedMappedHi,
+                    width: clippedMappedHi - clippedMappedLo,
+                },
+            });
+        }
+    }
+    log.info('intensity tolerance band', {
+        toleranceMin: clampedRangeMin,
+        toleranceMax: clampedRangeMax,
+        width: clampedRangeMax - clampedRangeMin,
+        ...diagnostics,
+    });
+    if (ENABLE_VERBOSE_FLOOD_FILL_LOGS) {
+        console.info('[cornerstone-tools] flood fill intensity range', {
+            rawMin: clampedRangeMin,
+            rawMax: clampedRangeMax,
+            strategy: diagnostics.strategy,
+            mappedBand: diagnostics.mappedBand,
+            neighborhoodRadius: diagnostics.neighborhoodRadius,
+        });
+    }
+    timeStart(FLOOD_FILL_RUN_TIMING_LABEL);
+    try {
+        const { dimensions } = referencedVolume;
+        const [width, height, numSlices] = dimensions;
+        const refVoxelManager = referencedVolume.voxelManager;
+        const numPixelsPerSlice = width * height;
+        const labelmapReadVm = labelmap.voxelManager;
+        const labelmapWriteVm = (options.historyVoxelManager ??
+            labelmap.voxelManager);
+        let positiveMin = clampedRangeMin;
+        let positiveMax = clampedRangeMax;
+        const seedScalar = Number(refVoxelManager.getAtIJKPoint(ijkStart));
+        if (Number.isFinite(seedScalar)) {
+            if (seedScalar < positiveMin) {
+                log.info('flood fill: expanded tolerance min to include seed voxel', {
+                    seedScalar,
+                    previousMin: positiveMin,
+                });
+                positiveMin = seedScalar;
+            }
+            if (seedScalar > positiveMax) {
+                log.info('flood fill: expanded tolerance max to include seed voxel', {
+                    seedScalar,
+                    previousMax: positiveMax,
+                });
+                positiveMax = seedScalar;
+            }
+        }
+        if (ENABLE_VERBOSE_FLOOD_FILL_LOGS) {
+            console.info('[cornerstone-tools] flood fill seed + effective tolerance', {
+                seedScalar,
+                effectiveMin: positiveMin,
+                effectiveMax: positiveMax,
+            });
+        }
+        const intensityGetter = (x, y, z) => {
+            if (x < 0 ||
+                x >= width ||
+                y < 0 ||
+                y >= height ||
+                z < 0 ||
+                z >= numSlices) {
+                return undefined;
+            }
+            const idx = z * numPixelsPerSlice + y * width + x;
+            return refVoxelManager.getAtIndex(idx);
+        };
+        const inRange = (val) => val >= positiveMin && val <= positiveMax;
+        const ensureSliceLoaded = options.ensureSliceLoaded ??
+            createEnsureSliceLoadedForVolume(referencedVolume);
+        const planar = options.planar === true;
+        if (planar) {
+            log.info('flood fill: planar mode (fixed slice index k)', { ijkStart });
+        }
+        const { sliceMasks, voxelCount: filledVoxelCount, truncated, bbox, } = await (0,floodFillSliceLazy/* .floodFill3dSliceLazy */.x)(intensityGetter, ijkStart, {
+            width,
+            height,
+            depth: numSlices,
+            equals: (val, _startVal) => val !== undefined && typeof val === 'number' && inRange(val),
+            ensureSliceLoaded,
+            yieldEvery: options.yieldEvery ?? 500,
+            planar,
+            maxDeltaK: options.maxDeltaK,
+            maxDeltaIJ: options.maxDeltaIJ,
+            isCancelled: options.isCancelled,
+            maxVoxels: options.maxVoxels,
+            shouldContinue: options.shouldContinueRegion,
+        });
+        const finalShapeRejected = !truncated &&
+            bbox &&
+            options.shouldContinueRegion &&
+            !options.shouldContinueRegion({ voxelCount: filledVoxelCount, bbox });
+        if (truncated || finalShapeRejected) {
+            log.warn('flood fill: rejected — region stopped by budget or shape gate; nothing committed', {
+                maxVoxels: options.maxVoxels,
+                voxelCountAtStop: filledVoxelCount,
+                bbox,
+                ijkStart,
+            });
+            options.onRejected?.({ voxelCount: filledVoxelCount, bbox });
+            return null;
+        }
+        if (filledVoxelCount === 0) {
+            log.info('flood fill: zero voxels (range may be too tight or seed isolated)', {
+                ijkStart,
+                toleranceMin: positiveMin,
+                toleranceMax: positiveMax,
+            });
+            return labelmap;
+        }
+        if (options.isCancelled?.() === true) {
+            log.info('flood fill: cancellation requested; nothing committed', {
+                ijkStart,
+                voxelCountAtCancel: filledVoxelCount,
+            });
+            return null;
+        }
+        const { floodedPoints, voxelCount: committedVoxels } = commitSliceMasksToLabelmapVolume({
+            labelmapVolume: labelmap,
+            sliceMasks,
+            width,
+            height,
+            paintIndex,
+            historyVoxelManager: options.historyVoxelManager,
+        });
+        if (committedVoxels === 0 || floodedPoints.length === 0) {
+            log.warn('flood fill: commit produced no labelmap voxels', {
+                filledVoxelCount,
+                committedVoxels,
+                ijkStart,
+            });
+            return labelmap;
+        }
+        let committedPoints = floodedPoints;
+        log.info('flood fill: complete', {
+            voxelCount: floodedPoints.length,
+            ijkStart,
+            paintIndex,
+            usePreview,
+        });
+        const applyExternal = options.applyExternalIslandRemoval !== false;
+        const applyInternal = options.applyInternalIslandRemoval !== false && applyExternal;
+        if (!applyExternal && !applyInternal) {
+            if (usePreview) {
+                promotePreviewSegmentToFinal(labelmapReadVm, labelmapWriteVm, paintIndex, segmentIndex, floodedPoints, numPixelsPerSlice, width);
+            }
+            options.onCommitted?.(committedPoints);
+            return labelmap;
+        }
+        const islandVerbose = options.islandRemovalVerboseLogging === true;
+        const islandRemoval = new FloodFillIslandRemoval({
+            maxInternalRemove: options.maxInternalRemove ?? 128,
+            fillInternalEdge: false,
+            verboseLogging: islandVerbose,
+        });
+        const ijkPoints = [ijkStart];
+        const initialized = islandRemoval.initialize(viewport, options.historyVoxelManager ?? labelmap.voxelManager, {
+            points: ijkPoints,
+            segmentIndex,
+            previewSegmentIndex: usePreview ? paintIndex : segmentIndex,
+        });
+        if (!initialized) {
+            log.warn('island removal: initialize failed', { segmentIndex, ijkStart });
+            if (usePreview) {
+                promotePreviewSegmentToFinal(labelmapReadVm, labelmapWriteVm, paintIndex, segmentIndex, floodedPoints, numPixelsPerSlice, width);
+            }
+            options.onCommitted?.(committedPoints);
+            return labelmap;
+        }
+        let islandFloodVoxels = 0;
+        let externalClearedVoxels = 0;
+        let internalSliceCount;
+        if (applyExternal) {
+            timeStart(FLOOD_FILL_ISLAND_EXTERNAL_TIMING_LABEL);
+            islandFloodVoxels = islandRemoval.floodFillSegmentIsland();
+            externalClearedVoxels = islandRemoval.removeExternalIslands();
+            timeEnd(FLOOD_FILL_ISLAND_EXTERNAL_TIMING_LABEL);
+            if (applyInternal) {
+                timeStart(FLOOD_FILL_ISLAND_INTERNAL_TIMING_LABEL);
+                const modifiedSlices = islandRemoval.removeInternalIslands();
+                internalSliceCount = modifiedSlices?.length;
+                timeEnd(FLOOD_FILL_ISLAND_INTERNAL_TIMING_LABEL);
+            }
+        }
+        log.info('island removal: complete', {
+            segmentIndex,
+            applyExternalIslandRemoval: applyExternal,
+            applyInternalIslandRemoval: applyInternal,
+            floodedPointsBeforeIsland: floodedPoints.length,
+            islandFloodVoxelsFromSegmentSet: islandFloodVoxels,
+            externalIslandClearVoxels: externalClearedVoxels,
+            internalRemovalModifiedSlices: internalSliceCount,
+            islandRemovalVerboseLogging: islandVerbose,
+        });
+        const internalFilledPoints = applyInternal
+            ? islandRemoval.getInternalFilledPoints()
+            : [];
+        committedPoints =
+            internalFilledPoints.length > 0
+                ? floodedPoints.concat(internalFilledPoints)
+                : floodedPoints;
+        if (usePreview) {
+            promotePreviewSegmentToFinal(labelmapReadVm, labelmapWriteVm, paintIndex, segmentIndex, committedPoints, numPixelsPerSlice, width);
+        }
+        options.onCommitted?.(committedPoints);
+        if (ENABLE_VERBOSE_FLOOD_FILL_LOGS && floodedPoints.length > 0) {
+            let finalSegmentCount = 0;
+            let previewCount = 0;
+            let zeroCount = 0;
+            let otherCount = 0;
+            for (let i = 0; i < floodedPoints.length; i++) {
+                const [x, y, z] = floodedPoints[i];
+                const index = z * numPixelsPerSlice + y * width + x;
+                const value = Number(labelmap.voxelManager.getAtIndex(index) ?? 0);
+                if (value === segmentIndex) {
+                    finalSegmentCount += 1;
+                }
+                else if (value === paintIndex) {
+                    previewCount += 1;
+                }
+                else if (value === 0) {
+                    zeroCount += 1;
+                }
+                else {
+                    otherCount += 1;
+                }
+            }
+            console.info('[cornerstone-tools] flood fill final voxel check', {
+                floodedPoints: floodedPoints.length,
+                segmentIndex,
+                paintIndex,
+                usePreview,
+                finalSegmentCount,
+                previewCount,
+                zeroCount,
+                otherCount,
+            });
+        }
+        return labelmap;
+    }
+    finally {
+        timeEnd(FLOOD_FILL_RUN_TIMING_LABEL);
+    }
+}
+
+
+
+},
+14386(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  e: () => (runGrowCut)
+});
+/* import */ var _cornerstonejs_core__rspack_import_0 = __webpack_require__(88479);
+/* import */ var _growCutShader_js__rspack_import_1 = __webpack_require__(20326);
+
+
+const GB = 1024 * 1024 * 1024;
+const WEBGPU_MEMORY_LIMIT = 1.99 * GB;
+const DEFAULT_GROWCUT_OPTIONS = {
+    windowSize: 3,
+    maxProcessingTime: 30000,
+    inspection: {
+        numCyclesInterval: 5,
+        numCyclesBelowThreshold: 3,
+        threshold: 1e-4,
+    },
+};
+async function runGrowCut(referenceVolumeId, labelmapVolumeId, options = DEFAULT_GROWCUT_OPTIONS) {
+    const workGroupSize = [8, 8, 4];
+    const { windowSize, maxProcessingTime } = Object.assign({}, DEFAULT_GROWCUT_OPTIONS, options);
+    const inspection = Object.assign({}, DEFAULT_GROWCUT_OPTIONS.inspection, options.inspection);
+    const volume = _cornerstonejs_core__rspack_import_0.cache.getVolume(referenceVolumeId);
+    const labelmap = _cornerstonejs_core__rspack_import_0.cache.getVolume(labelmapVolumeId);
+    const [columns, rows, numSlices] = volume.dimensions;
+    if (labelmap.dimensions[0] !== columns ||
+        labelmap.dimensions[1] !== rows ||
+        labelmap.dimensions[2] !== numSlices) {
+        throw new Error('Volume and labelmap must have the same size');
+    }
+    let numIterations = Math.floor(Math.sqrt(rows ** 2 + columns ** 2 + numSlices ** 2) / 2);
+    numIterations = Math.min(numIterations, 500);
+    const labelmapData = labelmap.voxelManager.getCompleteScalarDataArray();
+    let volumePixelData = volume.voxelManager.getCompleteScalarDataArray();
+    if (!(volumePixelData instanceof Float32Array)) {
+        volumePixelData = new Float32Array(volumePixelData);
+    }
+    const requiredLimits = {
+        maxStorageBufferBindingSize: WEBGPU_MEMORY_LIMIT,
+        maxBufferSize: WEBGPU_MEMORY_LIMIT,
+    };
+    const adapter = await navigator.gpu?.requestAdapter();
+    const device = await adapter.requestDevice({ requiredLimits });
+    const BUFFER_SIZE = volumePixelData.byteLength;
+    const UPDATED_VOXELS_COUNTER_BUFFER_SIZE = numIterations * Uint32Array.BYTES_PER_ELEMENT;
+    const BOUNDS_BUFFER_SIZE = 6 * Int32Array.BYTES_PER_ELEMENT;
+    const shaderModule = device.createShaderModule({
+        code: _growCutShader_js__rspack_import_1/* ["default"] */.A,
+    });
+    const numIterationIndex = 3;
+    const paramsArrayValues = new Uint32Array([
+        columns,
+        rows,
+        numSlices,
+        0,
+    ]);
+    const gpuParamsBuffer = device.createBuffer({
+        size: paramsArrayValues.byteLength,
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+    });
+    const gpuVolumePixelDataBuffer = device.createBuffer({
+        size: BUFFER_SIZE,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(gpuVolumePixelDataBuffer, 0, volumePixelData);
+    const gpuLabelmapBuffers = [0, 1].map(() => device.createBuffer({
+        size: BUFFER_SIZE,
+        usage: GPUBufferUsage.STORAGE |
+            GPUBufferUsage.COPY_SRC |
+            GPUBufferUsage.COPY_DST,
+    }));
+    device.queue.writeBuffer(gpuLabelmapBuffers[0], 0, new Uint32Array(labelmapData));
+    const gpuStrengthBuffers = [0, 1].map(() => {
+        const strengthBuffer = device.createBuffer({
+            size: BUFFER_SIZE,
+            usage: GPUBufferUsage.STORAGE |
+                GPUBufferUsage.COPY_SRC |
+                GPUBufferUsage.COPY_DST,
+        });
+        return strengthBuffer;
+    });
+    const gpuCounterBuffer = device.createBuffer({
+        size: UPDATED_VOXELS_COUNTER_BUFFER_SIZE,
         usage: GPUBufferUsage.STORAGE |
             GPUBufferUsage.COPY_SRC |
             GPUBufferUsage.COPY_DST,
@@ -7259,6 +9101,200 @@ function invalidateBrushCursor(toolGroupId) {
 }
 
 
+},
+29827(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  A: () => (IslandRemoval),
+  a: () => (SegmentationEnum)
+});
+/* import */ var _cornerstonejs_core__rspack_import_0 = __webpack_require__(88479);
+/* import */ var _normalizeViewportPlane_js__rspack_import_1 = __webpack_require__(95972);
+
+
+const { RLEVoxelMap, VoxelManager } = _cornerstonejs_core__rspack_import_0.utilities;
+const MAX_IMAGE_SIZE = 65535;
+var SegmentationEnum;
+(function (SegmentationEnum) {
+    SegmentationEnum[SegmentationEnum["SEGMENT"] = -1] = "SEGMENT";
+    SegmentationEnum[SegmentationEnum["ISLAND"] = -2] = "ISLAND";
+    SegmentationEnum[SegmentationEnum["INTERIOR"] = -3] = "INTERIOR";
+    SegmentationEnum[SegmentationEnum["EXTERIOR"] = -4] = "EXTERIOR";
+    SegmentationEnum[SegmentationEnum["INTERIOR_SMALL"] = -5] = "INTERIOR_SMALL";
+    SegmentationEnum[SegmentationEnum["INTERIOR_TEST"] = -6] = "INTERIOR_TEST";
+})(SegmentationEnum || (SegmentationEnum = {}));
+class IslandRemoval {
+    constructor(options) {
+        this.fillInternalEdge = false;
+        this.maxInternalRemove = 128;
+        this.maxInternalRemove =
+            options?.maxInternalRemove ?? this.maxInternalRemove;
+        this.fillInternalEdge = options?.fillInternalEdge ?? this.fillInternalEdge;
+    }
+    initialize(viewport, segmentationVoxels, options) {
+        const hasSource = !!segmentationVoxels.sourceVoxelManager;
+        const segmentationVoxelManager = hasSource
+            ? segmentationVoxels.sourceVoxelManager
+            : segmentationVoxels;
+        const previewVoxelManager = hasSource
+            ? segmentationVoxels
+            : VoxelManager.createRLEHistoryVoxelManager(segmentationVoxelManager);
+        const { segmentIndex = 1, previewSegmentIndex = 1 } = options;
+        const clickedPoints = options.points || segmentationVoxelManager.getPoints();
+        if (!clickedPoints?.length) {
+            return;
+        }
+        const boundsIJK = segmentationVoxelManager
+            .getBoundsIJK()
+            .map((bound, i) => [
+            Math.min(bound[0], ...clickedPoints.map((point) => point[i])),
+            Math.max(bound[1], ...clickedPoints.map((point) => point[i])),
+        ]);
+        if (boundsIJK.find((it) => it[0] < 0 || it[1] > MAX_IMAGE_SIZE)) {
+            return;
+        }
+        const { toIJK, fromIJK, boundsIJKPrime, error } = (0,_normalizeViewportPlane_js__rspack_import_1/* ["default"] */.A)(viewport, boundsIJK);
+        if (error) {
+            console.warn('Not performing island removal for planes not orthogonal to acquisition plane', error);
+            return;
+        }
+        const [width, height, depth] = fromIJK(segmentationVoxelManager.dimensions);
+        const segmentSet = new RLEVoxelMap(width, height, depth);
+        const getter = (i, j, k) => {
+            const index = segmentationVoxelManager.toIndex(toIJK([i, j, k]));
+            const oldVal = segmentationVoxelManager.getAtIndex(index);
+            if (oldVal === previewSegmentIndex || oldVal === segmentIndex) {
+                return SegmentationEnum.SEGMENT;
+            }
+        };
+        segmentSet.fillFrom(getter, boundsIJKPrime);
+        segmentSet.normalizer = { toIJK, fromIJK, boundsIJKPrime };
+        this.segmentSet = segmentSet;
+        this.previewVoxelManager = previewVoxelManager;
+        this.segmentIndex = segmentIndex;
+        this.previewSegmentIndex = previewSegmentIndex ?? segmentIndex;
+        this.selectedPoints = clickedPoints;
+        return true;
+    }
+    floodFillSegmentIsland() {
+        const { selectedPoints: clickedPoints, segmentSet } = this;
+        let floodedCount = 0;
+        const { fromIJK } = segmentSet.normalizer;
+        clickedPoints.forEach((clickedPoint) => {
+            const ijkPrime = fromIJK(clickedPoint);
+            const index = segmentSet.toIndex(ijkPrime);
+            const [iPrime, jPrime, kPrime] = ijkPrime;
+            if (segmentSet.get(index) === SegmentationEnum.SEGMENT) {
+                floodedCount += segmentSet.floodFill(iPrime, jPrime, kPrime, SegmentationEnum.ISLAND);
+            }
+        });
+        return floodedCount;
+    }
+    removeExternalIslands() {
+        const { previewVoxelManager, segmentSet } = this;
+        const { toIJK } = segmentSet.normalizer;
+        const callback = (index, rle) => {
+            const [, jPrime, kPrime] = segmentSet.toIJK(index);
+            if (rle.value !== SegmentationEnum.ISLAND) {
+                for (let iPrime = rle.start; iPrime < rle.end; iPrime++) {
+                    const clearPoint = toIJK([iPrime, jPrime, kPrime]);
+                    const v = previewVoxelManager.getAtIJKPoint(clearPoint);
+                    previewVoxelManager.setAtIJKPoint(clearPoint, v === undefined ? 0 : null);
+                }
+            }
+        };
+        segmentSet.forEach(callback, { rowModified: true });
+    }
+    removeInternalIslands() {
+        const { segmentSet, previewVoxelManager, previewSegmentIndex } = this;
+        const { height, normalizer, width } = segmentSet;
+        const { toIJK } = normalizer;
+        segmentSet.forEachRow((baseIndex, row) => {
+            let lastRle;
+            for (const rle of [...row]) {
+                if (rle.value !== SegmentationEnum.ISLAND) {
+                    continue;
+                }
+                if (!lastRle) {
+                    if (this.fillInternalEdge && rle.start > 0) {
+                        for (let iPrime = 0; iPrime < rle.start; iPrime++) {
+                            segmentSet.set(baseIndex + iPrime, SegmentationEnum.INTERIOR);
+                        }
+                    }
+                    lastRle = rle;
+                    continue;
+                }
+                for (let iPrime = lastRle.end; iPrime < rle.start; iPrime++) {
+                    segmentSet.set(baseIndex + iPrime, SegmentationEnum.INTERIOR);
+                }
+                lastRle = rle;
+            }
+            if (this.fillInternalEdge && lastRle?.end < width) {
+                for (let iPrime = lastRle.end; iPrime < width; iPrime++) {
+                    segmentSet.set(baseIndex + iPrime, SegmentationEnum.INTERIOR);
+                }
+            }
+        });
+        segmentSet.forEach((baseIndex, rle) => {
+            if (rle.value !== SegmentationEnum.INTERIOR) {
+                return;
+            }
+            const [, jPrime, kPrime] = segmentSet.toIJK(baseIndex);
+            const rowPrev = jPrime > 0 ? segmentSet.getRun(jPrime - 1, kPrime) : null;
+            const rowNext = jPrime + 1 < height ? segmentSet.getRun(jPrime + 1, kPrime) : null;
+            const isLast = jPrime === height - 1;
+            const isFirst = jPrime === 0;
+            const prevCovers = IslandRemoval.covers(rle, rowPrev) ||
+                (isFirst && this.fillInternalEdge);
+            const nextCovers = IslandRemoval.covers(rle, rowNext) || (isLast && this.fillInternalEdge);
+            if (rle.end - rle.start > 2 && (!prevCovers || !nextCovers)) {
+                segmentSet.floodFill(rle.start, jPrime, kPrime, SegmentationEnum.EXTERIOR, { singlePlane: true });
+            }
+        });
+        segmentSet.forEach((baseIndex, rle) => {
+            if (rle.value !== SegmentationEnum.INTERIOR) {
+                return;
+            }
+            const [, jPrime, kPrime] = segmentSet.toIJK(baseIndex);
+            const size = segmentSet.floodFill(rle.start, jPrime, kPrime, SegmentationEnum.INTERIOR_TEST);
+            const isBig = size > this.maxInternalRemove;
+            const newType = isBig
+                ? SegmentationEnum.EXTERIOR
+                : SegmentationEnum.INTERIOR_SMALL;
+            segmentSet.floodFill(rle.start, jPrime, kPrime, newType);
+        });
+        segmentSet.forEach((baseIndex, rle) => {
+            if (rle.value !== SegmentationEnum.INTERIOR_SMALL) {
+                return;
+            }
+            for (let iPrime = rle.start; iPrime < rle.end; iPrime++) {
+                const clearPoint = toIJK(segmentSet.toIJK(baseIndex + iPrime));
+                previewVoxelManager.setAtIJKPoint(clearPoint, previewSegmentIndex);
+                this.onInternalPointFilled(clearPoint);
+            }
+        });
+        return previewVoxelManager.getArrayOfModifiedSlices();
+    }
+    onInternalPointFilled(_point) {
+    }
+    static covers(rle, row) {
+        if (!row) {
+            return false;
+        }
+        let { start } = rle;
+        const { end } = rle;
+        for (const rowRle of row) {
+            if (start >= rowRle.start && start < rowRle.end) {
+                start = rowRle.end;
+                if (start >= end) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
+
+
 },
 70736(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {