Function runFieldLevelValidation

src/FinalForm.ts:346–398

(
    field: InternalFieldState,
    setError: (error: any | undefined) => void,
  )

  };

  const runFieldLevelValidation = (
    field: InternalFieldState,
    setError: (error: any | undefined) => void,
  ): Promise<any>[] => {
    const promises = [];
    const validators = getValidators(field);
    if (validators.length) {
      let error: any;
      // Bump validation key once per validation run (all validators share same key)
      field.asyncValidationKey++;
      const fieldValidationKey = field.asyncValidationKey;
      validators.forEach((validator) => {
        const errorOrPromise = validator(
          getIn(state.formState.values as object, field.name),
          state.formState.values,
          validator.length === 0 || validator.length === 3
            ? publishFieldState(state.formState, field)
            : undefined,
        );

        if (errorOrPromise && isPromise(errorOrPromise)) {
          // Track async validation with per-field counter
          field.asyncValidationCount++;
          field.validating = true;
          const fieldInstanceId = field.instanceId; // Capture stable instance ID
          const promise = errorOrPromise.then((error) => {
            const currentField = state.fields[field.name];
            // Only mutate if the field instance is still the same (check stable instanceId)
            if (currentField && currentField.instanceId === fieldInstanceId) {
              // Decrement async validation counter (guard against underflow)
              if (currentField.asyncValidationCount > 0) {
                currentField.asyncValidationCount--;
              }
              // Only set validating=false if all async validations for this field are complete
              if (currentField.asyncValidationCount === 0) {
                currentField.validating = false;
              }
              // Only apply error if this validation hasn't been superseded by a newer one
              if (fieldValidationKey === currentField.asyncValidationKey) {
                setError(error);
              }
            }
          }); // errors must be resolved, not rejected
          promises.push(promise);
        } else if (!error) {
          // first registered validator wins
          error = errorOrPromise;
        }
      });
      setError(error);
    }
    return promises;
  };

  const runValidation = (fieldChanged: string | undefined, callback: () => void) => {
    if (validationPaused) {