}

        try {
            metadata.storeInLocalRepository(localRepository, deploymentRepository);
        } catch (RepositoryMetadataStoreException e) {
            throw new RepositoryMetadataDeploymentException("Error installing metadata: " + e.getMessage(), e);
        }

        try {
            wagonManager.putArtifactMetadata(file, metadata, deploymentRepository);

        try {
            transporter.put(putTask);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void putBytes(byte[] source, URI relativeTarget) {
        requireNonNull(source, "source is null");
        try {
            Path tempPath = null;
            try {

        ExtensionDescriptor extensionDescriptor = null;

        if (extensionJar.isFile()) {
            try (JarFile pluginJar = new JarFile(extensionJar, false)) {
                ZipEntry pluginDescriptorEntry = pluginJar.getEntry(getExtensionDescriptorLocation());

                if (pluginDescriptorEntry != null) {
                    try (InputStream is = pluginJar.getInputStream(pluginDescriptorEntry)) {

    public MavenProject getProject() {
        return project;
    }

    @Override
    public void buildExtensionsAssembled(ModelBuildingEvent event) {
        Model model = new Model(event.model());

        try {
            pluginRepositories = projectBuildingHelper.createArtifactRepositories(
                    model.getPluginRepositories(), pluginRepositories, projectBuildingRequest);
        } catch (Exception e) {

            List<ArtifactRepository> repos = new ArrayList<>(repositories.size());

            for (Object repository : repositories) {
                if (repository instanceof Repository) {
                    try {
                        ArtifactRepository repo = repositorySystem.buildArtifactRepository((Repository) repository);
                        repositorySystem.injectMirror(request.getRepositorySession(), Arrays.asList(repo));

            TreeSet<Version> snapshots = new TreeSet<>(Collections.reverseOrder());

            for (String ver : versions.versions.keySet()) {
                try {
                    Version v = versionScheme.parseVersion(ver);

                    if (ver.endsWith("-SNAPSHOT")) {
                        snapshots.add(v);
                    } else {

            ProjectBuildList segmentProjectBuilds = projectBuilds.getByTaskSegment(taskSegment);
            Map<MavenProject, ProjectSegment> projectBuildMap = projectBuilds.selectSegment(taskSegment);
            try {
                ConcurrencyDependencyGraph analyzer =
                        new ConcurrencyDependencyGraph(segmentProjectBuilds, session.getProjectDependencyGraph());
                multiThreadedProjectTaskSegmentBuild(

    }

    @Override
    public ModelSource resolveModel(Session session, String groupId, String artifactId, String version)
            throws ModelResolverException {
        try {
            session = session.withRemoteRepositories(repositories.stream()
                    .map(InternalSession.from(session)::getRemoteRepository)
                    .toList());

        LinkedHashSet<String> visited = new LinkedHashSet<>();
        for (Artifact a = request.getArtifact(); ; ) {
            Artifact pomArtifact = ArtifactDescriptorUtils.toPomArtifactUnconditionally(a);
            try {
                VersionRequest versionRequest =
                        new VersionRequest(a, request.getRepositories(), request.getRequestContext());
                versionRequest.setTrace(trace);

        DefaultClassRealmManager classRealmManager;
        ClassRealm classRealm;

        InOrder verifier = inOrder(logger);

        PlexusContainer container = new DefaultPlexusContainer();

        try (MockedStatic<LoggerFactory> mockedLoggerFactory = Mockito.mockStatic(LoggerFactory.class)) {
            mockedLoggerFactory
                    .when(() -> LoggerFactory.getLogger(DefaultClassRealmManager.class))