* phase they want to execute and we can easily determine what lifecycle we need to run.
     *
     * @return A map of lifecycles, indexed on id
     */
    public Map<String, Lifecycle> getPhaseToLifecycleMap() {
        // If people are going to make their own lifecycles then we need to tell people how to namespace them correctly
        // so that they don't interfere with internally defined lifecycles.

    protected String component() {
        return "deployer";
    }

    @Test
    void testArtifactInstallation() throws Exception {
        sessionScope.enter();
        try {
            sessionScope.seed(MavenSession.class, mock(MavenSession.class));

            String artifactBasedir = new File(getBasedir(), "src/test/resources/artifact-install").getAbsolutePath();

        assertNotSame(bean.myBean.getClass(), MySessionScopedBean.class);

        assertThrows(OutOfScopeException.class, () -> bean.myBean.getSession());

        sessionScope.enter();
        sessionScope.seed(Session.class, this.session);
        assertNotNull(bean.myBean.getSession());
        assertNotNull(bean.myBean.getAnotherBean());
        assertSame(bean.myBean.getAnotherBean().getClass(), AnotherBean.class);

import org.apache.maven.api.settings.Settings;

/**
 * The session to install / deploy / resolve artifacts and dependencies.
 *
 * TODO: move the remote repositories in the requests (plugins will need to access this list somehow)
 * TODO: add request trace so that requests can be linked together and through the resolver
 * TODO: add a Request interface holding session + parent request
 *
 * @since 4.0.0
 */

                .withRemoteRepositories(Collections.singletonList(remoteRepository));
        InternalSession.associate(rss, this.session);
        sessionScope.enter();
        sessionScope.seed(InternalMavenSession.class, InternalMavenSession.from(this.session));
    }

    private Project project(Artifact artifact) {
        return session.getService(ProjectBuilder.class)

    /**
     * The path separator.
     */
    private static final String PATH_SEP = System.getProperty("path.separator");

    static {
        // Those two public constants are initialized here, as they need all the private constants
        // above to be initialized first, but the code style imposes the public constants to be
        // defined above the private ones...
        OS_FAMILY = getOsFamily();

            File outputDirectory = new File(project.getBuild().getOutputDirectory());

            // Check if the project is being built during this session, and if we can expect any output.
            // There is no need to check if the build has created any outputs, see MNG-2222.
            boolean projectCompiledDuringThisSession =
                    project.hasLifecyclePhase("compile") && COMPILE_PHASE_TYPES.contains(type);

                // invalid version range, so drop back to resolution from the repository
                return null;
            }
        }

        //
        // Here we just need to know that a version is fine to use but this validation we can do in our workspace
        // resolver.
        //

        /*

  |   be done with a regex, but we need inter-field validation and rules which could be
  |   dealt with by something like drools.
  |
  | o i18n: would be good to be able to have names/descriptions/specifications
  |   in as many languages as possible. (see MNG-3626)
  |
  | o annotation mechanism so that changes to the model can be accurately tracked.
  |

    }

    private void deepCopy(MavenProject project) {
        // disown the parent

        // copy fields
        file = project.file;
        basedir = project.basedir;

        // don't need a deep copy, they don't get modified or added/removed to/from - but make them unmodifiable to be
        // sure!
        if (project.getDependencyArtifacts() != null) {