function createSyncResult (
  rule,
  model,
  $dirty,
  { $lazy, $rewardEarly },
  $response,
  instance,
  siblingState,
  $lastInvalidState
) {
  const $unwatch = () => ({})
  const $invalid = computed(() => {
    if (
      // return early if $lazy mode and not touched
      ($lazy && !$dirty.value) ||
      // If $rewardEarly mode is ON and last invalid was false (no error), return it.
      // If we want to invalidate, we just flip the last state to true, causing the computed to run again
      ($rewardEarly && !$lastInvalidState.value)) {
      return false
    }
    let returnValue = true
    try {
      const result = callRule(rule, model, siblingState, instance)
      $response.value = result
      returnValue = normalizeValidatorResponse(result)
    } catch (err) {
      $response.value = err
    }
    return returnValue
  })
  return { $unwatch, $invalid }
}
Returns the result of a sync validator
@param {Validator} rule
@param {Ref<*>} model
@param {Ref<Boolean>} $dirty
@param {GlobalConfig} config
@param {Boolean} config.$lazy
@param {Ref<*>} $response
@param {VueInstance} instance
@param {Object} siblingState
@param {Ref<Boolean>} $lastInvalidState
@return {{$unwatch: (function(): {}), $invalid: ComputedRef<boolean>}}