diff --git a/src/components/FillHolesParameterControls.vue b/src/components/FillHolesParameterControls.vue
new file mode 100644
index 000000000..94b6c2c71
--- /dev/null
+++ b/src/components/FillHolesParameterControls.vue
@@ -0,0 +1,96 @@
+<template>
+  <div class="d-flex align-center">
+    <mini-expansion-panel>
+      <template #title
+        >Fill enclosed holes in the segmentation on the axis of the selected
+        view.</template
+      >
+      <ul>
+        <li>Finds background regions fully enclosed by segments on a slice.</li>
+        <li>
+          Fills holes on the current slice by default, or every slice of the
+          active view's axis.
+        </li>
+        <li>
+          All-segments mode fills each hole with the surrounding segment's
+          label; selected-segment mode fills only the active segment's holes.
+        </li>
+      </ul>
+    </mini-expansion-panel>
+  </div>
+
+  <div
+    v-for="scope in scopes"
+    :key="scope.label"
+    class="w-100 px-4 mb-4 d-flex flex-column align-center"
+  >
+    <div class="text-caption mb-1">{{ scope.label }}</div>
+    <v-btn-toggle
+      :model-value="scope.value"
+      density="compact"
+      variant="outlined"
+      divided
+      mandatory
+      :disabled="isDisabled"
+      @update:model-value="scope.onChange"
+    >
+      <v-btn
+        v-for="option in scope.options"
+        :key="option.value"
+        :value="option.value"
+        size="small"
+      >
+        {{ option.label }}
+      </v-btn>
+    </v-btn-toggle>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue';
+import {
+  useFillHolesStore,
+  FillHolesSliceScope,
+  FillHolesSegmentScope,
+} from '@/src/store/tools/fillHoles';
+import { usePaintProcessStore } from '@/src/store/tools/paintProcess';
+import MiniExpansionPanel from './MiniExpansionPanel.vue';
+
+const fillHolesStore = useFillHolesStore();
+const processStore = usePaintProcessStore();
+
+const isDisabled = computed(() => processStore.processStep === 'previewing');
+
+type ScopeControl = {
+  label: string;
+  value: string;
+  onChange: (value: string) => void;
+  options: { value: string; label: string }[];
+};
+
+const scopes = computed<ScopeControl[]>(() => [
+  {
+    label: 'Slices',
+    value: fillHolesStore.sliceScope,
+    onChange: (value) =>
+      fillHolesStore.setSliceScope(value as FillHolesSliceScope),
+    options: [
+      { value: FillHolesSliceScope.CurrentSlice, label: 'Current slice' },
+      { value: FillHolesSliceScope.WholeVolume, label: 'All slices' },
+    ],
+  },
+  {
+    label: 'Segments',
+    value: fillHolesStore.segmentScope,
+    onChange: (value) =>
+      fillHolesStore.setSegmentScope(value as FillHolesSegmentScope),
+    options: [
+      { value: FillHolesSegmentScope.AllSegments, label: 'All segments' },
+      {
+        value: FillHolesSegmentScope.SelectedSegment,
+        label: 'Selected segment',
+      },
+    ],
+  },
+]);
+</script>
diff --git a/src/components/ProcessControls.vue b/src/components/ProcessControls.vue
index a1b40b660..7a587a923 100644
--- a/src/components/ProcessControls.vue
+++ b/src/components/ProcessControls.vue
@@ -2,37 +2,28 @@
   <div class="d-flex flex-column align-center w-100">
     <ProcessTypeSelector />
 
-    <template v-if="activeProcessType === ProcessType.FillBetween">
-      <FillBetweenParameterControls />
-      <ProcessWorkflow :algorithm="fillBetweenAlgorithm" />
-    </template>
-
-    <template v-if="activeProcessType === ProcessType.GaussianSmooth">
-      <GaussianSmoothParameterControls />
-      <ProcessWorkflow :algorithm="gaussianSmoothAlgorithm" />
+    <template v-if="activeDefinition">
+      <component :is="activeDefinition.controls" />
+      <ProcessWorkflow
+        :algorithm="activeDefinition.getAlgorithm()"
+        :requires-active-segment="
+          activeDefinition.requiresActiveSegment?.() ?? true
+        "
+      />
     </template>
   </div>
 </template>
 
 <script setup lang="ts">
 import { computed } from 'vue';
-import {
-  ProcessType,
-  usePaintProcessStore,
-} from '@/src/store/tools/paintProcess';
+import { usePaintProcessStore } from '@/src/store/tools/paintProcess';
 import ProcessTypeSelector from './ProcessTypeSelector.vue';
 import ProcessWorkflow from './ProcessWorkflow.vue';
-import FillBetweenParameterControls from './FillBetweenParameterControls.vue';
-import GaussianSmoothParameterControls from './GaussianSmoothParameterControls.vue';
-import { useFillBetweenStore } from '../store/tools/fillBetween';
-import { useGaussianSmoothStore } from '../store/tools/gaussianSmooth';
+import { PROCESS_DEFINITIONS } from './processes';
 
 const processStore = usePaintProcessStore();
-const fillBetweenStore = useFillBetweenStore();
-const gaussianSmoothStore = useGaussianSmoothStore();
-
-const activeProcessType = computed(() => processStore.activeProcessType);
 
-const fillBetweenAlgorithm = fillBetweenStore.computeAlgorithm;
-const gaussianSmoothAlgorithm = gaussianSmoothStore.computeAlgorithm;
+const activeDefinition = computed(() =>
+  PROCESS_DEFINITIONS.find((def) => def.type === processStore.activeProcessType)
+);
 </script>
diff --git a/src/components/ProcessTypeSelector.vue b/src/components/ProcessTypeSelector.vue
index 49cd5ecba..8c7837bd4 100644
--- a/src/components/ProcessTypeSelector.vue
+++ b/src/components/ProcessTypeSelector.vue
@@ -4,10 +4,12 @@
       v-model="activeProcessType"
       mandatory
       selected-class="selected"
-      class="d-flex align-center justify-center"
+      class="d-flex align-center justify-center flex-wrap"
     >
       <v-item
-        :value="ProcessType.FillBetween"
+        v-for="definition in PROCESS_DEFINITIONS"
+        :key="definition.type"
+        :value="definition.type"
         v-slot="{ selectedClass, toggle }"
       >
         <v-btn
@@ -17,23 +19,8 @@
           :class="['process-button', 'mx-2', selectedClass]"
           @click.stop="toggle"
         >
