docs: def generate_handler_sourcepath(
              self, toolchain, spec, loaderplugin_sourcepath):
          """
          The default implementation is a recursive lookup method, which
          subclasses may make use of.
  
          Subclasses must implement this to return a mapping of modnames
          the the absolute path of the desired sourcefiles.  Example:
  
          return {
              'text': '/tmp/src/example_module/text/index.js',
              'json': '/tmp/src/example_module/json/index.js',
          }
  
          Subclasses of this implementation must accept the same
          arguments, and they should invoke this implementation via super
          and merge its results (e.g. using dict.update) with one provided
          by this one.  Also, this implementation depends on a correct
          unwrap implementation for the loaderplugin at hand, if required.
          """
  
          # since the loaderplugin_sourcepath values is the complete
          # modpath with the loader plugin, the values must be stripped
          # before making use of the filtering helper function for
          # grouping the inner mappings
          fake_spec = {}
          registry = spec.get(CALMJS_LOADERPLUGIN_REGISTRY)
          if registry:
              fake_spec[CALMJS_LOADERPLUGIN_REGISTRY] = registry
          spec_update_sourcepath_filter_loaderplugins(fake_spec, {
              self.unwrap(k): v
              for k, v in loaderplugin_sourcepath.items()
          }, 'current', 'nested')
          result = {}
          for plugin_name, sourcepath in fake_spec['nested'].items():
              if sourcepath == loaderplugin_sourcepath:
                  logger.warning(
                      "loaderplugin '%s' extracted same sourcepath of while "
                      "locating chain loaders: %s; skipping",
                      self.name, sourcepath
                  )
                  continue
              plugin = self.registry.get_record(plugin_name)
              if not plugin:
                  logger.warning(
                      "loaderplugin '%s' from registry '%s' cannot find "
                      "sibling loaderplugin handler for '%s'; processing "
                      "may fail for the following nested/chained sources: "
                      "%s",
                      self.name, self.registry.registry_name, plugin_name,
                      sourcepath,
                  )
                  continue
              result.update(plugin.generate_handler_sourcepath(
                  toolchain, spec, sourcepath))
          return result