loadFromMap = async (readPowers, compartmentMap, options = {}) => {
  const {
    searchSuffixes = undefined,
    parserForLanguage: parserForLanguageOption = {},
    Compartment: LoadCompartmentOption = Compartment,
  } = options;

  const parserForLanguage = freeze(
    assign(create(null), parserForLanguageOption),
  );

  /**
   * Object containing options and read powers that fulfills all requirements
   * for creation of a {@link ImportNowHookMaker}, thus enabling dynamic import.
   *
   * @typedef SyncBehavior
   * @property {ReadNowPowers} readPowers
   * @property {SyncImportLocationOptions} options
   * @property {'SYNC'} type
   */

  /**
   * Object containing options and read powers which is incompatible with
   * creation of an {@link ImportNowHookMaker}, thus disabling dynamic import.
   *
   * @typedef AsyncBehavior
   * @property {ReadFn|ReadPowers} readPowers
   * @property {ImportLocationOptions} options
   * @property {'ASYNC'} type
   */

  /**
   * When we must control flow based on _n_ type guards consdering _n_ discrete
   * values, grouping the values into an object, then leveraging a discriminated
   * union (the `type` property) is one way to approach the problem.
   */
  const behavior =
    isReadNowPowers(readPowers) && isSyncOptions(options)
      ? /** @type {SyncBehavior} */ ({
          readPowers,
          options: options || {},
          type: 'SYNC',
        })
      : /** @type {AsyncBehavior} */ ({
          readPowers,
          options: options || {},
          type: 'ASYNC',
        });

  const {
    entry: { compartment: entryCompartmentName, module: entryModuleSpecifier },
  } = compartmentMap;

  /** @type {ExecuteFn} */
  const execute = async (options = {}) => {
    const {
      globals,
      modules,
      transforms,
      __shimTransforms__,
      Compartment: CompartmentOption = LoadCompartmentOption,
      __native__,
      importHook: exitModuleImportHook,
    } = options;
    const compartmentExitModuleImportHook = exitModuleImportHookMaker({
      modules,
      exitModuleImportHook,
      entryCompartmentName,
    });
    const makeImportHook = makeImportHookMaker(
      readPowers,
      entryCompartmentName,
      {
        compartmentDescriptors: compartmentMap.compartments,
        searchSuffixes,
        archiveOnly: false,
        entryCompartmentName,
        entryModuleSpecifier,
        importHook: compartmentExitModuleImportHook,
      },
    );

    /** @type {ImportNowHookMaker | undefined} */
    let makeImportNowHook;

    /** @type {Compartment} */
    let compartment;
    /** @type {Promise<void>} */
    let pendingJobsPromise;

    if (behavior.type === 'SYNC') {
      const { importNowHook: exitModuleImportNowHook, syncModuleTransforms } =
        behavior.options;
      makeImportNowHook = makeImportNowHookMaker(
        /** @type {ReadNowPowers} */ (readPowers),
        entryCompartmentName,
        {
          entryCompartmentName,
          entryModuleSpecifier,
          compartmentDescriptors: compartmentMap.compartments,
          searchSuffixes,
          importNowHook: exitModuleImportNowHook,
        },
      );
      ({ compartment, pendingJobsPromise } = link(compartmentMap, {
        makeImportHook,
        makeImportNowHook,
        parserForLanguage,
        globals,
        transforms,
        syncModuleTransforms,
        __shimTransforms__,
        Compartment: CompartmentOption,
        __native__,
      }));
    } else {
      // sync module transforms are allowed, because they are "compatible"
      // with async module transforms (not vice-versa)
      const { moduleTransforms, syncModuleTransforms } = behavior.options;
      ({ compartment, pendingJobsPromise } = link(compartmentMap, {
        makeImportHook,
        parserForLanguage,
        globals,
        transforms,
        moduleTransforms,
        syncModuleTransforms,
        __shimTransforms__,
        Compartment: CompartmentOption,
        __native__,
      }));
    }

    await pendingJobsPromise;

    return compartment.import(entryModuleSpecifier);
  };

  return { import: execute };
}
@param {ReadFn|ReadPowers|ReadNowPowers} readPowers
@param {CompartmentMapDescriptor} compartmentMap
@param {ImportLocationOptions} [options]
@returns {Promise<Application>}