-          <v-icon>mdi-layers-triple</v-icon>
-          <span class="text-caption">Fill Between</span>
-        </v-btn>
-      </v-item>
-      <v-item
-        :value="ProcessType.GaussianSmooth"
-        v-slot="{ selectedClass, toggle }"
-      >
-        <v-btn
-          variant="tonal"
-          rounded="8"
-          stacked
-          :class="['process-button', 'mx-2', selectedClass]"
-          @click.stop="toggle"
-        >
-          <v-icon>mdi-blur</v-icon>
-          <span class="text-caption">Smooth</span>
+          <v-icon>{{ definition.icon }}</v-icon>
+          <span class="text-caption">{{ definition.label }}</span>
         </v-btn>
       </v-item>
     </v-item-group>
@@ -42,10 +29,8 @@
 
 <script setup lang="ts">
 import { computed } from 'vue';
-import {
-  ProcessType,
-  usePaintProcessStore,
-} from '@/src/store/tools/paintProcess';
+import { usePaintProcessStore } from '@/src/store/tools/paintProcess';
+import { PROCESS_DEFINITIONS } from './processes';
 
 const processStore = usePaintProcessStore();
 
diff --git a/src/components/ProcessWorkflow.vue b/src/components/ProcessWorkflow.vue
index 25c802ee7..69bf55d87 100644
--- a/src/components/ProcessWorkflow.vue
+++ b/src/components/ProcessWorkflow.vue
@@ -16,17 +16,16 @@
       <v-btn-toggle
         v-if="processStep === 'previewing'"
         :model-value="showingOriginal ? 0 : 1"
-        @update:model-value="handleToggleChange"
         mandatory
         variant="outlined"
         divided
         density="compact"
       >
-        <v-btn :value="0" size="small">
+        <v-btn :value="0" size="small" @click="processStore.togglePreview()">
           <v-icon start size="small">mdi-eye-outline</v-icon>
           Original
         </v-btn>
-        <v-btn :value="1" size="small">
+        <v-btn :value="1" size="small" @click="processStore.togglePreview()">
           <v-icon start size="small">mdi-eye-settings</v-icon>
           Processed
         </v-btn>
