docs: public Set<EndpointHelper> determineEndpoints(Set<EndpointHelper> annotatedEndpointHelpers,
                                                    Set<EndpointHelper> programmaticEndpointHelpers,
                                                    Set<Class<? extends ServerApplicationConfig>> serverAppConfigs) {
  
          Set<Class<?>> annotatedEndpointClasses = new HashSet<Class<?>>();
          HashMap<Class<?>, EndpointHelper> endpointMap = new HashMap<Class<?>, EndpointHelper>();
          Set<EndpointHelper> returnHelpers = new HashSet<EndpointHelper>();
  
          Set<Class<? extends Endpoint>> programmaticEndpointClasses = new HashSet<Class<? extends Endpoint>>();
          Set<Class<? extends ServerEndpointConfig>> endpointConfigs = new HashSet<Class<? extends ServerEndpointConfig>>();
  
          // no ServerApplicationConfig objects, allow all the annotated endpoints through, but no programmatic endpoints
          if (serverAppConfigs.size() == 0) {
              return annotatedEndpointHelpers;
          }
  
          // first look at annotated Endpoints
          // build the set of annotated Endpoints to look through, also need a map of endpoints to helpers for later indexing
          for (EndpointHelper helper : annotatedEndpointHelpers) {
              Class<?> c = helper.getEndpointClass();
              annotatedEndpointClasses.add(c);
              // need a map of EndpointClass to EndpointHelper to index into later
              endpointMap.put(c, helper);
          }
  
          // if we have annotated endpoints, then pass the set of them to each user config object
          if (annotatedEndpointClasses.size() > 0) {
              for (Class<? extends ServerApplicationConfig> configClass : serverAppConfigs) {
                  ServerApplicationConfig config = null;
                  try {
                      config = configClass.newInstance();
                  } catch (IllegalAccessException e) {
                      // allow instrumented FFDC to be used here
                  } catch (InstantiationException e) {
                      // allow instrumented FFDC to be used here
                  }
  
                  if (config != null) {
                      // get from the user config object the configs for which endpoints to use
                      Set<Class<?>> annotatedEnpointsToUse = config.getAnnotatedEndpointClasses(annotatedEndpointClasses);
  
                      // for each returned endpoint class, find the endpoint helper and put it into the return set
                      for (Class<?> c : annotatedEnpointsToUse) {
                          EndpointHelper helper = endpointMap.get(c);
                          if (tc.isDebugEnabled()) {
                              Tr.debug(tc, "will use annoated endpoint of: " + c);
                          }
                          returnHelpers.add(helper);
                      }
                  }
              }
          }
  
          // now do the same with programmatic configs.
          // first look at programmatic Endpoints
          // build the set of programmatic Endpoints to look through, also need a map of endpoints to helpers for later indexing
          endpointMap.clear();
          for (EndpointHelper helper : programmaticEndpointHelpers) {
              Class<?> c = helper.getEndpointClass();
              programmaticEndpointClasses.add((Class<? extends Endpoint>) c);
              // need a map of EndpointClass to EndpointHelper to index into later
              endpointMap.put(c, helper);
          }
  
          // if we have programmatic endpoints, then pass the set of them to each user config object
          if (programmaticEndpointClasses.size() > 0) {
              for (Class<? extends ServerApplicationConfig> configClass : serverAppConfigs) {
                  ServerApplicationConfig config = null;
                  try {
                      config = configClass.newInstance();
                  } catch (IllegalAccessException e) {
                      // allow instrumented FFDC to be used here
                  } catch (InstantiationException e) {
                      // allow instrumented FFDC to be used here
                  }
  
                  if (config != null) {
                      // get from the user config object which of the programmatic endpoints to use
                      Set<ServerEndpointConfig> programmaticEnpointConfigsToUse = config.getEndpointConfigs(programmaticEndpointClasses);
                      if (tc.isDebugEnabled()) {
                          Tr.debug(tc, "programmaticEnpointConfigsToUse: " + programmaticEnpointConfigsToUse);
                      }
                      if (programmaticEnpointConfigsToUse != null) {
                          // for each returned endpoint config class, create the endpoint helper and put it into the return set
                          for (ServerEndpointConfig endpointConfig : programmaticEnpointConfigsToUse) {
  
                              Class<?> endpoint = endpointConfig.getEndpointClass();
                              // Question: is this really how we should map the endpoint from the user config, to the endpoint we scanned earlier?
                              // You can map a single endpoint to multiple URIs/configurators, etc, so creating new here.
                              if (tc.isDebugEnabled()) {
                                  Tr.debug(tc, "endpointConfig class: " + endpoint.getName());
                              }
                              EndpointHelper scannedHelper = endpointMap.get(endpoint);
                              if (scannedHelper != null) {
                                  EndpointHelper newHelper = new EndpointHelper();
                                  newHelper.setEndpointClass(scannedHelper.getEndpointClass());
  
                                  newHelper.setServerEndpointConfig(endpointConfig);
                                  if (tc.isDebugEnabled()) {
                                      Tr.debug(tc, "will use programmatic endpoint of: " + endpoint);
                                  }
                                  returnHelpers.add(newHelper);
                              }
                          }
                      }
                  }
              }
          }
  
          return returnHelpers;
      }