Artifact pomArtifact = ArtifactDescriptorUtils.toPomArtifactUnconditionally(a);
            try {
                VersionRequest versionRequest =
                        new VersionRequest(a, request.getRepositories(), request.getRequestContext());
                versionRequest.setTrace(trace);
                VersionResult versionResult = versionResolver.resolveVersion(session, versionRequest);

        List<MetadataRequest> requests = new ArrayList<>();

        requests.add(new MetadataRequest(metadata, null, REPOSITORY_CONTEXT).setTrace(trace));

        for (RemoteRepository repository : request.getRepositories()) {
            requests.add(new MetadataRequest(metadata, repository, REPOSITORY_CONTEXT).setTrace(trace));
        }

        assertEquals(p.getActivation().getPackaging(), clone.getActivation().getPackaging());
        assertEquals(p.getProperties(), clone.getProperties());
        assertEquals(p.getRepositories().size(), clone.getRepositories().size());
        // TODO deep compare the lists
        assertEquals(
                p.getPluginRepositories().size(), clone.getPluginRepositories().size());
        // TODO deep compare the lists

            if (!model.getRepositories().isEmpty()) {
                List<String> oldRepos = request.getModelRepositoryHolder().getRepositories().stream()
                        .map(Object::toString)
                        .toList();
                request.getModelRepositoryHolder().merge(model.getRepositories(), false);

    public void populateResult(InternalSession session, ArtifactDescriptorResult result, Model model) {
        ArtifactTypeRegistry stereotypes = session.getSession().getArtifactTypeRegistry();

        for (Repository r : model.getRepositories()) {
            result.addRepository(session.toRepository(
                    session.getService(RepositoryFactory.class).createRemote(r)));
        }

        List<MetadataRequest> metadataRequests =
                new ArrayList<>(request.getRepositories().size());

        metadataRequests.add(new MetadataRequest(metadata, null, request.getRequestContext()));

        for (RemoteRepository repository : request.getRepositories()) {
            MetadataRequest metadataRequest = new MetadataRequest(metadata, repository, request.getRequestContext());

                        RemoteRepository r = (RemoteRepository) result.getRepository();
                        subRequest.setRepositories(Collections.singletonList(r));
                    } else {
                        subRequest.setRepositories(request.getRepositories());
                    }
                    VersionResult subResult = resolveVersion(session, subRequest);

                        .repositories(settings.getRepositories())
                        .pluginRepositories(settings.getPluginRepositories())
                        .build());
        RepositoryFactory repositoryFactory = session.getService(RepositoryFactory.class);
        List<RemoteRepository> repositories = profile.getRepositories().stream()
                .map(repositoryFactory::createRemote)

            repositories = repositoryFactory.aggregate(session, pomRepositories, externalRepositories, false);
        }
    }

    @Override
    public List<org.apache.maven.api.RemoteRepository> getRepositories() {
        return List.copyOf(repositories);
    }

    @Override
    public ModelRepositoryHolder copy() {
        return new DefaultModelRepositoryHolder(this);
    }

        // build the regular repos after extensions are loaded to allow for custom layouts
        try {
            remoteRepositories = projectBuildingHelper.createArtifactRepositories(
                    model.getRepositories(), remoteRepositories, projectBuildingRequest);
        } catch (Exception e) {
            event.problems()
                    .add(
                            BuilderProblem.Severity.ERROR,