@@ -60,9 +59,12 @@ import {
 
 interface Props {
   algorithm: ProcessAlgorithm;
+  requiresActiveSegment?: boolean;
 }
 
-const props = defineProps<Props>();
+const props = withDefaults(defineProps<Props>(), {
+  requiresActiveSegment: true,
+});
 
 const processStore = usePaintProcessStore();
 const paintStore = usePaintToolStore();
@@ -73,14 +75,9 @@ const showingOriginal = computed(() => processStore.showingOriginal);
 function startCompute() {
   const id = paintStore.activeSegmentGroupID;
   if (!id) return;
-  processStore.startProcess(id, props.algorithm);
-}
-
-function handleToggleChange(value: number) {
-  const shouldShowOriginal = value === 0;
-  if (shouldShowOriginal !== showingOriginal.value) {
-    processStore.togglePreview();
-  }
+  processStore.startProcess(id, props.algorithm, {
+    requiresActiveSegment: props.requiresActiveSegment,
+  });
 }
 
 function handleCancel() {
diff --git a/src/components/processes.ts b/src/components/processes.ts
new file mode 100644
index 000000000..d16aff121
--- /dev/null
+++ b/src/components/processes.ts
@@ -0,0 +1,56 @@
+import type { Component } from 'vue';
+import {
+  ProcessType,
+  type ProcessAlgorithm,
+} from '@/src/store/tools/paintProcess';
+import {
+  useFillHolesStore,
+  FillHolesSegmentScope,
+} from '@/src/store/tools/fillHoles';
+import { useFillBetweenStore } from '@/src/store/tools/fillBetween';
+import { useGaussianSmoothStore } from '@/src/store/tools/gaussianSmooth';
+import FillHolesParameterControls from './FillHolesParameterControls.vue';
+import FillBetweenParameterControls from './FillBetweenParameterControls.vue';
+import GaussianSmoothParameterControls from './GaussianSmoothParameterControls.vue';
+
+export type ProcessDefinition = {
+  type: ProcessType;
+  label: string;
+  icon: string;
+  controls: Component;
+  // Resolved lazily so each call reads the live store (Pinia singletons).
+  getAlgorithm: () => ProcessAlgorithm;
+  // Whether the process needs the active segment. Defaults to true; processes
+  // that act on every segment opt out. Resolved lazily for reactivity.
+  requiresActiveSegment?: () => boolean;
+};
+
+// Single source of truth for the paint processes. Adding a process is one
+// entry here instead of synchronized edits across the selector, the controls,
+// and the type enum.
+export const PROCESS_DEFINITIONS: ProcessDefinition[] = [
+  {
+    type: ProcessType.FillHoles,
+    label: 'Fill Holes',
+    icon: 'mdi-format-color-fill',
+    controls: FillHolesParameterControls,
+    getAlgorithm: () => useFillHolesStore().computeAlgorithm,
+    requiresActiveSegment: () =>
+      useFillHolesStore().segmentScope ===
+      FillHolesSegmentScope.SelectedSegment,
+  },
+  {
+    type: ProcessType.FillBetween,
+    label: 'Fill Between',
+    icon: 'mdi-layers-triple',
+    controls: FillBetweenParameterControls,
+    getAlgorithm: () => useFillBetweenStore().computeAlgorithm,
+  },
+  {
+    type: ProcessType.GaussianSmooth,
+    label: 'Smooth',
+    icon: 'mdi-blur',
+    controls: GaussianSmoothParameterControls,
+    getAlgorithm: () => useGaussianSmoothStore().computeAlgorithm,
+  },
+];
diff --git a/src/core/tools/paint/__tests__/fillHoles.spec.ts b/src/core/tools/paint/__tests__/fillHoles.spec.ts
new file mode 100644
index 000000000..1f77280bd
--- /dev/null
+++ b/src/core/tools/paint/__tests__/fillHoles.spec.ts
@@ -0,0 +1,209 @@
+import { describe, it, expect } from 'vitest';
+import { fillHoles } from '../fillHoles';
+
+// Build a flat single-slice label map (axis 2, k=0) from a 2D grid.
+// grid[j][i] maps to flat index i + j*dimI.
+function flatFromGrid(grid: number[][]) {
+  const dimI = grid[0].length;
+  const dimJ = grid.length;
+  const data = new Uint8Array(grid.flat());
+  return { data, dimensions: [dimI, dimJ, 1] as [number, number, number] };
+}
+
+describe('fillHoles', () => {
+  it('fills a background hole enclosed by a single segment', () => {
+    const { data, dimensions } = flatFromGrid([
+      [1, 1, 1],
+      [1, 0, 1],
+      [1, 1, 1],
+    ]);
+    const out = fillHoles({ data, dimensions, axis: 2, sliceIndex: 0 });
+    expect(Array.from(out)).toEqual(
+      Array.from(
+        flatFromGrid([
+          [1, 1, 1],
+          [1, 1, 1],
+          [1, 1, 1],
+        ]).data
+      )
+    );
+  });
+
+  it('leaves border-connected background untouched', () => {
+    const { data, dimensions } = flatFromGrid([
+      [0, 1, 1],
+      [1, 0, 1],
+      [1, 1, 1],
+    ]);
+    const out = fillHoles({ data, dimensions, axis: 2, sliceIndex: 0 });
+    // The top-left 0 reaches the border, so it stays 0; the center is enclosed.
+    expect(Array.from(out)).toEqual(
+      Array.from(
+        flatFromGrid([
+          [0, 1, 1],
+          [1, 1, 1],
+          [1, 1, 1],
+        ]).data
+      )
+    );
+  });
+
+  it('does not mutate the input array', () => {
+    const { data, dimensions } = flatFromGrid([
+      [1, 1, 1],
+      [1, 0, 1],
+      [1, 1, 1],
+    ]);
+    const before = Array.from(data);
+    fillHoles({ data, dimensions, axis: 2, sliceIndex: 0 });
+    expect(Array.from(data)).toEqual(before);
+  });
+
+  it('all-segments: fills a hole with the majority bordering label', () => {
+    const { data, dimensions } = flatFromGrid([
+      [5, 5, 5],
+      [7, 0, 5],
+      [5, 5, 5],
+    ]);
+    // The center 0 borders three 5s and one 7, so the majority is 5.
+    const out = fillHoles({ data, dimensions, axis: 2, sliceIndex: 0 });
+    expect(out[1 + 1 * 3]).toBe(5);
+  });
+
+  it('selected-segment: fills enclosed background but preserves encircled segments', () => {
+    // 7 wide x 5 tall. Left block is a ring of 1 enclosing 0s and 2s; a stray
+    // 2 sits outside the ring on the right border.
+    const { data, dimensions } = flatFromGrid([
+      [1, 1, 1, 1, 1, 0, 2],
+      [1, 0, 2, 0, 1, 0, 0],
+      [1, 2, 2, 2, 1, 0, 0],
+      [1, 0, 2, 0, 1, 0, 0],
+      [1, 1, 1, 1, 1, 0, 0],
+    ]);
+    const out = fillHoles({
+      data,
+      dimensions,
+      axis: 2,
+      sliceIndex: 0,
+      label: 1,
+    });
+    // Enclosed background (0) becomes 1; the enclosed 2s stay 2.
+    expect(Array.from(out)).toEqual(
+      Array.from(
+        flatFromGrid([
+          [1, 1, 1, 1, 1, 0, 2],
+          [1, 1, 2, 1, 1, 0, 0],
+          [1, 2, 2, 2, 1, 0, 0],
+          [1, 1, 2, 1, 1, 0, 0],
+          [1, 1, 1, 1, 1, 0, 0],
+        ]).data
+      )
+    );
+  });
+
+  it('selected-segment: does not override a segment it fully encircles', () => {
+    // Segment 1 forms a ring around segment 2 with a background gap between.
+    const { data, dimensions } = flatFromGrid([
+      [1, 1, 1, 1, 1],
+      [1, 0, 0, 0, 1],
+      [1, 0, 2, 0, 1],
+      [1, 0, 0, 0, 1],
+      [1, 1, 1, 1, 1],
+    ]);
+    const out = fillHoles({
+      data,
+      dimensions,
+      axis: 2,
+      sliceIndex: 0,
+      label: 1,
+    });
+    // The background gap fills with 1; the encircled 2 is untouched.
+    expect(Array.from(out)).toEqual(
+      Array.from(
+        flatFromGrid([
+          [1, 1, 1, 1, 1],
+          [1, 1, 1, 1, 1],
+          [1, 1, 2, 1, 1],
+          [1, 1, 1, 1, 1],
+          [1, 1, 1, 1, 1],
+        ]).data
+      )
+    );
+  });
+
+  it('whole-volume on a non-default axis fills every slice', () => {
+    // dims [3,3,3], slicing along axis 0: each i-plane is the (j,k) plane.
+    // Every i-plane is a ring of 1 around a 0 at (j=1, k=1).
+    const dimensions: [number, number, number] = [3, 3, 3];
+    const data = new Uint8Array(27).fill(1);
+    const holeOffset = (i: number) => i + 1 * 3 + 1 * 9; // j=1, k=1
+    for (let i = 0; i < 3; i += 1) data[holeOffset(i)] = 0;
+    // A border voxel that must stay 0 (corner of the i=0 plane).
+    data[0] = 0;
+
+    const out = fillHoles({ data, dimensions, axis: 0 });
+    for (let i = 0; i < 3; i += 1) {
+      expect(out[holeOffset(i)]).toBe(1);
+    }
+    expect(out[0]).toBe(0);
+  });
+
+  it('only fills the requested slice when sliceIndex is given', () => {
+    const dimensions: [number, number, number] = [3, 3, 3];
+    const data = new Uint8Array(27).fill(1);
+    const holeOffset = (i: number) => i + 1 * 3 + 1 * 9;
+    for (let i = 0; i < 3; i += 1) data[holeOffset(i)] = 0;
+
+    const out = fillHoles({ data, dimensions, axis: 0, sliceIndex: 1 });
+    expect(out[holeOffset(0)]).toBe(0);
+    expect(out[holeOffset(1)]).toBe(1);
+    expect(out[holeOffset(2)]).toBe(0);
+  });
+
+  it('all-segments: breaks majority ties by the lowest label', () => {
+    // The center borders two 8s (reached first by the flood) and two 3s. The
+    // lower label must win regardless of traversal order, so this fails if ties
+    // fall back to insertion order.
+    const { data, dimensions } = flatFromGrid([
+      [8, 8, 3],
+      [8, 0, 3],
+      [8, 3, 3],
+    ]);
+    const out = fillHoles({ data, dimensions, axis: 2, sliceIndex: 0 });
+    expect(out[1 + 1 * 3]).toBe(3);
+  });
+
+  it('all-segments: does not grow a locked segment into a hole', () => {
+    const { data, dimensions } = flatFromGrid([
+      [5, 5, 5],
+      [5, 0, 5],
+      [5, 5, 5],
+    ]);
+    // 5 is locked, so its enclosed hole is left as background.
+    const out = fillHoles({
+      data,
+      dimensions,
+      axis: 2,
+      sliceIndex: 0,
+      lockedLabels: [5],
+    });
+    expect(out[1 + 1 * 3]).toBe(0);
+  });
+
+  it('all-segments: fills with the unlocked majority even when a locked label borders', () => {
+    const { data, dimensions } = flatFromGrid([
+      [5, 5, 5],
+      [7, 0, 5],
+      [5, 5, 5],
+    ]);
+    // Majority 5 (unlocked) wins over the single locked 7 neighbor.
+    const out = fillHoles({
+      data,
+      dimensions,
+      axis: 2,
+      sliceIndex: 0,
+      lockedLabels: [7],
+    });
+    expect(out[1 + 1 * 3]).toBe(5);
+  });
+});
diff --git a/src/core/tools/paint/fillHoles.ts b/src/core/tools/paint/fillHoles.ts
new file mode 100644
index 000000000..5ccb8e8c0
--- /dev/null
+++ b/src/core/tools/paint/fillHoles.ts
@@ -0,0 +1,182 @@
+import { TypedArray } from '@kitware/vtk.js/types';
+
+// 4-connected neighbor offsets, shared so the flood-fill loops never allocate
+// a neighbor array per visited voxel.
+const NEIGHBOR_DU = [-1, 1, 0, 0];
+const NEIGHBOR_DV = [0, 0, -1, 1];
+
+export type FillHolesOptions = {
+  // Flat label-map scalar array, indexed as i + j*dimI + k*dimI*dimJ.
+  data: TypedArray | number[];
+  // Label-map IJK dimensions [dimI, dimJ, dimK].
+  dimensions: [number, number, number];
+  // IJK axis perpendicular to the fill plane (the slice axis).
+  axis: 0 | 1 | 2;
+  // When set, only this slice index along `axis` is processed.
+  // When omitted, every slice along `axis` is processed.
+  sliceIndex?: number;
+  // When set, only this label is treated as foreground (selected-segment mode)
+  // and enclosed background is filled with it. When omitted, every non-zero
+  // voxel is foreground (all-segments mode) and enclosed background is filled
+  // with the majority bordering label. In both modes only background (0)
+  // voxels are filled, so existing segments are never overwritten.
+  label?: number;
+  // All-segments mode only: labels that must not be grown. A hole whose
+  // majority bordering label is locked is left unfilled rather than expanding a
+  // locked segment.
+  lockedLabels?: number[];
+};
+
+// Fills enclosed background regions ("holes") on 2D slices of a label map.
+// A hole is background that does not connect to the slice border. Only
+// background (0) voxels are filled; other segments are never overwritten, even
+// when enclosed by the foreground. Returns a copy of `data`; the input is left
+// untouched.
+export function fillHoles(opts: FillHolesOptions) {
+  const { data, dimensions, axis, sliceIndex, label, lockedLabels } = opts;
+  const out = data.slice();
+  const lockedSet = lockedLabels?.length ? new Set(lockedLabels) : null;
+
+  const strides = [1, dimensions[0], dimensions[0] * dimensions[1]];
+  const sliceStride = strides[axis];
+  const sliceCount = dimensions[axis];
+
+  // The two in-plane axes (everything that isn't the slice axis).
+  const [uAxis, vAxis] = [0, 1, 2].filter((a) => a !== axis);
+  const uDim = dimensions[uAxis];
+  const vDim = dimensions[vAxis];
+  const uStride = strides[uAxis];
+  const vStride = strides[vAxis];
+  const planeSize = uDim * vDim;
+
+  const isForeground =
+    label === undefined
+      ? (value: number) => value !== 0
+      : (value: number) => value === label;
+  // Only all-segments mode needs to tally each hole's bordering labels.
+  const trackBorders = label === undefined;
+
+  // 0 = unvisited, 1 = outside (border-connected non-foreground), 2 = hole.
+  const visited = new Uint8Array(planeSize);
+  const stack: number[] = [];
+
+  const firstSlice = sliceIndex ?? 0;
+  const lastSlice = sliceIndex ?? sliceCount - 1;
+
+  for (let slice = firstSlice; slice <= lastSlice; slice++) {
+    const base = slice * sliceStride;
+    visited.fill(0);
+
+    const planeOffset = (u: number, v: number) =>
+      base + u * uStride + v * vStride;
+
+    // Drain `stack`, expanding the region into unvisited non-foreground
+    // neighbors (each marked with `mark`). `collect`, when given, receives the
+    // flat offset of every region cell; `onBorder`, when given, is called with
+    // each bordering foreground label.
+    const drain = (
+      mark: number,
+      collect?: number[],
+      onBorder?: (value: number) => void
+    ) => {
+      while (stack.length) {
+        const p = stack.pop()!;
+        const u = p % uDim;
+        const v = (p - u) / uDim;
+        if (collect) collect.push(planeOffset(u, v));
+        for (let n = 0; n < 4; n++) {
+          const nu = u + NEIGHBOR_DU[n];
+          const nv = v + NEIGHBOR_DV[n];
+          if (nu < 0 || nu >= uDim || nv < 0 || nv >= vDim) continue;
+          const np = nu + nv * uDim;
+          const nValue = out[planeOffset(nu, nv)];
+          if (isForeground(nValue)) {
+            onBorder?.(nValue);
+          } else if (visited[np] === 0) {
+            visited[np] = mark;
+            stack.push(np);
+          }
+        }
+      }
+    };
+
+    // Flood non-foreground cells reachable from the slice border ("outside").
+    const seedOutside = (u: number, v: number) => {
+      const p = u + v * uDim;
+      if (visited[p] === 0 && !isForeground(out[planeOffset(u, v)])) {
+        visited[p] = 1;
+        stack.push(p);
+      }
+    };
+    for (let u = 0; u < uDim; u++) {
+      seedOutside(u, 0);
+      seedOutside(u, vDim - 1);
+    }
+    for (let v = 0; v < vDim; v++) {
+      seedOutside(0, v);
+      seedOutside(uDim - 1, v);
+    }
+    drain(1);
+
+    // Any non-foreground cell not marked "outside" is part of a hole. Group
+    // each hole into a connected component and fill it.
+    for (let v = 0; v < vDim; v++) {
+      for (let u = 0; u < uDim; u++) {
+        const p = u + v * uDim;
+        if (visited[p] !== 0 || isForeground(out[planeOffset(u, v)])) continue;
+
+        const holeCells: number[] = [];
+        const borderLabelCounts = trackBorders
+          ? new Map<number, number>()
+          : null;
+        visited[p] = 2;
+        stack.push(p);
+        drain(
+          2,
+          holeCells,
+          borderLabelCounts
+            ? (value) =>
+                borderLabelCounts.set(
+                  value,
+                  (borderLabelCounts.get(value) ?? 0) + 1
+                )
+            : undefined
+        );
+
+        let fillValue = label;
+        if (fillValue === undefined && borderLabelCounts) {
+          // All-segments mode: fill with the majority bordering label, breaking
+          // ties by lowest label so the result is deterministic. Never fill
+          // with a locked label, which would grow a locked segment.
+          let bestCount = 0;
+          let bestLabel = -1;
+          borderLabelCounts.forEach((count, value) => {
+            if (
+              count > bestCount ||
+              (count === bestCount && value < bestLabel)
+            ) {
+              bestCount = count;
+              bestLabel = value;
+            }
+          });
+          if (bestLabel !== -1 && !lockedSet?.has(bestLabel)) {
+            fillValue = bestLabel;
+          }
+        }
+        // fillValue stays undefined only when the hole had no fillable border
+        // (no foreground neighbors, or every bordering label is locked).
+        if (fillValue !== undefined) {
+          for (let c = 0; c < holeCells.length; c++) {
+            // Only fill background; never overwrite another segment, even when
+            // it is enclosed by the foreground.
+            if (out[holeCells[c]] === 0) {
+              out[holeCells[c]] = fillValue;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return out;
+}
diff --git a/src/core/tools/paint/fillHoles.worker.ts b/src/core/tools/paint/fillHoles.worker.ts
new file mode 100644
index 000000000..6e3f30995
--- /dev/null
+++ b/src/core/tools/paint/fillHoles.worker.ts
@@ -0,0 +1,14 @@
+import * as Comlink from 'comlink';
+import { fillHoles, FillHolesOptions } from '@/src/core/tools/paint/fillHoles';
+
+// Runs the pure flood-fill off the main thread so whole-volume fills do not
+// freeze the UI, mirroring gaussianSmooth.worker.ts.
+export function fillHolesWorker(input: FillHolesOptions) {
+  return fillHoles(input);
+}
+
+const workerApi = {
+  fillHolesWorker,
+};
+
+Comlink.expose(workerApi);
diff --git a/src/store/__tests__/fillHoles.spec.ts b/src/store/__tests__/fillHoles.spec.ts
new file mode 100644
index 000000000..4368c5422
--- /dev/null
+++ b/src/store/__tests__/fillHoles.spec.ts
@@ -0,0 +1,174 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { setActivePinia, createPinia } from 'pinia';
+import { nextTick } from 'vue';
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import vtkLabelMap from '@/src/vtk/LabelMap';
+import { useFillHolesStore } from '@/src/store/tools/fillHoles';
+import { useImageCacheStore } from '@/src/store/image-cache';
+import { usePaintToolStore } from '@/src/store/tools/paint';
+import { useSegmentGroupStore } from '@/src/store/segmentGroups';
+import { useViewSliceStore } from '@/src/store/view-configs/slicing';
+import { useViewStore } from '@/src/store/views';
+
+const fillHolesWorkerMock = vi.hoisted(() => vi.fn(async (input) => input));
+
+vi.mock('comlink', () => ({
+  wrap: () => ({
+    fillHolesWorker: fillHolesWorkerMock,
+  }),
+}));
+
+vi.mock('@/src/store/image-stats', () => ({
+  useImageStatsStore: () => ({ stats: {} }),
+}));
+
+function addScalars(image: vtkImageData, values: Uint8Array) {
+  image.getPointData().setScalars(
+    vtkDataArray.newInstance({
+      numberOfComponents: 1,
+      values,
+    })
+  );
+}
+
+type Vector3 = [number, number, number];
+type Matrix3 = [
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+];
+
+function makeImage(dimensions: Vector3, spacing: Vector3, direction: Matrix3) {
+  const image = vtkImageData.newInstance({ spacing, direction });
+  image.setDimensions(dimensions);
+  addScalars(
+    image,
+    new Uint8Array(dimensions[0] * dimensions[1] * dimensions[2])
+  );
+  image.computeTransforms();
+  return image;
+}
+
+function makeLabelMap(
+  dimensions: Vector3,
+  spacing: Vector3,
+  direction: Matrix3
+) {
+  const labelMap = vtkLabelMap.newInstance({ spacing, direction });
+  labelMap.setDimensions(dimensions);
+  addScalars(
+    labelMap,
+    new Uint8Array(dimensions[0] * dimensions[1] * dimensions[2])
+  );
+  labelMap.computeTransforms();
+  return labelMap;
+}
+
+describe('Fill Holes store', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia());
+    fillHolesWorkerMock.mockClear();
+    vi.stubGlobal(
+      'Worker',
+      class {
+        terminate() {}
+      }
+    );
+  });
+
+  async function setupFillHolesRun(labelMap: vtkLabelMap, parentSlice: number) {
+    const imageCacheStore = useImageCacheStore();
+    const segmentGroupStore = useSegmentGroupStore();
+    const viewStore = useViewStore();
+    const viewSliceStore = useViewSliceStore();
+    const paintStore = usePaintToolStore();
+    const fillHolesStore = useFillHolesStore();
+
+    const parentImageID = 'parent-image';
+    const parentImage = makeImage(
+      [10, 10, 10],
+      [1, 1, 1],
+      [1, 0, 0, 0, 1, 0, 0, 0, 1]
+    );
+    imageCacheStore.addVTKImageData(parentImage, 'Parent', {
+      id: parentImageID,
+    });
+    await nextTick();
+
+    const groupId = segmentGroupStore.addLabelmap(labelMap, {
+      name: 'Test group',
+      parentImage: parentImageID,
+      segments: {
+        order: [1],
+        byValue: {
+          1: {
+            value: 1,
+            name: 'Segment 1',
+            color: [255, 0, 0, 255],
+            visible: true,
+            locked: false,
+          },
+        },
+      },
+    });
+
+    const axialView = viewStore.visibleViews.find(
+      (view) => view.type === '2D' && view.options.orientation === 'Axial'
+    );
+    expect(axialView).toBeDefined();
+    viewStore.setDataForView(axialView!.id, parentImageID);
+    viewStore.setActiveView(axialView!.id);
+    viewSliceStore.updateConfig(axialView!.id, parentImageID, {
+      slice: parentSlice,
+    });
+
+    paintStore.activeSegmentGroupID = groupId;
+    paintStore.activeSegment = 1;
+
+    return { fillHolesStore };
+  }
+
+  it('uses the label-map axis for the active parent view axis', async () => {
+    // Label-map I points along parent/world axial, so an active Axial view must
+    // be sent to the worker as axis 0 rather than the parent image's axis 2.
+    const labelMap = makeLabelMap(
+      [5, 10, 10],
+      [1, 1, 1],
+      [0, 0, 1, 0, 1, 0, 1, 0, 0]
+    );
+    const { fillHolesStore } = await setupFillHolesRun(labelMap, 0);
+
+    await fillHolesStore.computeAlgorithm(labelMap, 1);
+
+    expect(fillHolesWorkerMock).toHaveBeenCalledTimes(1);
+    expect(fillHolesWorkerMock.mock.calls[0][0]).toMatchObject({
+      axis: 0,
+    });
+  });
+
+  it('converts the active parent slice into label-map slice space', async () => {
+    // Same orientation, different axial spacing: parent slice 4 is world z=4,
+    // which lands on label-map slice 2 when label-map z spacing is 2.
+    const labelMap = makeLabelMap(
+      [10, 10, 5],
+      [1, 1, 2],
+      [1, 0, 0, 0, 1, 0, 0, 0, 1]
+    );
+    const { fillHolesStore } = await setupFillHolesRun(labelMap, 4);
+
+    await fillHolesStore.computeAlgorithm(labelMap, 1);
+
+    expect(fillHolesWorkerMock).toHaveBeenCalledTimes(1);
+    expect(fillHolesWorkerMock.mock.calls[0][0]).toMatchObject({
+      axis: 2,
+      sliceIndex: 2,
+    });
+  });
+});
diff --git a/src/store/__tests__/paintProcess.spec.ts b/src/store/__tests__/paintProcess.spec.ts
new file mode 100644
index 000000000..899b178a4
--- /dev/null
+++ b/src/store/__tests__/paintProcess.spec.ts
@@ -0,0 +1,85 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { setActivePinia, createPinia } from 'pinia';
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import vtkLabelMap from '@/src/vtk/LabelMap';
+import { PaintMode } from '@/src/core/tools/paint';
+import { useSegmentGroupStore } from '@/src/store/segmentGroups';
+import { usePaintToolStore } from '@/src/store/tools/paint';
+import { usePaintProcessStore } from '@/src/store/tools/paintProcess';
+
+function makeLabelMap(values: Uint8Array) {
+  const labelMap = vtkLabelMap.newInstance();
+  labelMap.setDimensions([values.length, 1, 1]);
+  labelMap.getPointData().setScalars(
+    vtkDataArray.newInstance({
+      numberOfComponents: 1,
+      values,
+    })
+  );
+  labelMap.computeTransforms();
+  return labelMap;
+}
+
+function getScalars(labelMap: vtkLabelMap) {
+  return Array.from(labelMap.getPointData().getScalars().getData());
+}
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (error: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+describe('Paint process store', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia());
+  });
+
+  it('ignores stale async results after a newer process starts', async () => {
+    const segmentGroupStore = useSegmentGroupStore();
+    const paintStore = usePaintToolStore();
+    const labelMap = makeLabelMap(new Uint8Array([0, 0]));
+    const groupId = segmentGroupStore.addLabelmap(labelMap, {
+      name: 'Test group',
+      parentImage: 'image-1',
+      segments: {
+        order: [1],
+        byValue: {
+          1: {
+            value: 1,
+            name: 'Segment 1',
+            color: [255, 0, 0, 255],
+            visible: true,
+            locked: false,
+          },
+        },
+      },
+    });
+
+    paintStore.activeSegmentGroupID = groupId;
+    paintStore.activeSegment = 1;
+    paintStore.activeMode = PaintMode.Process;
+    const processStore = usePaintProcessStore();
+
+    const first = deferred<Uint8Array>();
+    const second = deferred<Uint8Array>();
+    const firstRun = processStore.startProcess(groupId, () => first.promise);
+    const secondRun = processStore.startProcess(groupId, () => second.promise);
+
+    first.resolve(new Uint8Array([9, 9]));
+    await firstRun;
+
+    expect(processStore.processState.step).toBe('computing');
+    expect(getScalars(labelMap)).toEqual([0, 0]);
+
+    second.resolve(new Uint8Array([2, 2]));
+    await secondRun;
+
+    expect(processStore.processState.step).toBe('previewing');
+    expect(getScalars(labelMap)).toEqual([2, 2]);
+  });
+});
diff --git a/src/store/tools/fillHoles.ts b/src/store/tools/fillHoles.ts
new file mode 100644
index 000000000..d6c123cee
--- /dev/null
+++ b/src/store/tools/fillHoles.ts
@@ -0,0 +1,134 @@
+import { defineStore } from 'pinia';
+import { ref } from 'vue';
+import * as Comlink from 'comlink';
+import vtkLabelMap from '@/src/vtk/LabelMap';
+import { useViewStore } from '@/src/store/views';
+import { useViewSliceStore } from '@/src/store/view-configs/slicing';
+import { usePaintToolStore } from '@/src/store/tools/paint';
+import { useSegmentGroupStore } from '@/src/store/segmentGroups';
+import { getImageMetadata } from '@/src/composables/useCurrentImage';
+import { getEffectiveView } from '@/src/core/views/effectiveView';
+import { fillHolesWorker } from '@/src/core/tools/paint/fillHoles.worker';
+import { convertSliceIndex } from '@/src/utils/imageSpace';
+import { getLPSDirections } from '@/src/utils/lps';
+
+export enum FillHolesSliceScope {
+  CurrentSlice = 'currentSlice',
+  WholeVolume = 'wholeVolume',
+}
+
+export enum FillHolesSegmentScope {
+  AllSegments = 'allSegments',
+  SelectedSegment = 'selectedSegment',
+}
+
+type WorkerApi = {
+  fillHolesWorker: typeof fillHolesWorker;
+};
+
+let workerInstance: Comlink.Remote<WorkerApi> | null = null;
+
+async function getWorker() {
+  if (!workerInstance) {
+    const worker = new Worker(
+      new URL('@/src/core/tools/paint/fillHoles.worker.ts', import.meta.url),
+      { type: 'module' }
+    );
+    workerInstance = Comlink.wrap<WorkerApi>(worker);
+  }
+  return workerInstance;
+}
+
+export const useFillHolesStore = defineStore('fillHoles', () => {
+  const sliceScope = ref(FillHolesSliceScope.CurrentSlice);
+  const segmentScope = ref(FillHolesSegmentScope.AllSegments);
+
+  function setSliceScope(value: FillHolesSliceScope) {
+    sliceScope.value = value;
+  }
+
+  function setSegmentScope(value: FillHolesSegmentScope) {
+    segmentScope.value = value;
+  }
+
+  async function computeAlgorithm(
+    segImage: vtkLabelMap,
+    activeSegment: number
+  ) {
+    const viewStore = useViewStore();
+    const viewSliceStore = useViewSliceStore();
+    const paintStore = usePaintToolStore();
+    const segmentGroupStore = useSegmentGroupStore();
+
+    // Fill Holes works on the slice plane of the 2D view the user is on, so a
+    // 2D view must be active to know which axis (and slice) to operate on.
+    const effectiveView = getEffectiveView(viewStore.activeView);
+    if (effectiveView?.kind !== 'volume2D') {
+      throw new Error(
+        'Fill Holes needs an active 2D slice view. Click a 2D view, then try again.'
+      );
+    }
+
+    const groupId = paintStore.activeSegmentGroupID;
+    if (!groupId) {
+      throw new Error('No active segment group');
+    }
+    const metadata = segmentGroupStore.metadataByID[groupId];
+
+    const parentMetadata = getImageMetadata(metadata.parentImage);
+    const labelMapLpsOrientation = getLPSDirections(segImage.getDirection());
+    const axis = labelMapLpsOrientation[effectiveView.axis];
+
+    const dimensions = segImage.getDimensions() as [number, number, number];
+    const data = segImage.getPointData().getScalars().getData();
+
+    let sliceIndex: number | undefined;
+    if (sliceScope.value === FillHolesSliceScope.CurrentSlice) {
+      const sliceConfig = viewSliceStore.getConfig(
+        effectiveView.viewInfo.id,
+        metadata.parentImage
+      );
+      const parentAxis = parentMetadata.lpsOrientation[effectiveView.axis];
+      const parentSlice =
+        sliceConfig?.slice ??
+        Math.floor(parentMetadata.dimensions[parentAxis] / 2);
+      sliceIndex = convertSliceIndex(
+        parentSlice,
+        parentMetadata.lpsOrientation,
+        parentMetadata.indexToWorld,
+        segImage,
+        effectiveView.axis
+      );
+    }
+
+    const selectedSegment =
+      segmentScope.value === FillHolesSegmentScope.SelectedSegment;
+    const label = selectedSegment ? activeSegment : undefined;
+    // All-segments mode can fill a hole with any bordering label, so guard
+    // locked segments from being grown. Selected-segment mode only writes the
+    // active segment, whose lock is already enforced before the process starts.
+    const lockedLabels = selectedSegment
+      ? undefined
+      : Object.values(metadata.segments.byValue)
+          .filter((segment) => segment.locked)
+          .map((segment) => segment.value);
+
+    const worker = await getWorker();
+    return worker.fillHolesWorker({
+      data,
+      dimensions,
+      axis,
+      sliceIndex,
+      label,
+      lockedLabels,
+    });
+  }
+
+  return {
+    sliceScope,
+    segmentScope,
+    setSliceScope,
+    setSegmentScope,
+    computeAlgorithm,
+  };
+});
diff --git a/src/store/tools/paintProcess.ts b/src/store/tools/paintProcess.ts
index 66269dae1..0c5b63b1e 100644
--- a/src/store/tools/paintProcess.ts
+++ b/src/store/tools/paintProcess.ts
@@ -10,6 +10,7 @@ import { useCurrentImage } from '@/src/composables/useCurrentImage';
 import { useSegmentGroupStore } from '../segmentGroups';
 
 export enum ProcessType {
+  FillHoles = 'fillHoles',
   FillBetween = 'fillBetween',
   GaussianSmooth = 'gaussianSmooth',
 }
@@ -43,7 +44,8 @@ export type ProcessAlgorithm = (
 
 export const usePaintProcessStore = defineStore('paintProcess', () => {
   const processState = ref<ProcessState>({ step: 'start' });
-  const activeProcessType = ref<ProcessType>(ProcessType.FillBetween);
+  const activeProcessType = ref<ProcessType>(ProcessType.FillHoles);
+  let activeProcessRunId = 0;
 
   const processStep = computed(() => processState.value.step);
 
@@ -57,6 +59,17 @@ export const usePaintProcessStore = defineStore('paintProcess', () => {
   }
 
   function confirmProcess() {
+    const state = processState.value;
+    // Apply commits the processed result. When the user is viewing the
+    // original, the image currently holds originalScalars, so restore the
+    // processed scalars before finishing or the result is silently discarded.
+    if (state.step === 'previewing' && state.showingOriginal) {
+      state.segImage
+        .getPointData()
+        .getScalars()
+        .setData(state.processedScalars);
+      state.segImage.modified();
+    }
     resetState();
   }
 
@@ -89,23 +102,35 @@ export const usePaintProcessStore = defineStore('paintProcess', () => {
     activeProcessType.value = processType;
   }
 
-  async function startProcess(groupId: string, algorithm: ProcessAlgorithm) {
-    if (!paintStore.activeSegment) {
-      messageStore.addError('No active segment selected');
-      return;
-    }
+  async function startProcess(
+    groupId: string,
+    algorithm: ProcessAlgorithm,
+    options?: { requiresActiveSegment?: boolean }
+  ) {
+    const activeSegment = paintStore.activeSegment;
+    // Most processes operate on the active segment; all-segments processes opt
+    // out so they are not blocked by (or limited to) a single active segment.
+    const requiresActiveSegment = options?.requiresActiveSegment ?? true;
+
+    if (requiresActiveSegment) {
+      if (!activeSegment) {
+        messageStore.addError('No active segment selected');
+        return;
+      }
 
-    // Check if the active segment is locked
-    const segment = segmentGroupStore.getSegment(
-      groupId,
-      paintStore.activeSegment
-    );
-    if (segment?.locked) {
-      messageStore.addError('Cannot process locked segment');
-      return;
+      // Check if the active segment is locked
+      const segment = segmentGroupStore.getSegment(groupId, activeSegment);
+      if (segment?.locked) {
+        messageStore.addError('Cannot process locked segment');
+        return;
+      }
     }
 
     const segImage = segmentGroupStore.dataIndex[groupId];
+    const activeParentImageID =
+      segmentGroupStore.metadataByID[groupId].parentImage;
+    const processType = activeProcessType.value;
+    const processRunId = ++activeProcessRunId;
 
     const originalScalars = segImage
       .getPointData()
@@ -115,16 +140,19 @@ export const usePaintProcessStore = defineStore('paintProcess', () => {
 
     processState.value = {
       step: 'computing',
-      activeParentImageID: segmentGroupStore.metadataByID[groupId].parentImage,
-      processType: activeProcessType.value,
+      activeParentImageID,
+      processType,
     };
 
     try {
-      const outputScalars = await algorithm(segImage, paintStore.activeSegment);
-
-      // If the state changed during the async operation, stop processing
-      if (processState.value.step !== 'computing') {
-        return; // cancelProcess handled the state change
+      const outputScalars = await algorithm(segImage, activeSegment ?? 0);
+
+      // If the state changed during the async operation, stop processing.
+      if (
+        processRunId !== activeProcessRunId ||
+        processState.value.step !== 'computing'
+      ) {
+        return;
       }
 
       const scalars = segImage.getPointData().getScalars();
@@ -133,22 +161,26 @@ export const usePaintProcessStore = defineStore('paintProcess', () => {
 
       processState.value = {
         step: 'previewing',
-        activeParentImageID:
-          segmentGroupStore.metadataByID[groupId].parentImage,
-        processType: activeProcessType.value,
+        activeParentImageID,
+        processType,
         segImage,
         originalScalars,
         processedScalars: outputScalars,
         showingOriginal: false,
       };
     } catch (error) {
-      messageStore.addError(`${activeProcessType.value} Operation Failed`, {
+      if (
+        processRunId !== activeProcessRunId ||
+        processState.value.step !== 'computing'
+      ) {
+        return;
+      }
+
+      messageStore.addError(`${processType} Operation Failed`, {
         error: error as Error,
       });
-      if (processState.value.step === 'computing') {
-        rollbackPreview(segImage, originalScalars);
-        resetState();
-      }
+      rollbackPreview(segImage, originalScalars);
+      resetState();
     }
   }
 
diff --git a/tests/pageobjects/volview.page.ts b/tests/pageobjects/volview.page.ts
index 7aebc7984..c69b9e814 100644
--- a/tests/pageobjects/volview.page.ts
+++ b/tests/pageobjects/volview.page.ts
@@ -114,6 +114,87 @@ class VolViewPage extends Page {
     await button.click();
   }
 
+  // Paint "Process" mode and the Fill Holes process workflow.
+  get processModeButton() {
+    return $('button*=Process');
+  }
+
+  get fillHolesProcessButton() {
+    return $('button*=Fill Holes');
+  }
+
+  get fillHolesWholeVolumeButton() {
+    return $('button*=All slices');
+  }
+
+  get fillHolesSelectedSegmentButton() {
+    return $('button*=Selected segment');
+  }
+
+  get processPreviewButton() {
+    return $('button*=Preview');
+  }
+
+  get processApplyButton() {
+    return $('button*=Apply');
+  }
+
+  get processOriginalButton() {
+    return $('button*=Original');
+  }
+
+  get processProcessedButton() {
+    return $('button*=Processed');
+  }
+
+  // The selected button in a Vuetify v-btn-toggle carries v-btn--active.
+  async isPreviewToggleActive(button: ChainablePromiseElement) {
+    const classes = await button.getAttribute('class');
+    return (classes ?? '').includes('v-btn--active');
+  }
+
+  async paintStrokeOnView(view: ChainablePromiseElement) {
+    const canvas = await view.$('canvas');
+    const location = await canvas.getLocation();
+    const size = await canvas.getSize();
+    const centerX = Math.round(location.x + size.width / 2);
+    const centerY = Math.round(location.y + size.height / 2);
+
+    await browser
+      .action('pointer')
+      .move({ x: centerX, y: centerY })
+      .down()
+      .move({ x: centerX + 40, y: centerY })
+      .move({ x: centerX + 40, y: centerY + 40 })
+      .move({ x: centerX, y: centerY + 40 })
+      .move({ x: centerX, y: centerY })
+      .up()
+      .perform();
+  }
+
+  async runFillHoles() {
+    await this.processModeButton.waitForClickable();
+    await this.processModeButton.click();
+
+    const fillHoles = this.fillHolesProcessButton;
+    await fillHoles.waitForClickable();
+    await fillHoles.click();
+
+    const preview = this.processPreviewButton;
+    await preview.waitForClickable();
+    await preview.click();
+
+    // Reaching the "previewing" state (Apply appears) only happens after the
+    // algorithm runs successfully on the label map.
+    const apply = this.processApplyButton;
+    await apply.waitForDisplayed();
+    await apply.waitForClickable();
+    await apply.click();
+
+    // Applying returns the workflow to its start state (Preview reappears).
+    await this.processPreviewButton.waitForDisplayed();
+  }
+
   get viewTwoContainer() {
     return $('div[data-testid~="two-view-container"]');
   }
diff --git a/tests/specs/paint-fill-holes.e2e.ts b/tests/specs/paint-fill-holes.e2e.ts
new file mode 100644
index 000000000..1a1471d8d
--- /dev/null
+++ b/tests/specs/paint-fill-holes.e2e.ts
@@ -0,0 +1,76 @@
+import AppPage from '../pageobjects/volview.page';
+
+describe('Fill Holes paint process', () => {
+  beforeEach(async () => {
+    await AppPage.open();
+    await AppPage.downloadProstateSample();
+    await AppPage.waitForViews();
+
+    const views2D = await AppPage.getViews2D();
+    const axialView = views2D[0];
+
+    await AppPage.activatePaint();
+    // Paint a shape so the label map has data for the algorithm to process.
+    await AppPage.paintStrokeOnView(axialView);
+  });
+
+  it('runs the Fill Holes workflow to completion on a painted segment', async () => {
+    // Default options: current slice, all segments.
+    await AppPage.runFillHoles();
+
+    // The Preview button is back, meaning the process applied without error.
+    await expect(AppPage.processPreviewButton).toBeDisplayed();
+  });
+
+  it('runs Fill Holes with whole-volume and selected-segment options', async () => {
+    await AppPage.processModeButton.waitForClickable();
+    await AppPage.processModeButton.click();
+    await AppPage.fillHolesProcessButton.waitForClickable();
+    await AppPage.fillHolesProcessButton.click();
+
+    // Switch both option toggles away from their defaults.
+    await AppPage.fillHolesWholeVolumeButton.waitForClickable();
+    await AppPage.fillHolesWholeVolumeButton.click();
+    await AppPage.fillHolesSelectedSegmentButton.waitForClickable();
+    await AppPage.fillHolesSelectedSegmentButton.click();
+
+    await AppPage.processPreviewButton.waitForClickable();
+    await AppPage.processPreviewButton.click();
+
+    const apply = AppPage.processApplyButton;
+    await apply.waitForDisplayed();
+    await apply.waitForClickable();
+    await apply.click();
+
+    await expect(AppPage.processPreviewButton).toBeDisplayed();
+  });
+
+  it('toggles the preview in place between processed and original', async () => {
+    await AppPage.processModeButton.waitForClickable();
+    await AppPage.processModeButton.click();
+    await AppPage.fillHolesProcessButton.waitForClickable();
+    await AppPage.fillHolesProcessButton.click();
+
+    await AppPage.processPreviewButton.waitForClickable();
+    await AppPage.processPreviewButton.click();
+
+    // Previewing starts on the processed result.
+    await AppPage.processProcessedButton.waitForDisplayed();
+    await browser.waitUntil(() =>
+      AppPage.isPreviewToggleActive(AppPage.processProcessedButton)
+    );
+    expect(
+      await AppPage.isPreviewToggleActive(AppPage.processOriginalButton)
+    ).toBe(false);
+
+    // Clicking the already-active button flips the preview in place, without
+    // moving the pointer to the other button.
+    await AppPage.processProcessedButton.click();
+    await browser.waitUntil(() =>
+      AppPage.isPreviewToggleActive(AppPage.processOriginalButton)
+    );
+    expect(
+      await AppPage.isPreviewToggleActive(AppPage.processProcessedButton)
+    ).toBe(false);
+  });
+});