async __executeValidators() {
      const value = getValueForValidators(this.modelValue);

      /**
       * Handle the 'mutually exclusive' Required validator:
       *
       * About the Required Validator:
       * - the validity is dependent on the formControls' modelValue and therefore determined
       * by the formControl._isEmpty method. Basically, the Required Validator is a means
       * to trigger formControl._isEmpty().
       *
       * About the empty state:
       * - when _isEmpty returns true, the modelValue is considered empty. This means we need to stop
       * validation here, because all other Validators' execute functions assume the
       * value is not empty (there would be nothing to validate).
       *
       */

      const isEmpty = this.__isEmpty(value);
      this.__syncValidationResult = [];

      /**
       * So we can have the following scenarios:
       * - we're empty
       *   - we have a single value (we are an 'endpoint') => we want to halt execution, because validation only makes sense when we have a value
       *     - 1. we have Required => we fill .__syncValidationResult and finish validation, because we have a value to validate
       *     - 2. we don't have Required => we stop validation
       *   - we have a group of values (object/array) => we want to continue execution, because the constellation of the object (even though the individual endpoints are empty) might be interesting for validation.
       *     - 3. we have Required => we fill .__syncValidationResult and continue validation (so we can add more to .__syncValidationResult)
       *     - 4. we don't have Required => we continue validation
       *  - we're not empty
       *    - we have a single value or group of values
       *     - 5. we may have Required, but if we have it will not be 'active' => we continue execution, because we have a value to validate
       */

      if (isEmpty) {
        const hasSingleValue = !(/** @type {*  & ValidateHost} */ (this)._isFormOrFieldset);
        const requiredValidator = this._allValidators.find(
          v => /** @type {typeof Validator} */ (v.constructor)?.validatorName === 'Required',
        );
        if (requiredValidator) {
          this.__syncValidationResult = [{ validator: requiredValidator, outcome: true }];
        }

        if (hasSingleValue) {
          this.__finishValidationPass({
            syncValidationResult: this.__syncValidationResult,
          });
          return;
        }
      }

      const metaValidators = /** @type {MetaValidator[]} */ [];
      const syncValidators = /** @type {Validator[]} */ [];
      const asyncValidators = /** @type {Validator[]} */ [];

      for (const v of this._allValidators) {
        if (/** @type {MetaValidator} */ (v)?.executeOnResults) {
          metaValidators.push(/** @type {MetaValidator} */ (v));
        } else if (/** @type {typeof Validator} */ (v.constructor)?.validatorName === 'Required') {
          // Required validator was already handled
        } else if (/** @type {typeof Validator} */ (v.constructor).async) {
          asyncValidators.push(v);
        } else {
          syncValidators.push(v);
        }
      }

      const hasAsync = Boolean(asyncValidators.length);

      /**
       * 2. Synchronous validators
       */

      this.__syncValidationResult = [
        // This could eventually contain the Required Validator
        ...this.__syncValidationResult,
        ...this.__executeSyncValidators(syncValidators, value),
      ];
      // Finish the first (synchronous) pass
      this.__finishValidationPass({
        syncValidationResult: this.__syncValidationResult,
        metaValidators,
      });

      /**
       * 3. Asynchronous validators
       */
      if (hasAsync) {
        // Add a hint in the ui that we're waiting for async validation
        this.isPending = true;
        this.__asyncValidationResult = await this.__executeAsyncValidators(asyncValidators, value);
        this.isPending = false;
        // Now finish the second (asynchronous) pass (including both sync and async results)
        this.__finishValidationPass({
          syncValidationResult: this.__syncValidationResult,
          asyncValidationResult: this.__asyncValidationResult,
          metaValidators,
        });
        this.__validateCompleteResolve?.(true);
      } else {
        this.__validateCompleteResolve?.(true);
      }
    }
@desc step a1-3 + b (as explained in `validate()`)