docs: def init_argparser(self, argparser):
          """
          This should not be called with an external argparser as it will
          corrupt tracking data if forced.
          """
  
          def prepare_argparser():
              if argparser in self.argparser_details:
                  return False
              result = self.argparser_details[argparser] = ArgumentParserDetails(
                  {}, {}, {})
              return result
  
          def to_module_attr(ep):
              return '%s:%s' % (ep.module_name, '.'.join(ep.attrs))
  
          def register(name, runtime, entry_point):
              subparser = commands.add_parser(
                  name, help=inst.description,
              )
              # Have to specify this separately because otherwise the
              # subparser will not have a proper description when it is
              # invoked as the root.
              subparser.description = inst.description
  
              # Assign values for version reporting system
              setattr(subparser, ATTR_ROOT_PKG, getattr(
                  argparser, ATTR_ROOT_PKG, self.package_name))
              subp_info = []
              subp_info.extend(getattr(argparser, ATTR_INFO, []))
              subp_info.append((subparser.prog, entry_point.dist))
              setattr(subparser, ATTR_INFO, subp_info)
  
              try:
                  try:
                      runtime.init_argparser(subparser)
                  except RuntimeError as e:
                      # first attempt to filter out recursion errors; also if
                      # the stack frame isn't available the complaint about
                      # bad validation doesn't apply anyway.
                      frame = currentframe()
                      if (not frame or 'maximum recursion depth' not in str(
                              e.args)):
                          raise
  
                      if (not isinstance(runtime, Runtime) or (type(
                              runtime).entry_point_load_validated.__code__ is
                              Runtime.entry_point_load_validated.__code__)):
                          # welp, guess some other thing blew up then, or
                          # that the problem is definitely not caused by
                          # this runtime implementation.
                          # TODO figure out how to log this nicer via the
                          # self.log_debug_error without exploding the
                          # console like Megumin would have done.
                          raise
  
                      # assume the overridden method didn't do everything
                      # correctly then; would be great if there is a way
                      # to ensure that our thing would have been called.
                      cls = type(runtime)
                      logger.critical(
                          "Runtime subclass at entry_point '%s' has override "
                          "'entry_point_load_validated' without filtering out "
                          "its parent classes; this can be addressed by calling "
                          "super(%s.%s, self).entry_point_load_validated("
                          "entry_point) in its implementation, or simply don't "
                          "override that method to avoid infinite recursion.",
                          entry_point, cls.__module__, cls.__name__,
                      )
                      exc = RuntimeError(
                          "%r has an invalid 'entry_point_load_validated' "
                          "implementation: insufficient protection against "
                          "infinite recursion into self not provided" % runtime
                      )
                      # for Python 3 to not blow it up.
                      exc.__suppress_context__ = True
                      raise exc
              except Exception as e:
                  self.log_debug_error(
                      "cannot register entry_point '%s' from '%s' as a "
                      "subcommand to '%s': %s: %s",
                      entry_point, entry_point.dist, argparser.prog,
                      e.__class__.__name__, e
                  )
                  # this is where naughty things happen: will be poking at
                  # the parser internals to undo the damage that was done
                  # first, pop the choices_actions as a help was provided
                  commands._choices_actions.pop()
                  # then pop the name that was mapped.
                  commands._name_parser_map.pop(name)
              else:
                  # finally record the completely initialized subparser
                  # into the structure here if successful.
                  subparsers[name] = subparser
                  runtimes[name] = runtime
                  entry_points[name] = entry_point
  
          details = prepare_argparser()
          if not details:
              logger.debug(
                  'argparser %r has already been initialized against runner %r',
                  argparser, self,
              )
              return
          subparsers, runtimes, entry_points = details
  
          super(Runtime, self).init_argparser(argparser)
  
          commands = argparser.add_subparsers(
              dest=self.action_key, metavar='<command>')
          # Python 3.7 has required set to True, which is correct in most
          # cases but this disables the manual handling for cases where a
          # command was not provided; also this generates a useless error
          # message that simply states "<command> is required" and forces
          # the program to exit.  As the goal of this suite of classes is
          # to act as a helpful CLI front end, force required to be False
          # to keep our manual handling and management of subcommands.
          # Setting this as a property for compatibility with Python<3.7,
          # as only in Python>=3.7 the add_subparsers can accept required
          # as an argument.
          commands.required = False
  
          for entry_point in self.iter_entry_points():
              inst = self.entry_point_load_validated(entry_point)
              if not inst:
                  continue
  
              if entry_point.name in runtimes:
                  reg_ep = entry_points[entry_point.name]
                  reg_rt = runtimes[entry_point.name]
  
                  if reg_rt is inst:
                      # this is fine, multiple packages declared the same
                      # thing with the same name.
                      logger.debug(
                          "duplicated registration of command '%s' via entry "
                          "point '%s' ignored; registered '%s', confict '%s'",
                          entry_point.name, entry_point, reg_ep.dist,
                          entry_point.dist,
                      )
                      continue
  
                  logger.error(
                      "a calmjs runtime command named '%s' already registered.",
                      entry_point.name
                  )
                  logger.info("conflicting entry points are:")
                  logger.info(
                      "'%s' from '%s' (registered)", reg_ep, reg_ep.dist)
                  logger.info(
                      "'%s' from '%s' (conflict)", entry_point, entry_point.dist)
                  # Fall back name should work if the class/instances are
                  # stable.
                  name = to_module_attr(entry_point)
  
                  if name in runtimes:
                      # Maybe this is the third time this module is
                      # registered.  Test for its identity.
                      if runtimes[name] is not inst:
                          # Okay someone is having a fun time here mucking
                          # with data structures internal to here, likely
                          # (read hopefully) due to testing or random
                          # monkey patching (or module level reload).
                          logger.critical(
                              "'%s' is already registered but points to a "
                              "completely different instance; please try again "
                              "with verbose logging and note which packages are "
                              "reported as conflicted; alternatively this is a "
                              "forced situation where this Runtime instance has "
                              "been used or initialized improperly.",
                              name
                          )
                      else:
                          logger.debug(
                              "fallback command '%s' is already registered.",
                              name
                          )
                      continue
  
                  logger.error(
                      "falling back to using full instance path '%s' as command "
                      "name, also registering alias for registered command", name
                  )
                  register(to_module_attr(reg_ep), reg_rt, reg_ep)
              else:
                  name = entry_point.name
  
              register(name, inst, entry_point)