try {
            session = session.withRemoteRepositories(repositories.stream()
                    .map(InternalSession.from(session)::getRemoteRepository)
                    .toList());
            Map.Entry<org.apache.maven.api.Artifact, Path> resolved =
                    session.resolveArtifact(session.createArtifactCoordinate(groupId, artifactId, version, "pom"));

        nl.addAll(l);
        nl.add(t);
        return nl;
    }

    @Override
    public List<String> computePhases(Lifecycle lifecycle) {
        return lifecycle.phases().stream().map(Lifecycle.Phase::name).toList();
    }

    static class LifecycleWrapperProvider implements LifecycleProvider {
        private final Map<String, org.apache.maven.lifecycle.Lifecycle> lifecycles;

        @Inject

        this.attributes = this.node.getAttributes().entrySet().stream()
                .filter(a -> a.getKey().equals(qname.getName()) || "*".equals(qname.getName()))
                .collect(Collectors.toList());
    }

    public NodePointer getNodePointer() {
        if (position == 0) {
            setPosition(1);
        }
        return (attribute == null) ? null : new Xpp3DomAttributePointer(parent, attribute);

     */
    public ProjectBuildList getByTaskSegment(TaskSegment taskSegment) {
        return new ProjectBuildList(
                items.stream().filter(pb -> taskSegment == pb.getTaskSegment()).collect(Collectors.toList()));
    }

    public Map<MavenProject, ProjectSegment> selectSegment(TaskSegment taskSegment) {
        return items.stream()
                .filter(pb -> taskSegment == pb.getTaskSegment())

        List<ArtifactCoordinate> coordinates = nodes.stream()
                .map(Node::getDependency)
                .filter(Objects::nonNull)
                .map(Artifact::toCoordinate)
                .collect(Collectors.toList());
        Map<Artifact, Path> artifacts = session.resolveArtifacts(coordinates);
        DefaultDependencyResolverResult result = new DefaultDependencyResolverResult(

                                    .plugins(lf.phases().stream()
                                            .flatMap(phase -> phase.plugins().stream())
                                            .toList())
                                    .build()));
            Map<Plugin, Plugin> allPlugins = new LinkedHashMap<>();

        ArtifactCoordinateFactory acf = getService(ArtifactCoordinateFactory.class);
        List<ArtifactCoordinate> coords =
                Arrays.stream(artifacts).map(a -> acf.create(this, a)).collect(Collectors.toList());
        return resolveArtifacts(coords);
    }

    /**
     * Shortcut for {@code getService(ArtifactInstaller.class).install(...)}
     *

                        // ignore
                        e.printStackTrace();
                    }
                    List<Supplier<Object>> list =
                            res3.stream().map(this::compile).collect(Collectors.toList());
                    //noinspection unchecked
                    return () -> (Q) list(list);
                }
                if (key.getRawType() == Map.class) {
                    Key<?> k = key.getTypeParameter(0);

        return projectIds.stream()
                .map(projects::get)
                .sorted(Comparator.comparingInt(order::get))
                .collect(Collectors.toList());
    }

    @Override
    public String toString() {
        return sorter.getSortedProjects().toString();
    }

                .values()
                .stream()
                .map(MavenProject::getVersion)
                .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
        if (!versions.isEmpty()) {
            return versions;
        }
        return getAllProjects()
                .getOrDefault(artifact.getGroupId(), Collections.emptyMap())