url = "file://" + url;
        } else if (url.startsWith("file:") && !url.startsWith("file://")) {
            url = "file://" + url.substring("file:".length());
        }

        // So now we have an url of the form file://<path>

        // We want to eliminate any relative path nonsense and lock down the path so we
        // need to fully resolve it before any submodules use the path. This can happen

    }

    static class DefaultSession extends AbstractSession {

        private final Map<String, String> systemProperties;
        private Instant startTime = Instant.now();

        DefaultSession(RepositorySystemSession session, RepositorySystem repositorySystem, Lookup lookup) {
            this(session, repositorySystem, Collections.emptyList(), null, lookup);
        }

    <<NOTE:>> Do we want to fail when we cannot bind a mojo to the lifecycle
    because of offline/online status? That would probably indicate that the user
    was trying to do something they cannot succeed at for now...so we probably

  BasicComponentConfigurator.

* Other

  We may need to define a new lifecycle/phase to contextualize a mojo right
  before it's used, and reset it's state afterward. Up to now, the approach
  of most plexus components has been to avoid instance state like the plague.
  With the current parameter passing model of mojos, this will not be possible,

    }

    public boolean isActive() {
        return active;
    }

    public void enable() {
        active = true;

        // TODO if it was null, we really need to go find them now... or is this taken care of by the ordering?
        if (children != null) {
            for (ResolutionNode node : children) {
                node.enable();
            }
        }
    }

        // url normalization
        resultModel = modelUrlNormalizer.normalize(resultModel, request);

        result.setEffectiveModel(resultModel);

        // Now the fully interpolated model is available: reconfigure the resolver
        if (!resultModel.getRepositories().isEmpty()) {
            List<String> oldRepos = request.getModelRepositoryHolder().getRepositories().stream()

public class ArtifactResolutionRequest implements RepositoryRequest {
    private static final String LS = System.lineSeparator();

    private Artifact artifact;

    // Needs to go away
    // These are really overrides now, projects defining dependencies for a plugin that override what is
    // specified in the plugin itself.
    private Set<Artifact> artifactDependencies;

    private ArtifactRepository localRepository;

 We need to define what happens in the when things are not setup correctly

 o ~/.m2 directory does not exist
 o ~/.m2/maven.properties does not exist
 o if they once existed but now to do not exist

    <exportedPackage>jakarta.inject.*</exportedPackage>
    <exportedPackage>jakarta.annotation.*</exportedPackage>

    <!--
      | We may potentially want to export these, but right now I'm not sure that anything Guice specific needs
      | to be made available to plugin authors. If we find people are getting fancy and want to take advantage of

        MavenProject project = session.getCurrentProject();

        // Here we will actually not have any artifacts because the ProjectDependenciesResolver is not involved here. So
        // right now it's not valid to ask for artifacts unless plugins require the artifacts.

        project.getCompileClasspathElements();
    }

    @Test
    void testBuildFromModelSource() throws Exception {