@Nonnull
        public ArtifactInstallerRequestBuilder session(@Nonnull Session session) {
            this.session = session;
            return this;
        }

        @Nonnull
        public ArtifactInstallerRequestBuilder trace(RequestTrace trace) {
            this.trace = trace;
            return this;
        }

        @Nonnull

     */
    record Entry(
            @Nonnull Level level,
            @Nonnull String message,
            @Nullable Throwable error) {}

    /**
     * If this is an accumulating log, it will "drain" this instance. It returns the accumulated log entries, and
     * also "resets" this instance to empty (initial) state.
     */
    @Nonnull
    default List<Entry> drain() {
        return List.of();

 * @since 4.0.0
 */
public interface ExtensibleEnumRegistry<T extends ExtensibleEnum> extends Service {
    @Nonnull
    Optional<T> lookup(@Nonnull String id);

    @Nonnull
    default T require(@Nonnull String id) {
        return lookup(id).orElseThrow(() -> new IllegalArgumentException("Unknown extensible enum value '" + id + "'"));
    }

     * @return The version result, never {@code null}.
     * @throws VersionResolverException If the metaversion could not be resolved.
     */
    @Nonnull
    default VersionResolverResult resolve(@Nonnull Session session, @Nonnull ArtifactCoordinates artifactCoordinates)
            throws VersionResolverException {
        return resolve(VersionResolverRequest.build(session, artifactCoordinates));
    }

        return project;
    }

    @Nonnull
    @Override
    public String getGroupId() {
        return project.getGroupId();
    }

    @Nonnull
    @Override
    public String getArtifactId() {
        return project.getArtifactId();
    }

    @Nonnull
    @Override
    public String getVersion() {
        return project.getVersion();
    }

    @Nonnull
    @Override

     */
    @Nonnull
    Artifact create(@Nonnull ArtifactFactoryRequest request);

    @Nonnull
    default Artifact create(
            @Nonnull Session session, String groupId, String artifactId, String version, String extension) {
        return create(ArtifactFactoryRequest.build(session, groupId, artifactId, version, extension));
    }

    @Nonnull
    default Artifact create(

    @Nonnull
    private final InternalMavenSession session;

    private final Map<String, Path> paths = new ConcurrentHashMap<>();

    @Inject
    public DefaultArtifactManager(@Nonnull InternalMavenSession session) {
        this.session = session;
    }

    @Nonnull
    @Override
    public Optional<Path> getPath(@Nonnull Artifact artifact) {

        return builder(requireNonNull(request, "request cannot be null"))
                .source(requireNonNull(source, "source cannot be null"))
                .build();
    }

    @Nonnull
    static ModelBuilderRequest build(@Nonnull Session session, @Nonnull ModelSource source) {
        return builder()

     */
    @Nonnull
    Optional<Source> getInstallationToolchainsSource();

    /**
     * Gets the user Toolchains source.
     *
     * @return the user Toolchains source or {@code null} if none
     */
    @Nonnull
    Optional<Source> getUserToolchainsSource();

    @Nonnull
    static ToolchainsBuilderRequest build(
            @Nonnull ProtoSession session,

     * @throws DependencyResolverException
     */
    List<Node> flatten(@Nonnull Session session, @Nonnull Node node, @Nullable PathScope scope)
            throws DependencyResolverException;

    @Nonnull
    default DependencyResolverResult flatten(
            @Nonnull Session session, @Nonnull Project project, @Nonnull PathScope scope) {
        return flatten(DependencyResolverRequest.build(