}

        CacheRecord record = new CacheRecord(extensionRealm, extensionDescriptor, artifacts);

        cache.put(key, record);

        return record;
    }

    public void flush() {
        for (CacheRecord record : cache.values()) {
            ClassRealm realm = record.getRealm();
            try {

            final MavenSession rootSession,
            final MavenSession currentSession,
            final MavenProject mavenProject,
            Throwable t,
            final long buildStartTime) {
        // record the error and mark the project as failed
        long buildEndTime = System.currentTimeMillis();
        buildContext.getResult().addException(t);

            Object obj = cache.get(session, cacheKey);
            if (obj instanceof Record) {
                Record record = (Record) obj;
                result.setVersion(record.version);
                result.setRepository(
                        getRepository(session, request.getRepositories(), record.repoClass, record.repoId));
                return result;
            }
        }

        Metadata metadata;

                extensionArtifactFilter = new ExclusionsDependencyFilter(exclusions);
            }

            record = projectRealmCache.put(projectRealmKey, projectRealm, extensionArtifactFilter);
        }

        projectRealmCache.register(project, projectRealmKey, record);

        return record;
    }

    public void selectProjectRealm(MavenProject project) {

    /**
     * Registers the specified cache record for usage with the given project. Integrators can use the information
     * collected from this method in combination with a custom cache implementation to dispose unused records from the
     * cache.
     *
     * @param project The project that employs the plugin realm, must not be {@code null}.
     * @param record The cache record being used for the project, must not be {@code null}.
     */

    /**
     * Registers the specified cache record for usage with the given project. Integrators can use the information
     * collected from this method in combination with a custom cache implementation to dispose unused records from the
     * cache.
     *
     * @param project The project that employs the plugin realm, must not be {@code null}.
     * @param record The cache record being used for the project, must not be {@code null}.
     */

            throw new UnresolvableModelException(e.getMessage(), groupId, artifactId, version, e);
        }

        return new ArtifactModelSource(pomArtifact.getFile(), groupId, artifactId, version);
    }

    record Result(ModelSource source, Parent parent, Exception e) {}

    @Override
    public ModelSource resolveModel(final Parent parent, AtomicReference<Parent> modified)
            throws UnresolvableModelException {

        //        defaultSession.getService(RepositoryFactory.class).createRemote()
        //        return defaultSession;
    }

    static class UnsupportedInStandaloneModeException extends MavenException {}

    record DumbPackaging(String id, Type type, Map<String, PluginContainer> plugins) implements Packaging {}

        if (event.request().isProcessPlugins()) {
            try {
                ProjectRealmCache.CacheRecord record =
                        projectBuildingHelper.createProjectRealm(project, model, projectBuildingRequest);

                project.setClassRealm(record.getRealm());
                project.setExtensionDependencyFilter(record.getExtensionArtifactFilter());

     * User property for reverse dependency tree. If enabled, Maven will record ".tracking" directory into local
     * repository with "reverse dependency tree", essentially explaining WHY given artifact is present in local
     * repository.
     * Default: {@code false}, will not record anything.
     *
     * @since 3.9.0
     */
    private static final String MAVEN_REPO_LOCAL_RECORD_REVERSE_TREE = "maven.repo.local.recordReverseTree";

    /**