docs: protected void initializeContext(
              @Nonnull List<BeanDefinitionReference> contextScopeBeans,
              @Nonnull List<BeanDefinitionReference> processedBeans) {
  
          if (CollectionUtils.isNotEmpty(contextScopeBeans)) {
              final Collection<BeanDefinition> contextBeans = new ArrayList<>();
  
              for (BeanDefinitionReference contextScopeBean : contextScopeBeans) {
                  try {
                      loadContextScopeBean(contextScopeBean, contextBeans::add);
                  } catch (Throwable e) {
                      throw new BeanInstantiationException("Bean definition [" + contextScopeBean.getName() + "] could not be loaded: " + e.getMessage(), e);
                  }
              }
              filterProxiedTypes((Collection) contextBeans, true, false);
              filterReplacedBeans((Collection) contextBeans);
  
              for (BeanDefinition contextScopeDefinition: contextBeans) {
                  try {
                      loadContextScopeBean(contextScopeDefinition);
                  } catch (Throwable e) {
                      throw new BeanInstantiationException("Bean definition [" + contextScopeDefinition.getName() + "] could not be loaded: " + e.getMessage(), e);
                  }
              }
              contextBeans.clear();
          }
  
          if (!processedBeans.isEmpty()) {
  
              @SuppressWarnings("unchecked") Stream<BeanDefinitionMethodReference<?, ?>> methodStream = processedBeans
                      .stream()
                      // is the bean reference enabled
                      .filter(ref -> ref.isEnabled(this))
                      // ok - continue and load it
                      .map((Function<BeanDefinitionReference, BeanDefinition<?>>) reference -> {
                          try {
                              return reference.load(this);
                          } catch (Exception e) {
                              throw new BeanInstantiationException("Bean definition [" + reference.getName() + "] could not be loaded: " + e.getMessage(), e);
                          }
                      })
                      // is the bean itself enabled
                      .filter(bean -> bean.isEnabled(this))
                      // ok continue and get all of the ExecutableMethod references
                      .flatMap(beanDefinition ->
                              beanDefinition.getExecutableMethods()
                                      .parallelStream()
                                      .map((Function<ExecutableMethod<?, ?>, BeanDefinitionMethodReference<?, ?>>) executableMethod ->
                                              BeanDefinitionMethodReference.of((BeanDefinition) beanDefinition, executableMethod)
                                      )
                      );
  
              // group the method references by annotation type such that we have a map of Annotation -> MethodReference
              // ie. Class<Scheduled> -> @Scheduled void someAnnotation()
              Map<Class<? extends Annotation>, List<BeanDefinitionMethodReference<?, ?>>> byAnnotation = methodStream
                      .collect(
                              Collectors.groupingBy((Function<ExecutableMethod<?, ?>, Class<? extends Annotation>>) executableMethod ->
                                      executableMethod.getAnnotationTypeByStereotype(Executable.class)
                                              .orElseThrow(() ->
                                                      new IllegalStateException("BeanDefinition.requiresMethodProcessing() returned true but method has no @Executable definition. This should never happen. Please report an issue.")
                                              )));
  
              // Find ExecutableMethodProcessor for each annotation and process the BeanDefinitionMethodReference
              for (Map.Entry<Class<? extends Annotation>, List<BeanDefinitionMethodReference<?, ?>>> entry : byAnnotation.entrySet()) {
                  Class<? extends Annotation> annotationType = entry.getKey();
                  streamOfType(ExecutableMethodProcessor.class, Qualifiers.byTypeArguments(annotationType))
                          .forEach(processor -> {
                              for (BeanDefinitionMethodReference<?, ?> method : entry.getValue()) {
  
                                  BeanDefinition<?> beanDefinition = method.getBeanDefinition();
  
                                  // Only process the method if the the annotation is not declared at the class level
                                  // If declared at the class level it will already have been processed by AnnotationProcessorListener
                                  if (!beanDefinition.hasStereotype(annotationType)) {
                                      //noinspection unchecked
                                      if (method.hasDeclaredStereotype(Parallel.class)) {
                                          ForkJoinPool.commonPool().execute(() -> {
                                              try {
                                                  processor.process(beanDefinition, method);
                                              } catch (Throwable e) {
                                                  if (LOG.isErrorEnabled()) {
                                                      LOG.error("Error processing bean method " + beanDefinition + "." + method + " with processor (" + processor + "): " + e.getMessage(), e);
                                                  }
                                                  Boolean shutdownOnError = method.getValue(Parallel.class, "shutdownOnError", Boolean.class).orElse(true);
                                                  if (shutdownOnError) {
                                                      stop();
                                                  }
                                              }
                                          });
                                      } else {
                                          processor.process(beanDefinition, method);
                                      }
                                  }
                              }
  
                              if (processor instanceof Completable) {
                                  ((Completable) processor).onComplete();
                              }
  
                          });
              }
          }
  
          final Runnable runnable = () ->
                  beanDefinitionsClasses.removeIf((BeanDefinitionReference beanDefinitionReference) ->
                          !beanDefinitionReference.isEnabled(this));
          if (ClassLoadingReporter.isReportingEnabled()) {
              // do this in a blocking manner so that reporting is immediately aware of missing classes
              runnable.run();
          } else {
              // proactively remove bean definitions that are not enabled
              new Thread(runnable).start();
          }
  
      }