26.1.2 RB 1

Co-authored-by: LexManos <[email protected]>
Co-authored-by: Jonathing <[email protected]>

.github/ISSUE_TEMPLATE/feature_request.md

@@ -10,4 +10,4 @@ assignees: ''
 <!-- Please note, feature requests that are submitted as GitHub issues here are rarely implemented. -->
 <!-- If you'd like to see something in Forge, you should be ready to implement it as a PR. -->
 <!-- If you're not sure, open a Draft PR or discuss it in the Discord server. -->
-<!-- Discord: https://discord.gg/UvedJ9m -->
+<!-- Discord: https://discord..minecraftforge.net/ -->

.github/ISSUE_TEMPLATE/issue_report.md

@@ -11,6 +11,7 @@ assignees: ''
 
 <!-- For support with crashes and issues, please create a post on the forum instead: -->
 <!-- https://www.minecraftforge.net/forum/forum/18-support-bug-reports/ -->
+<!-- You can also use the discord for support, https://discord.minecraftforge.net/ -->
 
 **Minecraft Version:** {Minecraft version}
 

.github/workflows/publish.yml

@@ -0,0 +1,28 @@
+name: Publish
+
+on:
+  push:
+    branches: [ '26.1.2' ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    uses: MinecraftForge/SharedActions/.github/workflows/gradle.yml@main
+    with:
+      java: 21
+      gradle_setup: './gradlew setup'
+      gradle_tasks: 'build publish'
+      artifact_name: 'forge'
+    secrets:
+      DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}
+      PROMOTE_ARTIFACT_WEBHOOK: ${{ secrets.PROMOTE_ARTIFACT_WEBHOOK }}
+      PROMOTE_ARTIFACT_USERNAME: ${{ secrets.PROMOTE_ARTIFACT_USERNAME }}
+      PROMOTE_ARTIFACT_PASSWORD: ${{ secrets.PROMOTE_ARTIFACT_PASSWORD }}
+      MAVEN_USER: ${{ secrets.MAVEN_USER }}
+      MAVEN_PASSWORD: ${{ secrets.MAVEN_PASSWORD }}
+      SIGN_KEY_ALIAS: ${{ secrets.SIGN_KEY_ALIAS }}
+      SIGN_KEY_PASSWORD: ${{ secrets.SIGN_KEY_PASSWORD }}
+      SIGN_KEYSTORE_PASSWORD: ${{ secrets.SIGN_KEYSTORE_PASSWORD }}
+      SIGN_KEYSTORE_DATA: ${{ secrets.SIGN_KEYSTORE_DATA }}

.github/workflows/pull_request_review.yml

@@ -7,7 +7,7 @@ jobs:
     name: Upload payload
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/upload-artifact@v3 # Payload artifact is consumed in Actionable
+      - uses: actions/upload-artifact@v4 # Payload artifact is consumed in Actionable
         with:
           name: payload
           path: ${{ github.event_path }}

.github/workflows/pull_request_review_comment.yml

@@ -7,7 +7,7 @@ jobs:
     name: Upload payload
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/upload-artifact@v3 # Payload artifact is consumed in Actionable
+      - uses: actions/upload-artifact@v4 # Payload artifact is consumed in Actionable
         with:
           name: payload
           path: ${{ github.event_path }}

.gitignore

@@ -1,3 +1,6 @@
+#forgedev dev if the folder exists in here
+forgedev
+
 #eclipse
 **/bin
 **/.settings
@@ -22,10 +25,12 @@
 /*/build
 /*/.gradle
 
+# Minecraft
+/run
+/*.launch
+
 # Projects repo, either ignore it, or ignore patches.
-/projects/mcp/
-/projects/clean/
-/projects/forge/
+src/minecraft
 
 #occupational hazards
 /projects/**/build/
@@ -46,3 +51,9 @@ src/*/generated/**/.cache/
 /*/.gitignore
 /*/.factorypath
 /*/.apt_generated/
+/fmlcore/logs/
+/lib/
+/_actual/
+/runs/
+/forge.ipr
+/forge.iws

.teamcity/pom.xml

@@ -1,104 +0,0 @@
-<?xml version="1.0"?>
-<project>
-  <modelVersion>4.0.0</modelVersion>
-  <name>MinecraftForge_Forge Config DSL Script</name>
-  <groupId>MinecraftForge_Forge</groupId>
-  <artifactId>MinecraftForge_Forge_dsl</artifactId>
-  <version>1.0-SNAPSHOT</version>
-
-  <parent>
-    <groupId>org.jetbrains.teamcity</groupId>
-    <artifactId>configs-dsl-kotlin-parent</artifactId>
-    <version>1.0-SNAPSHOT</version>
-  </parent>
-
-  <repositories>
-    <repository>
-      <id>jetbrains-all</id>
-      <url>https://download.jetbrains.com/teamcity-repository</url>
-      <snapshots>
-        <enabled>true</enabled>
-      </snapshots>
-    </repository>
-    <repository>
-      <id>teamcity-server</id>
-      <url>https://teamcity.minecraftforge.net/app/dsl-plugins-repository</url>
-      <snapshots>
-        <enabled>true</enabled>
-      </snapshots>
-    </repository>
-  </repositories>
-
-  <pluginRepositories>
-    <pluginRepository>
-      <id>JetBrains</id>
-      <url>https://download.jetbrains.com/teamcity-repository</url>
-    </pluginRepository>
-  </pluginRepositories>
-
-  <build>
-    <sourceDirectory>${basedir}</sourceDirectory>
-    <plugins>
-      <plugin>
-        <artifactId>kotlin-maven-plugin</artifactId>
-        <groupId>org.jetbrains.kotlin</groupId>
-        <version>${kotlin.version}</version>
-
-        <configuration/>
-        <executions>
-          <execution>
-            <id>compile</id>
-            <phase>process-sources</phase>
-            <goals>
-              <goal>compile</goal>
-            </goals>
-          </execution>
-          <execution>
-            <id>test-compile</id>
-            <phase>process-test-sources</phase>
-            <goals>
-              <goal>test-compile</goal>
-            </goals>
-          </execution>
-        </executions>
-      </plugin>
-      <plugin>
-        <groupId>org.jetbrains.teamcity</groupId>
-        <artifactId>teamcity-configs-maven-plugin</artifactId>
-        <version>${teamcity.dsl.version}</version>
-        <configuration>
-          <format>kotlin</format>
-          <dstDir>target/generated-configs</dstDir>
-        </configuration>
-      </plugin>
-    </plugins>
-  </build>
-
-  <dependencies>
-    <dependency>
-      <groupId>org.jetbrains.teamcity</groupId>
-      <artifactId>configs-dsl-kotlin</artifactId>
-      <version>${teamcity.dsl.version}</version>
-      <scope>compile</scope>
-    </dependency>
-    <dependency>
-      <groupId>org.jetbrains.teamcity</groupId>
-      <artifactId>configs-dsl-kotlin-plugins</artifactId>
-      <version>1.0-SNAPSHOT</version>
-      <type>pom</type>
-      <scope>compile</scope>
-    </dependency>
-    <dependency>
-      <groupId>org.jetbrains.kotlin</groupId>
-      <artifactId>kotlin-stdlib-jdk8</artifactId>
-      <version>${kotlin.version}</version>
-      <scope>compile</scope>
-    </dependency>
-    <dependency>
-      <groupId>org.jetbrains.kotlin</groupId>
-      <artifactId>kotlin-script-runtime</artifactId>
-      <version>${kotlin.version}</version>
-      <scope>compile</scope>
-    </dependency>
-  </dependencies>
-</project>

.teamcity/settings.kts

@@ -1,193 +0,0 @@
-import jetbrains.buildServer.configs.kotlin.v2019_2.*
-import jetbrains.buildServer.configs.kotlin.v2019_2.projectFeatures.githubIssues
-import jetbrains.buildServer.configs.kotlin.*
-import jetbrains.buildServer.configs.kotlin.v2019_2.buildSteps.gradle
-
-/*
-The settings script is an entry point for defining a TeamCity
-project hierarchy. The script should contain a single call to the
-project() function with a Project instance or an init function as
-an argument.
-
-VcsRoots, BuildTypes, Templates, and subprojects can be
-registered inside the project using the vcsRoot(), buildType(),
-template(), and subProject() methods respectively.
-
-To debug settings scripts in command-line, run the
-
-    mvnDebug org.jetbrains.teamcity:teamcity-configs-maven-plugin:generate
-
-command and attach your debugger to the port 8000.
-
-To debug in IntelliJ Idea, open the 'Maven Projects' tool window (View
--> Tool Windows -> Maven Projects), find the generate task node
-(Plugins -> teamcity-configs -> teamcity-configs:generate), the
-'Debug' option is available in the context menu for the task.
-*/
-
-version = "2021.2"
-
-project {
-
-    buildType(Build)
-    buildType(BuildSecondaryBranches)
-    buildType(PullRequests)
-    buildType(PullRequestChecks)
-    buildType(PullRequestCompatibility)
-
-    params {
-        text("docker_jdk_version", "21", label = "Gradle version", description = "The version of the JDK to use during execution of tasks in a JDK.", display = ParameterDisplay.HIDDEN, allowEmpty = false)
-        text("docker_gradle_version", "8.7", label = "Gradle version", description = "The version of Gradle to use during execution of Gradle tasks.", display = ParameterDisplay.HIDDEN, allowEmpty = false)
-        text("git_main_branch", "1.21.x", label = "Git Main Branch", description = "The git main or default branch to use in VCS operations.", display = ParameterDisplay.HIDDEN, allowEmpty = false)
-        text("git_branch_spec", """
-                +:refs/heads/(main*)
-                +:refs/heads/(master*)
-                +:refs/heads/(develop|release|staging|main|master)
-                +:refs/heads/(1.*)
-            """.trimIndent(), label = "The branch specification of the repository", description = "By default all main branches are build by the configuration. Modify this value to adapt the branches build.", display = ParameterDisplay.HIDDEN, allowEmpty = true)
-        text("github_repository_name", "MinecraftForge", label = "The github repository name. Used to connect to it in VCS Roots.", description = "This is the repository slug on github. So for example `MinecraftForge` or `MinecraftForge`. It is interpolated into the global VCS Roots.", display = ParameterDisplay.HIDDEN, allowEmpty = false)
-        text("env.PUBLISHED_JAVA_ARTIFACT_ID", "forge", label = "Published artifact id", description = "The maven coordinate artifact id that has been published by this build. Can not be empty.", allowEmpty = false)
-        text("env.PUBLISHED_JAVA_GROUP", "net.minecraftforge", label = "Published group", description = "The maven coordinate group that has been published by this build. Can not be empty.", allowEmpty = false)
-        //These are references and not actually keys
-        password("env.CROWDIN_KEY", "credentialsJSON:a3102dbe-805d-4177-9f54-3d2c2eb08fd5", display = ParameterDisplay.HIDDEN)
-        password("env.KEYSTORE_URL", "credentialsJSON:a7ae1c82-8058-4061-8d12-7f6bc2618d2e", display = ParameterDisplay.HIDDEN)
-        password("env.KEYSTORE_PASSWORD", "credentialsJSON:d7b964e3-a1fd-47a8-b892-6f601fe47479", display = ParameterDisplay.HIDDEN)
-        text("additional_publishing_gradle_parameters", "-PcrowdinKey=%env.CROWDIN_KEY% -PkeystoreKeyPass=%env.KEYSTORE_PASSWORD% -PkeystoreStorePass=%env.KEYSTORE_PASSWORD% -Pkeystore=%env.KEYSTORE_URL%", label = "Additional gradle parameters for publish", description = "Contains the additional gradle parameters used during publishing.", display = ParameterDisplay.HIDDEN, allowEmpty = true)
-
-        checkbox("should_execute_build", "false", label = "Should build", description = "Indicates if the build task should be executed.", display = ParameterDisplay.HIDDEN,
-            checked = "true", unchecked = "false")
-        checkbox("should_execute_test", "false", label = "Should build", description = "Indicates if the build task should be executed.", display = ParameterDisplay.HIDDEN,
-            checked = "true", unchecked = "false")
-    }
-
-    features {
-        githubIssues {
-            id = "MinecraftForge_MinecraftForge__IssueTracker"
-            displayName = "MinecraftForge/MinecraftForge"
-            repositoryURL = "https://github.com/MinecraftForge/MinecraftForge"
-        }
-    }
-}
-
-object Build : BuildType({
-    templates(AbsoluteId("MinecraftForge_SetupGradleUtilsCiEnvironmen"), AbsoluteId("MinecraftForge_BuildWithDiscordNotifications"), AbsoluteId("MinecraftForge_BuildMainBranches"), AbsoluteId("MinecraftForge_SetupProjectUsingGradle"), AbsoluteId("MinecraftForge_BuildUsingGradle"), AbsoluteId("MinecraftForge_PublishProjectUsingGradle"), AbsoluteId("MinecraftForge_TriggersStaticFilesWebpageGenerator"))
-    id("MinecraftForge_MinecraftForge__Build")
-    name = "Build"
-    description = "Builds and Publishes the main branches of the project."
-})
-
-object BuildSecondaryBranches : BuildType({
-    templates(AbsoluteId("MinecraftForge_ExcludesBuildingDefaultBranch"), AbsoluteId("MinecraftForge_SetupGradleUtilsCiEnvironmen"), AbsoluteId("MinecraftForge_BuildWithDiscordNotifications"), AbsoluteId("MinecraftForge_BuildMainBranches"), AbsoluteId("MinecraftForge_SetupProjectUsingGradle"), AbsoluteId("MinecraftForge_BuildUsingGradle"))
-    id("MinecraftForge_MinecraftForge__BuildSecondaryBranches")
-    name = "Build - Secondary Branches"
-    description = "Builds and Publishes the secondary branches of the project."
-    params {
-        text("git_branch_spec", """
-                +:refs/heads/(*)
-                -:refs/heads/noci*
-            """.trimIndent(), label = "The branch specification of the repository", description = "By default all main branches are build by the configuration. Modify this value to adapt the branches build.", display = ParameterDisplay.HIDDEN, allowEmpty = true)
-    }
-    vcs {
-        branchFilter = """
-            +:*
-            -:1.*
-            -:<default>
-        """.trimIndent()
-    }
-})
-
-object PullRequests : BuildType({
-    templates(AbsoluteId("MinecraftForge_BuildPullRequests"), AbsoluteId("MinecraftForge_SetupGradleUtilsCiEnvironmen"), AbsoluteId("MinecraftForge_BuildWithDiscordNotifications"), AbsoluteId("MinecraftForge_SetupProjectUsingGradle"), AbsoluteId("MinecraftForge_BuildUsingGradle"))
-    id("MinecraftForge_MinecraftForge__PullRequests")
-    name = "Pull Requests"
-    description = "Builds pull requests for the project"
-
-    params {
-        checkbox("should_execute_build", "true", label = "Should build", description = "Indicates if the build task should be executed.", display = ParameterDisplay.HIDDEN,
-            checked = "true", unchecked = "false")
-        text(
-            "gradle_build_task",
-            "assemble",
-            label = "Gradle build task to execute during build",
-            description = "Determines the build task that is executed to build the project.",
-            display = ParameterDisplay.HIDDEN,
-            allowEmpty = false
-        )
-    }
-
-    vcs {
-        branchFilter = """
-            +:*
-            -:1.*
-            -:<default>
-        """.trimIndent()
-    }
-})
-
-object PullRequestChecks : BuildType({
-    templates(AbsoluteId("MinecraftForge_BuildPullRequests"), AbsoluteId("MinecraftForge_SetupGradleUtilsCiEnvironmen"), AbsoluteId("MinecraftForge_BuildWithDiscordNotifications"), AbsoluteId("MinecraftForge_SetupProjectUsingGradle"))
-    id("MinecraftForge_MinecraftForge__PullRequestChecks")
-    name = "Pull Requests (Checks)"
-    description = "Checks pull requests for the project"
-
-    steps {
-        gradle {
-            name = "Check"
-            id = "RUNNER_10_Check"
-
-            tasks = "checkAll"
-            gradleParams = "--continue %gradle_custom_args%"
-            enableStacktrace = true
-            dockerImage = "%docker_gradle_image%"
-            dockerRunParameters = """
-                -v "/opt/cache/agent/gradle:/home/gradle/.gradle"
-                -v "/opt/cache/shared/gradle:/home/gradle/rocache:ro"
-                --network=host
-                -u 1000:1000
-                %docker_additional_args%
-            """.trimIndent()
-        }
-    }
-
-    vcs {
-        branchFilter = """
-            +:*
-            -:1.*
-            -:<default>
-        """.trimIndent()
-    }
-})
-
-object PullRequestCompatibility : BuildType({
-    templates(AbsoluteId("MinecraftForge_BuildPullRequests"), AbsoluteId("MinecraftForge_SetupGradleUtilsCiEnvironmen"), AbsoluteId("MinecraftForge_BuildWithDiscordNotifications"), AbsoluteId("MinecraftForge_SetupProjectUsingGradle"))
-    id("MinecraftForge_MinecraftForge__PullRequestCompatibility")
-    name = "Pull Requests (Compatibility)"
-    description = "Validates binary compatibility for pull requests made to the project"
-
-    steps {
-        gradle {
-            name = "Validate"
-            id = "RUNNER_10_Compatibility"
-
-            tasks = "checkJarCompatibility"
-            gradleParams = "--continue %gradle_custom_args%"
-            enableStacktrace = true
-            dockerImage = "%docker_gradle_image%"
-            dockerRunParameters = """
-                -v "/opt/cache/agent/gradle:/home/gradle/.gradle"
-                -v "/opt/cache/shared/gradle:/home/gradle/rocache:ro"
-                --network=host
-                -u 1000:1000
-                %docker_additional_args%
-            """.trimIndent()
-        }
-    }
-
-    vcs {
-        branchFilter = """
-            +:*
-            -:1.*
-            -:<default>
-        """.trimIndent()
-    }
-})

CREDITS.txt

@@ -1,65 +0,0 @@
-Minecraft Forge: Credits/Thank You
-
-Forge is a set of tools and modifications to the Minecraft base game code to assist 
-mod developers in creating new and exciting content. It has been in development for 
-several years now, but I would like to take this time thank a few people who have 
-helped it along its way.
-
-First, the people who originally created the Forge projects way back in Minecraft 
-alpha. Eloraam of RedPower, and SpaceToad of Buildcraft, without their acceptiance 
-of me taking over the project, who knows what Minecraft modding would be today.
-
-Secondly, someone who has worked with me, and developed some of the core features
-that allow modding to be as functional, and as simple as it is, cpw. For developing
-FML, which stabilized the client and server modding ecosystem. As well as the base
-loading system that allows us to modify Minecraft's code as elegently as possible.
-
-Mezz, who has stepped up as the issue and pull request manager. Helping to keep me
-sane as well as guiding the community into creating better additions to Forge.
-
-Searge, Bspks, Fesh0r, ProfMobious, and all the rest over on the MCP team {of which 
-I am a part}. For creating some of the core tools needed to make Minecraft modding 
-both possible, and as stable as can be.
-  On that note, here is some specific information of the MCP data we use:
-    * Minecraft Coder Pack (MCP) *
-      Forge Mod Loader and Minecraft Forge have permission to distribute and automatically 
-      download components of MCP and distribute MCP data files. This permission is not 
-      transitive and others wishing to redistribute the Minecraft Forge source independently
-      should seek permission of MCP or remove the MCP data files and request their users 
-      to download MCP separately.
-      
-And lastly, the countless community members who have spent time submitting bug reports, 
-pull requests, and just helping out the community in general. Thank you.
-
---LexManos
-
-=========================================================================
-
-This is Forge Mod Loader.
-
-You can find the source code at all times at https://github.com/MinecraftForge/MinecraftForge/tree/1.12.x/src/main/java/net/minecraftforge/fml
-
-This minecraft mod is a clean open source implementation of a mod loader for minecraft servers
-and minecraft clients.
-
-The code is authored by cpw.
-
-It began by partially implementing an API defined by the client side ModLoader, authored by Risugami.
-https://www.minecraftforum.net/topic/75440-
-This support has been dropped as of Minecraft release 1.7, as Risugami no longer maintains ModLoader.
-
-It also contains suggestions and hints and generous helpings of code from LexManos, author of MinecraftForge.
-https://minecraftforge.net/
-
-Additionally, it contains an implementation of topological sort based on that 
-published at http://keithschwarz.com/interesting/code/?dir=topological-sort
-
-It also contains code from the Maven project for performing versioned dependency
-resolution. http://maven.apache.org/
-
-It also contains a partial repackaging of the javaxdelta library from http://sourceforge.net/projects/javaxdelta/
-with credit to it's authors.
-
-Forge Mod Loader downloads components from the Minecraft Coder Pack
-(http://mcp.ocean-labs.de/index.php/Main_Page) with kind permission from the MCP team.
-

LICENSE.txt

@@ -3,7 +3,7 @@ parts herein are licensed under the terms of the LGPL 2.1 found
 here http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt and 
 copied below.
 
-Homepage: http://minecraftforge.net/
+Homepage: https://minecraftforge.net/
           https://github.com/MinecraftForge/MinecraftForge
           
 

build.gradle

@@ -1,54 +1,796 @@
-import net.minecraftforge.forge.tasks.*
-import net.minecraftforge.gradleutils.PomUtils
+import org.apache.tools.ant.filters.ReplaceTokens
 
 plugins {
-    id 'net.minecraftforge.licenser' version '1.0.1'
-    id 'com.github.ben-manes.versions' version '0.46.0'
-    id 'net.minecraftforge.gradleutils' version '[2.6.4,2.7)'
+    id 'java-library'
+    id 'idea'
     id 'eclipse'
-    id 'de.undercouch.download' version '5.4.0'
-    id 'net.minecraftforge.gradle.patcher' version '[6.0.22,6.2)' apply false
-    id 'net.minecraftforge.gradle.mcp' version '[6.0.22,6.2)' apply false
-    id 'net.minecraftforge.gradlejarsigner' version '1.0.4'
-    id 'org.barfuin.gradle.taskinfo' version '2.1.0'
+    id 'maven-publish'
+    alias libs.plugins.licenser
+    alias libs.plugins.versions
+    alias libs.plugins.gradleutils
+    alias libs.plugins.gitversion
+    alias libs.plugins.changelog
+    alias libs.plugins.jarsigner
+    id 'net.minecraftforge.forgedev'
+    id 'net.minecraftforge.forge.build.convention'
 }
 
-Util.init() //Init all our extension methods!
+gradleutils.displayName = 'Forge'
+group = 'net.minecraftforge'
+description = 'Modifications to Minecraft to enable mod developers.'
 
-ext {
-    VERSION = gitversion.getMCTagOffsetBranch(MC_VERSION)
-    FORGE_VERSION = VERSION.substring(MC_VERSION.length() + 1)
+// NOTE: See settings.gradle for all the referenceable version variables.
+// All subprojects (that apply 'net.minecraftforge.forge.build.convention') will have these available.
+println "Version: $version"
+
+java.toolchain.languageVersion = JavaLanguageVersion.of(javaVersion)
+
+jarSigner.autoDetect('forge')
+
+// We have to tell ForgeDev to use the exact versions of tools we ship in the installer
+fdtools {
+    configure('binpatcher') {
+        version = buildLibs.binarypatcher.get().version
+    }
+    configure('installertools') {
+        version = buildLibs.installertools.get().version
+    }
+    configure('jarcompatibilitychecker') {
+        javaLauncher = javaToolchains.launcherFor(java.toolchain)
+    }
 }
 
-changelog {
-    from '47.999'
+/* This is used for debugging, comparing all published artifacts against actual production
+forgedev.validatePublish {
+    task {
+        baseBranch = 'upstream/26.1.2'
+        versionPrefix = minecraftVersion
+    }
+}
+*/
+
+final minecraftFiles = forgedev.minecraftFiles(minecraftVersion)
+
+final mcpBase = forgedev.mcpBase {
+    mcpVersion = "${minecraftVersion}-${project.ext.mcpVersion}"
+    accessTransformers.from file('src/main/resources/META-INF/accesstransformer.cfg')
+    sideAnnotationStrippers.from file('src/main/resources/forge.sas')
+}
+
+forgedev.patches {
+    base = mcpBase
+    patches = file('patches/minecraft')
+    patched = file('src/minecraft/java')
+    sourceSets.main.java.srcDir patched
 }
 
 tasks.register('setup') {
-    dependsOn ':forge:extractMapped'
-    if (findProject(':clean'))
-        dependsOn ':clean:extractMapped'
+    dependsOn forgedev.patches.apply
 }
 
-tasks.register('doChecks') {
-    dependsOn ':forge:checkJarCompatibility'
-    dependsOn ':forge:publish'
-}
-
-project(':mcp') {
-    apply plugin: 'net.minecraftforge.gradle.mcp'
-    mcp {
-        config MC_VERSION + '-' + MCP_VERSION
-        pipeline = 'joined'
+sourceSets {
+    named('main') {
+        resources.srcDir 'src/main/generated'
+    }
+    named('test') {
+        resources.srcDir 'src/test/generated'
     }
 }
 
-if (System.env.TEAMCITY_VERSION) {
-    //Only setup the CI environment if and only if the environment variables are set.
-    tasks.named('configureTeamCity').configure {
-        doLast {
-            println "##teamcity[buildNumber '${project(':forge').version}']"
-            println "##teamcity[setParameter name='env.PUBLISHED_JAVA_ARTIFACT_VERSION' value='${project(':forge').version}']"
+license {
+    header = file('LICENSE-header.txt')
+
+    include 'net/minecraftforge/'
+    exclude 'net/minecraftforge/common/LenientUnboundedMapCodec.java'
+
+    tasks.tap {
+        register('main') {
+            files.from files('src/main/java')
+        }
+
+        register('test') {
+            files.from files('src/test/java')
         }
     }
 }
+
+changelog {
+    from changelogBase
+    publishAll = false
+}
+
+// TODO [ForgeDev] Support compileOnlyApi, runtimeOnly, and a consumable annotation processor configuration
+configurations {
+    // Don't pull all libraries, if we're missing something, add it to the installer list so the installer knows to download it.
+    register('bootstrap') {
+        transitive = false
+        canBeDeclared = true
+        canBeResolved = true
+    }
+
+    register('installer') {
+        transitive = false
+        canBeDeclared = true
+        canBeResolved = true
+        extendsFrom(bootstrap)
+    }
+
+    named('api') {
+        extendsFrom(installer)
+    }
+
+    named('implementation') {
+        // Inherit vanilla Minecraft's dependencies
+        extendsFrom(mcpBase.dependencyConfiguration)
+    }
+}
+
+dependencies {
+    // These need to actually be on the classpath at the start. This is only used for the server shim jar.
+    // And this is only needed because custom file systems are REQUIRED to be on the boot classloader.
+    // This has ASM/BootStrap/Unsafe all because I haven't gotten around to moving UnionFileSystem out to its own project.
+    bootstrap libs.jarjar.fs     // JarInJar file system
+    bootstrap libs.roimfs        // JarInJar File System - FileSystems need to be on boot loader.
+    bootstrap libs.bundles.jimfs // In memory file system used for ForgeDev launches
+    bootstrap libs.securemodules // Has Union file system in it
+    bootstrap libs.unsafe        // Needed by securemodules
+    bootstrap libs.bundles.asm   // Needed by securemodules
+
+    implementation libs.jopt.simple
+
+    installer libs.bootstrap
+    installer libs.bootstrap.api // Needed by securemodules
+    installer libs.accesstransformers
+    installer libs.eventbus
+    installer libs.jspecify // Dep of EventBus
+    installer libs.forgespi
+    installer libs.coremods.api
+    installer libs.modlauncher
+    installer libs.mergetool.api
+    installer libs.bundles.night.config
+    installer libs.maven.artifact
+    installer libs.bundles.terminalconsoleappender
+    installer libs.mixin
+    installer libs.mixinextras.forge
+    installer libs.bundles.jarjar
+    installer libs.roimfs
+
+    installer projects.fmlcore
+    installer projects.fmlloader
+    installer projects.fmlearlydisplay
+    installer projects.javafmllanguage
+    installer projects.lowcodelanguage
+    installer projects.mclanguage
+    installer projects.forgeTransformers
+
+    runtimeOnly files(mcpBase.extra)
+
+    runtimeOnly libs.bootstrap
+    runtimeOnly libs.bootstrap.dev
+
+    annotationProcessor libs.eventbus.validator
+}
+
+final EXTRA_TXTS = [
+        file('LICENSE.txt'),
+        changelog.task.flatMap(task -> task.outputFile)
+]
+forgedev.runs {
+    configureEach {
+        options {
+            workingDir = layout.projectDirectory.dir("runs/$name")
+
+            mainClass = 'net.minecraftforge.bootstrap.ForgeBootstrap'
+            args '--gameDir', '.'
+            jvmArgs '-Djava.net.preferIPv6Addresses=system', '-XX:+UseCompactObjectHeaders'
+
+            systemProperty 'bsl.debug', 'true'
+            systemProperty 'terminal.jline', 'true'
+            with(sourceSets.test) {
+                systemProperty 'forge.enableGameTest', 'true'
+                systemProperty 'forgedev.enableTestMods', 'true'
+            }
+        }
+    }
+
+    create('client') {
+        options {
+            systemProperty 'eventbus.api.strictRuntimeChecks', 'true'
+            systemProperty 'org.lwjgl.system.SharedLibraryExtractDirectory', 'lwjgl_dll'
+
+            args '--launchTarget', 'forge_dev_client',
+                 '--username', 'Dev',
+                 '--version', project.name,
+                 '--accessToken', '0',
+                 '--userType', 'mojang',
+                 '--versionType', 'release',
+                 '--assetsDir', '{assets_root}',
+                 '--assetIndex', '{asset_index}'
+        }
+    }
+
+    create('server') {
+        options {
+            args '--launchTarget', 'forge_dev_server'
+        }
+    }
+
+    create('gameTestServer') {
+        options {
+            args '--launchTarget', 'forge_dev_server_gametest'
+            args '--uniqueWorld' // Unique world is used so that the world regenerates, as well as the world config isn't influenced by other runs
+        }
+    }
+
+    create('data') {
+        options {
+            args '--launchTarget', 'forge_dev_data',
+                 '--all',
+                 '--existing', sourceSets.main.resources.srcDirs[0],
+                 '--assetsDir', '{assets_root}',
+                 '--assetIndex', '{asset_index}'
+
+            with(sourceSets.main) {
+                args '--mod', 'forge',
+                     '--output', rootProject.file('src/main/generated/')
+            }
+
+            with(sourceSets.test) {
+                args '--mod', '.+',
+                     '--existing', sourceSets.test.resources.srcDirs[0],
+                     '--output', rootProject.file('src/test/generated/')
+            }
+        }
+    }
+
+    create('clientData') {
+        options {
+            args '--all',
+                    '--existing', sourceSets.main.resources.srcDirs[0],
+                    '--assetsDir', '{assets_root}',
+                    '--assetIndex', '{asset_index}'
+
+            with(sourceSets.main) {
+                args '--launchTarget', 'forge_dev_client_data',
+                     '--mod', 'forge',
+                     '--output', rootProject.file('src/main/generated/'),
+                     '--mod', 'forge'
+            }
+
+            with(sourceSets.test) {
+                args '--launchTarget', 'forge_dev',
+                     '--launchEntry', 'minecraft/net.minecraft.client.data.Main',
+                     '--launchData',
+                     '--mod', '.+',
+                     '--existing', sourceSets.test.resources.srcDirs[0],
+                     '--output', rootProject.file('src/test/generated/')
+            }
+        }
+    }
+}
+tasks.register('genAllData') {
+    dependsOn forgedev.runs.data.run, forgedev.runs.data.runTest, forgedev.runs.clientData.run, forgedev.runs.clientData.runTest
+}
+
+final serverShim = forgedev.shim {
+    config {
+        mainClass = 'net.minecraftforge.bootstrap.ForgeBootstrap'
+        args = ['--launchTarget', 'forge_server']
+    }
+    classpath {
+        libraries configurations.installer
+        library tasks.named('universalJar', Jar)
+        library forgedev.binaryPatches('server').apply, 'server'
+        serverBundle.fileProvider(minecraftFiles.server)
+    }
+    bootstrapClasspath(configurations.bootstrap)
+    jar {
+        jarSigner.sign(it)
+    }
+}
+
+final finalizeSpawn = forgedev.methodCallFinder('findFinalizeSpawnTargets') {
+    jar.fileProvider(mcpBase.classes)
+    output = rootProject.file('forge-transformers/src/main/resources/coremods/finalize_spawn_targets.json')
+    blacklist 'net/minecraft/world/level/BaseSpawner' // Ignore this class as we special case it.
+    invokeVirtual('finalizeSpawn', '(Lnet/minecraft/world/level/ServerLevelAccessor;Lnet/minecraft/world/DifficultyInstance;Lnet/minecraft/world/entity/EntitySpawnReason;Lnet/minecraft/world/entity/SpawnGroupData;)Lnet/minecraft/world/entity/SpawnGroupData;')
+}
+
+forgedev.validateDeprecations(tasks.named('jar', Jar)) {
+    mcVersion = minecraftVersion
+}
+
+forgedev.checks() {
+    base = mcpBase
+    ats {}
+    sas {}
+    execs {}
+
+    patches {
+        dependsOn forgedev.patches.make
+        patchDir = forgedev.patches.patches
+        patchesWithS2SArtifact = [
+                'minecraft/net/minecraft/client/renderer/ViewArea.java.patch',
+                'minecraft/net/minecraft/data/models/blockstates/Variant.java.patch',
+        ]
+    }
+
+    fix {
+        dependsOn finalizeSpawn
+    }
+
+    forgedev.patches.make.configure {
+        finalizedBy forgedev.checks.patches.fix
+    }
+}
+
+final crowdin = forgedev.crowdin // Create the crowdin tasks
+tasks.named('jar', Jar) {
+    from(EXTRA_TXTS)
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+    exclude '.cache'
+
+    from(zipTree(crowdin.flatMap { it.output } )) {
+        include 'assets/forge/lang/*.json'
+    }
+
+    manifest {
+        attributes([
+                'Automatic-Module-Name': 'net.minecraftforge.forge'
+        ])
+        attributes([
+                'Specification-Title'   : gradleutils.displayName.get(),
+                'Specification-Vendor'  : gradleutils.vendor.get(),
+                'Specification-Version' : gitversion.info.tag,
+                'Implementation-Title'  : project.group,
+                'Implementation-Vendor' : gradleutils.vendor.get(),
+                'Implementation-Version': forgeVersion
+        ], 'net/minecraftforge/versions/forge/')
+        attributes([
+                'Specification-Title'   : 'Minecraft',
+                'Specification-Vendor'  : gradleutils.vendor.get(),
+                'Specification-Version' : minecraftVersion,
+                'Implementation-Title'  : 'MCP',
+                'Implementation-Vendor' : gradleutils.vendor.get(),
+                'Implementation-Version': mcpVersion
+        ], 'net/minecraftforge/versions/mcp/')
+    }
+    jarSigner.sign(it)
+}
+
+final universalJar = tasks.register('universalJar', Jar) {
+    from (zipTree(tasks.named('jar', Jar).flatMap { it.archiveFile } )) {
+        exclude(forgedev.filterVanilla(mcpBase.classes))
+    }
+    manifest = tasks.named('jar', Jar).get().manifest
+    archiveClassifier = 'universal'
+    jarSigner.sign(it)
+}
+
+final sourcesJarAll = tasks.register('sourcesJarAll', Jar) {
+    archiveClassifier = 'sources-all'
+    from(sourceSets.main.allJava.srcDirs)
+}
+
+// Our sources, plus the patches we do to Vanilla Minecraft
+final sourcesJar = tasks.register('sourcesJar', Jar) {
+    archiveClassifier = 'sources'
+    from(sourceSets.main.allJava.srcDirs - forgedev.patches.patched.asFile.get())
+    mustRunAfter(forgedev.patches.make)
+    from(forgedev.patches.patches) {
+        into 'patches/'
+    }
+}
+
+forgedev.userDev {
+    base(mcpBase)
+
+    config {
+        universal universalJar
+        sources sourcesJar
+        addLibraries(configurations.installer)
+        // TODO [ForgeDev][UserDev] Split API/Runtime elements in userdev config
+        //      so we don't gotta keep making exceptions for MixinExtras
+        addCompileDependency(libs.mixinextras.common)
+        addAnnotationProcessorDependency(libs.mixinextras.common)
+
+        // TODO [ForgeDev] Consolidate Patcher + UserDev Config runs in a sane way
+        runs {
+            configureEach {
+                parents = []
+                main = 'net.minecraftforge.bootstrap.ForgeBootstrap'
+                args '--gameDir', '.'
+                jvmArgs '-Djava.net.preferIPv6Addresses=system', '-XX:+UseCompactObjectHeaders'
+                client = it.name.containsIgnoreCase('client')
+                environment 'MCP_MAPPINGS', '{mcp_mappings}'
+            }
+
+            register('clientData') {
+                args '--launchTarget', "forge_userdev_client_data"
+                args '--assetIndex', '{asset_index}'
+                args '--assetsDir', '{assets_root}'
+            }
+
+            register('client') {
+                property 'forge.enableGameTest', 'true'
+                args '--launchTarget', "forge_userdev_client"
+                args '--version', 'MOD_DEV'
+                args '--assetIndex', '{asset_index}'
+                args '--assetsDir', '{assets_root}'
+            }
+
+            register('server') {
+                property 'forge.enableGameTest', 'true'
+                args '--launchTarget', "forge_userdev_server"
+            }
+
+            register('gameTestServer') {
+                args '--launchTarget', "forge_userdev_server_gametest"
+            }
+
+            register('data') {
+                args '--launchTarget', "forge_userdev_data"
+                args '--assetIndex', '{asset_index}'
+                args '--assetsDir', '{assets_root}'
+            }
+        }
+    }
+    patches {
+        modified.setFrom(sourcesJarAll.flatMap { it.archiveFile })
+    }
+    binaryPatches {
+        mustRunAfter(forgedev.patches.make)
+        patches.setFrom(forgedev.patches.patches)
+        dirty.setFrom(tasks.named('jar', Jar).flatMap { it.archiveFile })
+    }
+}
+
+forgedev.userdevCompatibility(minecraftVersion) {
+    clean = mcpBase.classes
+    dirty = tasks.named('jar', Jar)
+}
+
+// region Installer tasks, Not needed when we simplify the installer/remove obf
+final clientBinPatches = forgedev.binaryPatches('client') {
+    clean = minecraftFiles.client
+    // Workaround for 3rd party launcher issues, marker needed to locate MC, store needed to fix zlib-ng issues
+    apply { 
+        store = true 
+        marker = '.forge_patched_minecraft'
+    }
+}
+final serverBinPatches = forgedev.binaryPatches('server') {
+    clean = minecraftFiles.serverExtracted
+    apply { store = true }
+}
+// endregion
+
+forgedev.installer {
+    dev = !forgedev.ci
+    offline = false
+    baseVersion = buildLibs.installer.get().version.toString()
+
+    // Add extra libraries
+    pack serverShim.jar // The Server executable jar IS needed to be packed, as the installer would need a spec bump in order to download it
+    pack universalJar // I don't think this is strictly needed to be packed anymore, will need to double check later
+
+    launcherLibrary universalJar
+    // We configure the launcher here to keep the order for easier diff, after publishing, move this to the LauncherJson configuration below
+    launcherJson {
+        // We create this during install, so it's not downloadable
+        generated(clientBinPatches.apply, 'client')
+    }
+
+    launcherLibraries configurations.installer
+
+    final launcherId = "${minecraftVersion}-${project.name}-${forgeVersion}"
+    final installertools = tool(buildLibs.installertools)
+    final binarypatcher = tool(buildLibs.binarypatcher)
+
+    jar {
+        from(EXTRA_TXTS)
+        from(rootProject.file('/forge_installer_logo.png')) {
+            rename { 'big_logo.png' }
+        }
+        from(clientBinPatches.create.flatMap { t -> t.output }) {
+            rename { 'data/client.lzma' }
+        }
+        from(serverBinPatches.create.flatMap { t -> t.output }) {
+            rename { 'data/server.lzma' }
+        }
+
+        final argsFile = rootProject.file('server_files/args.txt')
+        final tokens = [tokens: [
+                SHIM_JAR_FILE: serverShim.jar.get().archiveFileName.get(),
+                MAVEN_PATH: forgedev.mavenArtifact.directory
+        ]]
+        from(argsFile) {
+            filter(tokens, ReplaceTokens)
+            into 'data'
+            rename { 'unix_args.txt' }
+        }
+        from(argsFile) {
+            filter(tokens, ReplaceTokens)
+            into 'data'
+            rename { 'win_args.txt' }
+        }
+
+        from(rootProject.file('server_files')) {
+            filter(tokens, ReplaceTokens)
+            into 'data'
+            exclude 'args.txt'
+        }
+
+        jarSigner.sign(it)
+    }
+    json {
+        icon = rootProject.file('icon.ico')
+        executable serverShim.jar
+        minecraft = minecraftVersion
+        profileVersion = launcherId
+
+        final projectArtifact = "${project.group}:${project.name}:${project.version}"
+
+        data 'MC_UNPACKED', "[net.minecraft:client:${minecraftVersion}]", "[net.minecraft:server:${minecraftVersion}:unpacked]"
+        data 'MC_UNPACKED_SHA', minecraftFiles.client, minecraftFiles.serverExtracted
+
+        data 'BINPATCH', '/data/client.lzma', '/data/server.lzma'
+        data 'PATCHED', "[$projectArtifact:client]", "[$projectArtifact:server]"
+        data 'PATCHED_SHA', clientBinPatches.apply.flatMap { it.output }, serverBinPatches.apply.flatMap { it.output }
+
+        steps = [
+                extract(installertools) {
+                    side = 'server'
+                    archive '{INSTALLER}'
+                    extract 'data/README.txt', '{ROOT}/README.txt'
+                    extract 'data/run.sh', '{ROOT}/run.sh'
+                    executable '{ROOT}/run.sh'
+                    extract 'data/run.bat', '{ROOT}/run.bat'
+                    optional 'data/user_jvm_args.txt', '{ROOT}/user_jvm_args.txt'
+                    extract 'data/unix_args.txt', "{ROOT}/libraries/${forgedev.mavenArtifact.directory}/unix_args.txt"
+                    extract 'data/win_args.txt', "{ROOT}/libraries/${forgedev.mavenArtifact.directory}/win_args.txt"
+                },
+                extractBundle(installertools) {
+                    side = 'server'
+                    libraries()
+                },
+                extractBundle(installertools) {
+                    side = 'server'
+                    jar '{MINECRAFT_JAR}', '{MC_UNPACKED}'
+                    cache '{MC_UNPACKED}', '{MC_UNPACKED_SHA}'
+                },
+                step(binarypatcher) {
+                    side = 'server'
+                    args = [
+                            '--clean', '{MC_UNPACKED}',
+                            '--output', '{PATCHED}',
+                            '--apply', '{BINPATCH}',
+                            '--data', '--unpatched',
+                            '--store'
+                    ]
+                    cache '{PATCHED}', '{PATCHED_SHA}'
+                },
+                step(binarypatcher) {
+                    side = 'client'
+                    args = [
+                            '--clean', '{MINECRAFT_JAR}',
+                            '--output', '{PATCHED}',
+                            '--apply', '{BINPATCH}',
+                            '--data', '--unpatched',
+                            '--store',
+                            '--marker', '.forge_patched_minecraft'
+                    ]
+                    cache '{PATCHED}', '{PATCHED_SHA}'
+                }
+        ]
+    }
+
+    launcherJson {
+        // These are flags to preserve glitchy old behavior to make diffing easier, removing when migrating to production is recommended
+        sortLibraries = false // Don't sort, makes things non-deterministic, but easier to diff old versions
+        duplicateLibraries = true // Our 'bootstrap' layer go added twice
+        librariesLast = false // Makes libraries be added before args
+
+        id = launcherId
+        inheritsFrom = minecraftVersion
+        mainClass = 'net.minecraftforge.bootstrap.ForgeBootstrap'
+        gameArgs = [ '--launchTarget', 'forge_client' ]
+        jvmArgs = [ '-Djava.net.preferIPv6Addresses=system', '-XX:+UseCompactObjectHeaders' ]
+    }
+}
+
+final mdkGradleWrapper = tasks.register('mdkGradleWrapper', Wrapper) {
+    gradleVersion = '9.5.0'
+    scriptFile = layout.buildDirectory.dir("wrapper/" + gradleVersion + "/gradlew")
+    jarFile = layout.buildDirectory.dir("wrapper/" + gradleVersion + "/gradle/wrapper/gradle-wrapper.jar")
+}
+
+final mdkZip = tasks.register('mdkZip', Zip) {
+    dependsOn mdkGradleWrapper
+
+    archiveBaseName = project.name
+    archiveClassifier = 'mdk'
+    archiveVersion = project.version
+    destinationDirectory = file('build/libs')
+    from(EXTRA_TXTS)
+
+    from mdkGradleWrapper.map(Wrapper.&getScriptFile)
+    from mdkGradleWrapper.map(Wrapper.&getBatchScript)
+    into('gradle/wrapper/') {
+        from mdkGradleWrapper.map(Wrapper.&getJarFile)
+        from mdkGradleWrapper.map(Wrapper.&getPropertiesFile)
+    }
+    from(rootProject.file('mdk/')){
+        rootProject.file('mdk/gitignore.txt').eachLine {
+            if (!it.trim().isEmpty() && !it.trim().startsWith('#'))
+                exclude it
+        }
+        filter(ReplaceTokens, tokens: [
+                FORGE_VERSION: forgeVersion,
+                FORGE_GROUP: project.group,
+                FORGE_NAME: project.name,
+                MC_VERSION: minecraftVersion,
+                FORGE_SPEC_VERSION: gitversion.info.tag.split("\\.")[0],
+                MC_NEXT_VERSION: minecraftNextVersion,
+                EVENTBUS_VERSION: libs.versions.eventbus.get()
+        ])
+        rename 'gitignore\\.txt', '.gitignore'
+        rename 'gitattributes\\.txt', '.gitattributes'
+    }
+    from(rootProject.file('src/test/java/com/example/examplemod/')) {
+        into('src/main/java/com/example/examplemod/')
+    }
+    from(rootProject.file('src/test/generated/mdk_datagen/')) {
+        into('src/main/resources/')
+        exclude '**/.cache/'
+    }
+}
+
+/*
+tasks.named('javadoc', Javadoc) {
+    description = 'Generates the combined javadocs for the FML projects and the main Forge project'
+    var includedProjects = [ ':fmlcore', ':fmlloader', ':javafmllanguage', ':mclanguage', ':forge-transformers' ]
+    source includedProjects.collect { project(it).sourceSets.main.allJava }
+    classpath = classpath + files(includedProjects.collect { project(it).sourceSets.main.compileClasspath })
+
+    var docsDir = rootProject.file('src/docs/')
+    inputs.dir(docsDir)
+        .withPropertyName('docs resources directory')
+        .withPathSensitivity(PathSensitivity.RELATIVE)
+        .optional()
+
+    failOnError = false
+
+    // Exclude the Minecraft classes if not enabled
+    if (!project.hasProperty('generateAllDocumentation')) {
+        exclude 'net/minecraft/**'
+        exclude 'com/mojang/**'
+    }
+    exclude 'mcp/**'
+
+    options {
+        stylesheetFile = new File(docsDir, 'stylesheet.css')
+
+        tags = [
+            'apiNote:a:<em>API Note:</em>',
+            'implSpec:a:<em>Implementation Requirements:</em>',
+            'implNote:a:<em>Implementation Note:</em>'
+        ]
+
+        groups = [
+            'Forge Mod Loader': [
+                'net.minecraftforge.fml.common.asm*',
+                'net.minecraftforge.fml.loading*',
+                'net.minecraftforge.fml.server*'
+            ],
+            'FML Core':  [
+                'net.minecraftforge.fml',
+                'net.minecraftforge.fml.config*',
+                'net.minecraftforge.fml.event*',
+                'net.minecraftforge.fml.util*'
+            ],
+            'FML Common': [
+                'net.minecraftforge.fml.core',
+                'net.minecraftforge.fml.event.config',
+                'net.minecraftforge.fml.event.lifecycle'
+            ],
+            'FML Java/MC Language Providers': [
+                'net.minecraftforge.fml.common',
+                'net.minecraftforge.fml.javafmlmod',
+                'net.minecraftforge.fml.mclanguageprovider'
+            ],
+            'Minecraft Forge API': [
+                'net.minecraftforge*'
+            ]
+        ]
+
+        author = false
+        noSince = true
+        noHelp = true
+
+        bottom = "Minecraft Forge is an open source modding API for Minecraft: Java Edition, licensed under the Lesser GNU General Public License, version 2.1."
+        windowTitle = "Minecraft Forge API ${version}"
+        docTitle = "Minecraft Forge API - ${forgeVersion} for Minecraft ${minecraftVersion}"
+        header = "<div style=\"margin-top: 9px;padding: 5px 6px;\"><strong>${forgeVersion} for Minecraft ${minecraftVersion}</strong></div>"
+    }
+
+    doLast {
+        project.copy {
+            from docsDir
+            exclude '/stylesheet.css'
+            into destinationDir
+        }
+    }
+}
+*/
+
+publishing {
+    repositories {
+        maven gradleutils.publishingForgeMaven
+    }
+
+    publications.register('mavenJava', MavenPublication) {
+        changelog.publish(it)
+        gradleutils.promote(it)
+
+        artifact universalJar
+        artifact forgedev.installer.jar
+        artifact mdkZip
+        artifact forgedev.userDev.jar
+        artifact sourcesJar
+        artifact serverShim.jar
+
+        pom {
+            description = project.description
+
+            gradleutils.pom.addRemoteDetails(pom)
+
+            licenses {
+                license gradleutils.pom.licenses.LGPLv2_1
+            }
+        }
+    }
+}
+
+
+/*
+// These are debugging tasks that are only used when developing ForgeDevPlugin, to bulk test task's config/caching
+// region ForgeDev Tests
+def all = tasks.register('all') {}
+afterEvaluate {
+    if (gradle.startParameter.taskNames.contains('all')) {
+	    tasks.forEach { task -> // This forces everything to be realized, which is why we have the startParameter check
+	        if (!gradle.startParameter.isTaskGraph() && task.name.startsWith('run')) return
+            if (task.name in [all.name, 'dependencyInsight', 'dependencies', 'dependencyUpdates', 'init', 'buildEnvironment', 'idea',
+                'eclipse', 'javaToolchains', 'outgoingVariants', 'projects', 'properties', 'resolvableConfigurations', 'tasks', 'updateDaemonJvm',
+                'generateActionsWorkflow'
+            ]) return
+            if (task.name.startsWith('clean')) return
+            if (task.name == 'checkJarCompatibility') return // This doesn't work in FG6 dev, I think it's cuz we check vs srg names. Will need to look at later
+        	all.configure { dependsOn(task) }
+	    }
+    }
+}
+*/
+// endregion
+// We dont have any unit tests, so disable this error
+tasks.withType(AbstractTestTask).configureEach {
+    failOnNoDiscoveredTests = false
+}
+// This shouldn't be needed according to the Gradle devs, as we never run these commands together.
+// But in another case of Gradle being gradle, here we are
+[ 'makePatches', 'compileJava', 'checkLicenseMain', 'updateLicenseMain', 'sourcesJar', 'sourcesJarAll' ]
+        .each{ tasks.named(it).configure{ mustRunAfter forgedev.patches.apply }}
+forgedev.runs.configureEach {
+    run.configure { dependsOn finalizeSpawn}
+    runTest.configure { dependsOn finalizeSpawn}
+}
+
+// run gradlew dependencyUpdates --no-parallel
+//noinspection UnnecessaryQualifiedReference
+tasks.named('dependencyUpdates', com.github.benmanes.gradle.versions.updates.DependencyUpdatesTask) {
+    resolutionStrategy {
+        mcpBase.dependencies.get().forEach {dep -> force(dep) } // Force all vanilla dependencies to their correct versions
+        force(earlyDisplayLibs.slf4j.jdk14) // Force slf4j implementation, its tied to the api from the manifest
+    }
+}

buildSrc/.gitignore

@@ -1,3 +0,0 @@
-/.gradle/
-/build/
-/out/

buildSrc/build.gradle

@@ -1,13 +0,0 @@
-repositories {
-    maven { url = 'https://maven.minecraftforge.net/' }
-    mavenCentral()
-}
-
-dependencies {
-    implementation 'org.ow2.asm:asm:9.8'
-    implementation 'org.ow2.asm:asm-tree:9.8'
-    implementation 'net.minecraftforge:srgutils:0.5.10'
-    implementation 'commons-io:commons-io:2.13.0'
-    implementation 'com.google.code.gson:gson:2.10.1'
-    implementation 'org.eclipse.jgit:org.eclipse.jgit:6.7.0.202309050840-r'
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/BundleList.groovy

@@ -1,70 +0,0 @@
-package net.minecraftforge.forge.tasks
-
-import org.gradle.api.tasks.*
-import org.gradle.api.DefaultTask
-import org.gradle.api.file.ConfigurableFileCollection
-import org.gradle.api.file.RegularFileProperty
-import org.gradle.api.tasks.bundling.AbstractArchiveTask
-
-import java.util.zip.ZipFile
-
-abstract class BundleList extends DefaultTask {
-    @InputFiles abstract ConfigurableFileCollection getConfig()
-    @InputFiles abstract ConfigurableFileCollection getConfigExtra()
-    @InputFile abstract RegularFileProperty getServerBundle()
-    @OutputFile abstract RegularFileProperty getOutput()
-
-    BundleList() {
-        config.setFrom(project.configurations.installer)
-        configExtra.setFrom(project.configurations.installerextra)
-        output.convention(project.layout.buildDirectory.file("$name/output.list"))
-        configure {
-            dependsOn(project.tasks.universalJar)
-            inputs.file(project.tasks.universalJar.archiveFile)
-        }
-    }
-    
-    @TaskAction
-    void run() {
-        def entries = [:] as TreeMap
-        def resolved = project.configurations.installer.resolvedConfiguration.resolvedArtifacts
-        for (def dep : resolved) {
-            def info = Util.getMavenInfoFromDep(dep)
-            //println("$dep.file.sha1\t$info.name\t$info.path")
-            entries.put("$info.art.group:$info.art.name", "$dep.file.sha256\t$info.name\t$info.path")
-        }
-
-        resolved = project.configurations.installerextra.resolvedConfiguration.resolvedArtifacts
-        for (def dep : resolved) {
-            def info = Util.getMavenInfoFromDep(dep)
-            //println("$dep.file.sha1\t$info.name\t$info.path")
-            entries.put("$info.art.group:$info.art.name", "$dep.file.sha256\t$info.name\t$info.path")
-        }
-
-        var packed = (AbstractArchiveTask) project.tasks.universalJar
-        var info = Util.getMavenInfoFromTask(packed)
-        def file = packed.archiveFile.get().asFile
-        entries.put("$info.art.group:$info.art.name:$info.art.classifier", "$file.sha256\t$info.name\t$info.path")
-
-        var classifier = 'server'
-        var genned = project.tasks.applyServerBinPatches
-        info = Util.getMavenInfoFromTask(genned, classifier)
-        file = genned.output.get().asFile
-        entries.put("$info.art.group:$info.art.name:$info.art.classifier", "$file.sha256\t$info.name\t$info.path")
-        
-        try (def zip = new ZipFile(serverBundle.get().asFile)) {
-            def entry = zip.getEntry('META-INF/libraries.list')
-            def data = zip.getInputStream(entry).text.split('\n')
-            for (def line : data) {
-                def (sha, artifact, path) = line.split('\t')
-                def (group, name, other) = artifact.split(':', 3)
-                //println("Group: $group Name: $name")
-                def key = "$group:$name"
-                if (!entries.containsKey(key))
-                    entries.put(key, line)
-            }
-        }
-        
-        output.get().asFile.text = entries.values().join('\n')
-    }
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/BytecodeFinder.groovy

@@ -1,52 +0,0 @@
-package net.minecraftforge.forge.tasks
-
-import groovy.json.JsonBuilder
-import groovy.transform.CompileStatic
-import org.gradle.api.DefaultTask
-import org.gradle.api.file.RegularFileProperty
-import org.gradle.api.tasks.InputFile
-import org.gradle.api.tasks.Internal
-import org.gradle.api.tasks.TaskAction
-import org.objectweb.asm.tree.ClassNode
-import org.objectweb.asm.tree.FieldNode
-import org.objectweb.asm.tree.MethodNode
-
-@CompileStatic
-abstract class BytecodeFinder extends DefaultTask {
-    @InputFile abstract RegularFileProperty getJar()
-    // It should be fine to mark the output as internal as we want to control when we run it anyways.
-    // This also shuts Gradle 8 up about implicit task dependencies.
-    @Internal abstract RegularFileProperty getOutput()
-
-    BytecodeFinder() {
-        output.convention(project.layout.buildDirectory.dir(name).map { it.file("output.json") })
-    }
-
-    @TaskAction
-    protected void exec() {
-        Util.init()
-
-        var outputFile = output.get().asFile
-        if (outputFile.exists())
-            outputFile.delete()
-
-        pre()
-
-        Util.processClassNodes(jar.get().asFile, this.&process)
-
-        post()
-        outputFile.text = new JsonBuilder(getData()).toPrettyString()
-    }
-
-
-    protected process(ClassNode node) {
-        if (node.fields !== null) node.fields.each { process(node, it) }
-        if (node.methods !== null) node.methods.each { process(node, it) }
-    }
-
-    protected pre() {}
-    protected process(ClassNode parent, FieldNode node) {}
-    protected process(ClassNode parent, MethodNode node) {}
-    protected post() {}
-    protected abstract Object getData()
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/BytecodePredicateFinder.groovy

@@ -1,48 +0,0 @@
-package net.minecraftforge.forge.tasks
-
-import groovy.transform.CompileStatic
-import org.gradle.api.provider.Property
-import org.gradle.api.tasks.Internal
-import org.objectweb.asm.Opcodes
-import org.objectweb.asm.tree.ClassNode
-import org.objectweb.asm.tree.MethodNode
-
-@CompileStatic
-abstract class BytecodePredicateFinder extends BytecodeFinder {
-
-    @Internal
-    abstract Property<Closure<Boolean>> getPredicate()
-
-    private final Map<String, List<String>> matches = new TreeMap<>(Comparator.naturalOrder())
-
-    @Override
-    protected process(ClassNode parent, MethodNode node) {
-        for (final current : node.instructions) {
-            if (predicate.get().call(parent, node, current)) {
-                var methods = matches.compute(parent.name, { k, v -> v ?: new ArrayList<>() })
-
-                // only add non-synthetic methods
-                if ((node.access & Opcodes.ACC_SYNTHETIC) == 0) {
-                    methods.add(node.name + node.desc)
-                }
-
-                return
-            }
-        }
-    }
-
-    @Internal
-    @Override
-    protected Object getData() {
-        var array = new ArrayList<Object>()
-        matches.forEach { c, m ->
-            {
-                array.add(
-                        'class': c,
-                        'methods': m
-                )
-            }
-        }
-        return array ?: { throw new RuntimeException('Failed to find any targets, please ensure that method names and descriptors are correct.') }()
-    }
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/CleanProperties.groovy

@@ -1,97 +0,0 @@
-package net.minecraftforge.forge.tasks;
-
-import groovy.transform.CompileDynamic;
-import groovy.transform.CompileStatic;
-
-import java.util.Properties;
-import java.util.Enumeration;
-import java.util.Map;
-import java.util.TreeSet;
-
-import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.Reader;
-import java.io.InputStreamReader;
-import java.io.IOException;
-import java.io.OutputStream;
-import java.io.Writer;
-import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
-import java.util.Collections;
-import java.util.Set;
-
-/**
- * Eclipse config files are literally just java properties, with the header cleaned up.
- * https://github.com/eclipse/buildship/blob/5b2c7fca7fa86cd74d71b3c099c7b1559eba038e/org.eclipse.buildship.core/src/main/java/org/eclipse/buildship/core/internal/configuration/PreferenceStore.java#L238
- *
- * This does the same thing, as well as sorting alphabetically.
- * It also ignores all comments. We can add them latter if someone cares.
- */
-@CompileStatic
-public class CleanProperties extends Properties {
-    private static final long serialVersionUID = 1L;
-    private static final String LINE_SEP = System.getProperty("line.separator");
-    private static final String UNIX_LINE_SEP = "\n";
-    private static final Charset ENCODING = StandardCharsets.UTF_8;
-
-    public CleanProperties load(File input) throws IOException {
-        if (input.exists()) {
-            try (Reader is = new InputStreamReader(new FileInputStream(input), ENCODING)) {
-                super.load(is);
-            }
-        }
-        return this;
-    }
-
-    public void store(File out) throws IOException {
-        if (!out.getParentFile().exists())
-            out.getParentFile().mkdirs();
-
-        try (OutputStream os = new FileOutputStream(out)) {
-            store(os, null);
-        }
-    }
-
-    @Override
-    public synchronized Enumeration<Object> keys() {
-        Set<Object> ret = new TreeSet<>();
-        for (Enumeration<?> e = super.keys(); e.hasMoreElements();)
-            ret.add(e.nextElement());
-        return Collections.enumeration(ret);
-    }
-
-    @CompileDynamic
-    @Override
-    public Set<Map.Entry<Object, Object>> entrySet() {
-        Set<Map.Entry<Object, Object>> ret = new TreeSet<>((l, r) -> ((String)l.getKey()).compareTo((String)r.getKey()));
-        ret.addAll(super.entrySet());
-        return ret;
-    }
-
-    @Override
-    public void store(OutputStream out, String comments) throws IOException {
-        out.write(clean().getBytes(ENCODING));
-        out.flush();
-    }
-
-    @Override
-    public void store(Writer out, String comments) throws IOException {
-        out.write(clean());
-        out.flush();
-    }
-
-    private String clean() throws IOException {
-        ByteArrayOutputStream tmp = new ByteArrayOutputStream();
-        try {
-            super.store(tmp, null);
-        } finally {
-            tmp.close();
-        }
-
-        String ret = tmp.toString(ENCODING).replace(LINE_SEP, UNIX_LINE_SEP);
-        ret = ret.substring(ret.indexOf(UNIX_LINE_SEP) + 1);
-        return ret;
-    }
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/ClosureHelper.groovy

@@ -1,33 +0,0 @@
-package net.minecraftforge.forge.tasks
-
-import groovy.transform.stc.FirstParam
-
-import java.util.function.BiConsumer
-
-public class ClosureHelper {
-    BiConsumer<String, Closure> callback
-    
-    public ClosureHelper(Closure cl, BiConsumer<String, Closure> callback) {
-        this.callback = callback
-        apply(this, cl)
-    }
-    
-    
-    def methodMissing(String name, Object args) {
-        if (!args.class.isArray()) return
-        Object[] aargs = (Object[])args
-        
-        if (aargs.length == 1 && aargs[0] instanceof Closure) {
-            this.callback.accept(name, (Closure)aargs[0])
-        } else {
-            throw new IllegalArgumentException('Unknown method: "' + name + '" with arguments ' + args + ' for ' + this)
-        }
-    }
-    
-    static <T> T apply(T obj, @DelegatesTo(value = FirstParam, strategy = Closure.DELEGATE_FIRST) Closure cl) {
-        cl.delegate = obj
-        cl.resolveStrategy = Closure.DELEGATE_FIRST
-        cl()
-        return obj
-    }
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/DownloadLibraries.groovy

@@ -1,54 +0,0 @@
-package net.minecraftforge.forge.tasks
-
-import org.gradle.api.DefaultTask
-import org.gradle.api.file.ConfigurableFileCollection
-import org.gradle.api.file.DirectoryProperty
-import org.gradle.api.file.RegularFileProperty
-import org.gradle.api.tasks.InputFile
-import org.gradle.api.tasks.Internal
-import org.gradle.api.tasks.OutputFile
-import org.gradle.api.tasks.OutputFiles
-import org.gradle.api.tasks.TaskAction
-import org.gradle.api.tasks.OutputDirectory
-
-import java.nio.file.Files
-
-abstract class DownloadLibraries extends DefaultTask {
-	@InputFile abstract RegularFileProperty getInput()
-	@OutputDirectory abstract DirectoryProperty getOutput()
-	@OutputFile abstract RegularFileProperty getLibrariesOutput()
-
-    DownloadLibraries() {
-		output.convention(project.layout.buildDirectory.dir(name))
-        librariesOutput.convention(project.layout.buildDirectory.dir(name).map(d -> d.file('libraries.txt')))
-	}
-
-    @TaskAction
-    def run() {
-		Util.init()
-		File outputDir = output.get().asFile
-        var libraries = new ArrayList<String>()
-
-		def json = input.get().asFile.json().libraries.each { lib ->
-		    //TODO: Thread?
-			def artifacts = [lib.downloads.artifact] + lib.downloads.get('classifiers', [:]).values()
-			artifacts.each{ art -> 
-				def target = new File(outputDir, art.path)
-				libraries.add(target.absolutePath)
-				if (!target.exists() || art.sha1 != target.sha1()) {
-					project.logger.lifecycle("Downloading ${art.url}")
-					if (!target.parentFile.exists()) {
-						target.parentFile.mkdirs()
-					}
-					new URL(art.url).withInputStream { i ->
-						target.withOutputStream { it << i }
-					}
-					if (art.sha1 != target.sha1()) {
-						throw new IllegalStateException("Failed to download ${art.url} to ${target.canonicalPath} SHA Mismatch")
-					}
-				}
-			}
-		}
-        Files.write(librariesOutput.get().asFile.toPath(), libraries)
-    }
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/ExtractFile.groovy

@@ -1,28 +0,0 @@
-package net.minecraftforge.forge.tasks
-
-import groovy.transform.CompileStatic
-import org.gradle.api.DefaultTask
-import org.gradle.api.file.RegularFileProperty
-import org.gradle.api.provider.Property
-import org.gradle.api.tasks.*
-
-import java.util.zip.ZipFile
-
-@CompileStatic
-abstract class ExtractFile extends DefaultTask {
-    @InputFile abstract RegularFileProperty getInput()
-    @Input abstract Property<String> getTarget()
-    @OutputFile abstract RegularFileProperty getOutput()
-
-    @TaskAction
-    protected void exec() {
-        var zip = new ZipFile(input.get().asFile);
-        var entry = zip.getEntry(target.get())
-        if (entry == null)
-            throw new IllegalStateException(input.get().asFile.absolutePath + " does not contain " + target.get())
-        var stream = zip.getInputStream(entry)
-        output.get().asFile.withOutputStream { out ->
-            stream.transferTo(out)
-        }
-    }
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/FieldCompareFinder.groovy

@@ -1,101 +0,0 @@
-package net.minecraftforge.forge.tasks
-
-import groovy.transform.CompileStatic
-import groovy.transform.EqualsAndHashCode
-
-import org.gradle.api.tasks.*
-import org.objectweb.asm.tree.AbstractInsnNode
-import org.objectweb.asm.tree.ClassNode
-import org.objectweb.asm.tree.MethodNode
-
-import static org.objectweb.asm.Opcodes.*
-
-abstract class FieldCompareFinder extends BytecodeFinder {
-    @Nested
-    Map<String, Search> fields = [:] as HashMap
-    @Internal
-    Map<Search, String> fieldsReverse = [:] as HashMap
-    @Internal
-    Map<String, Set<ObjectTarget>> targets = [:] as TreeMap
-    
-    @Override
-    protected pre() {
-        //fields.each{ k,v -> logger.lifecycle("Fields: " + k + ' ' + v) }
-    }
-    
-    @Override
-    protected process(ClassNode parent, MethodNode node) {
-        AbstractInsnNode last = null
-        def parentInstance = new ObjectTarget(owner: parent.name, name: '', desc: '')
-        for (int x = 0; x < node.instructions.size(); x++) {
-            def current = node.instructions.get(x)
-            if (current.opcode === IF_ACMPEQ || current.opcode === IF_ACMPNE) {
-                if (last !== null && (last.opcode === GETSTATIC || last.opcode === GETFIELD)) {
-                    def target = new Search(cls: last.owner, name: last.name)
-                    def wanted = fieldsReverse.get(target)
-                    def original = fields.get(wanted)
-                    def instance = new ObjectTarget(owner: parent.name, name: node.name, desc: node.desc)
-                    if (wanted !== null && (original.blacklist === null || (!original.blacklist.contains(instance) && !original.blacklist.contains(parentInstance)))) {
-                        targets.computeIfAbsent(wanted, { k -> new TreeSet() }).add(instance)
-                    }
-                }
-            }
-            last = current
-        }
-    }
-    
-    @Internal
-    @Override
-    protected Object getData() {
-		def ret = [:] as HashMap
-		targets.forEach{ k, v -> 
-			def e = fields.get(k)
-			ret[k] = [
-				cls: e.cls, 
-				name: e.name, 
-				replacement: e.replacement, 
-				targets: v
-			]
-		}
-        return ret
-    }
-
-    @CompileStatic
-    @EqualsAndHashCode(excludes = ['replacement', 'blacklist'])
-    static class Search {
-        @Input
-        String cls
-        
-        @Input
-        String name
-		
-		@Input
-		String replacement
-    
-        @Nested
-        @Optional
-        Set<ObjectTarget> blacklist
-        
-        @Override
-        String toString() {
-            return cls + '.' + name
-        }
-        
-        def blacklist(String owner, String name, String desc) {
-            if (blacklist === null)
-                blacklist = new HashSet<>()
-            blacklist.add(new ObjectTarget(owner: owner, name: name, desc: desc))
-        }
-        def blacklist(String owner) {
-            blacklist(owner, '', '')
-        }
-    }
-    
-    void fields(Closure cl) {
-        new ClosureHelper(cl, {name, ccl ->
-            def search = ClosureHelper.apply(new Search(), ccl)
-            this.fields.put(name, search)
-            this.fieldsReverse.put(search, name)
-        })
-    }
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/InheritanceData.groovy

@@ -1,49 +0,0 @@
-package net.minecraftforge.forge.tasks
-
-import com.google.gson.Gson
-import com.google.gson.reflect.TypeToken
-import groovy.transform.CompileStatic
-import groovy.transform.TupleConstructor
-
-@CompileStatic
-@TupleConstructor
-final class InheritanceData implements Annotatable {
-    String name
-    int access
-    String superName
-    List<String> interfaces = []
-    Map<String, Method> methods = [:]
-    Map<String, Field> fields = [:]
-    List<Annotation> annotations = []
-
-    @TupleConstructor
-    static final class Method implements Annotatable {
-        int access
-        String override
-        List<Annotation> annotations = []
-    }
-
-    @TupleConstructor
-    static final class Field implements Annotatable {
-        int access
-        String desc
-        List<Annotation> annotations = []
-    }
-
-    @TupleConstructor
-    static final class Annotation {
-        String desc
-    }
-
-    private static final Gson GSON = new Gson()
-    static Map<String, InheritanceData> parse(File file) {
-        try (final reader = file.newReader()) {
-            return GSON.fromJson(reader, new TypeToken<Map<String, InheritanceData>>() {})
-        }
-    }
-}
-
-@CompileStatic
-interface Annotatable {
-    List<InheritanceData.Annotation> getAnnotations()
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/InstallerJar.groovy

@@ -1,158 +0,0 @@
-package net.minecraftforge.forge.tasks
-
-import org.gradle.api.file.DuplicatesStrategy
-import org.gradle.api.tasks.bundling.AbstractArchiveTask
-import org.gradle.api.tasks.bundling.Zip
-import org.gradle.api.tasks.*
-import org.gradle.api.DefaultTask
-import org.gradle.api.provider.Property
-import groovy.json.JsonSlurper
-
-abstract class InstallerJar extends Zip {
-    @Input @Optional abstract Property<Boolean> getFat()
-    @Input @Optional abstract Property<Boolean> getOffline()
-
-    InstallerJar() {
-        archiveClassifier.set('installer')
-        archiveExtension.set('jar') // Needs to be Zip task to not override Manifest, so set extension
-        destinationDirectory.set(project.layout.buildDirectory.dir('libs'))
-        fat.convention(false)
-        offline.convention(false)
-
-        def installerJson = project.tasks.installerJson
-        def launcherJson = project.tasks.launcherJson
-        def downloadInstaller = project.tasks.downloadInstaller
-
-        dependsOn(installerJson, launcherJson, downloadInstaller, project.configurations.installer)
-        from(installerJson, launcherJson)
-
-        from(project.rootProject.file('/src/main/resources/url.png'))
-        project.afterEvaluate {
-            from(project.zipTree(downloadInstaller.output)) {
-                duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-            }
-            
-            if (fat.get() || offline.get()) {
-                def cfg = project.tasks.register(name + "Config", Configure)
-                cfg.get().configure {
-                    parent = this
-                    dependsOn(project.tasks.installerJson, project.tasks.launcherJson)
-                }
-                dependsOn(cfg)
-            } else {
-                // Things we ALWAYS bundle, this just the server shim jar, because the installer spec only says to extract the file. 
-                // I should make it allow downloads but thats a spec break, and this is just a ~14KB jar
-                [
-                    project.tasks.serverShimJar // Server bootstrap executable jar
-                ].forEach { AbstractArchiveTask packed ->
-                    def path = Util.getMavenInfoFromTask(packed).path
-                    from(packed) {
-                        rename { "maven/$path" }
-                    }
-                }
-            }
-        }
-    }
-    
-    static abstract class Configure extends DefaultTask {
-        public Zip parent
-        private int count = 0;
-        
-        @TaskAction
-        protected void exec() {
-            def deps = [:] as java.util.TreeMap
-            
-            // Gather all things that need downloading
-            [
-                project.tasks.installerJson, 
-                project.tasks.launcherJson
-            ].each { task ->
-                def json = task.output.get().asFile.json
-                json.libraries.each { lib -> 
-                    if (lib.downloads?.artifact?.url !== null && !lib.downloads.artifact.url.isEmpty())
-                        deps.put(lib.name, lib.downloads.artifact)
-                }
-            }
-            
-            // First find things we build in this project.
-            [
-                project.tasks.universalJar, // Forge runtime code
-                project.tasks.serverShimJar // Shim jar for dedicated server
-            ].forEach { AbstractArchiveTask packed ->
-                def name = Util.getMavenInfoFromTask(packed).name
-                def info = deps.remove(name)
-                if (info !== null) {
-                    println("Adding: $packed.path $name")
-                    parent.from(packed) {
-                        rename { "maven/$info.path" }
-                    }
-                }
-            }
-            
-            // Find any artifacts from the 'installer' config
-            // This config specifies the runtime files we intend for the interaller to have.
-            // And are typically what we would be developing and testing alongside Forge. 
-            // So we may have local modified versions
-            def cfg = project.configurations.installer
-            while (cfg != null) {
-                //println('')
-                def resolved = cfg.resolvedConfiguration.resolvedArtifacts
-                int found = 0
-                for (def dep : resolved) {
-                    def name = Util.getMavenInfoFromDep(dep).name
-                    def info = deps.remove(name)
-                    if (info == null) {
-                        //println("Skipping: $name")
-                        continue
-                    }
-                    //println("-$name")
-                    found++
-                    addFile(dep.file, info)
-                }
-                
-                if (deps.isEmpty()) {
-                    cfg = null
-                    continue
-                }
-                
-                // Prevent infinite loops if something fucky happens
-                if (found == 0)
-                    throw new IllegalStateException("Failed to find any installer dependencies") 
-                
-                def seen = [] as Set
-                cfg = project.configurations.detachedConfiguration()
-                cfg.transitive = false
-                for (def key : deps.keySet()) {
-                    def (group, artifact, other) = key.split(':', 3)
-                    // Only resolve unique group:artifact so we don't get version overrides
-                    if (seen.add(group + ':' + artifact)) {
-                        //println("+$key")
-                        cfg.dependencies.add(project.dependencies.create(key))
-                    }
-                }
-            }
-        }
-        
-        void addFile(file, info) {
-            boolean pack = parent.offline.get() || info.url.isEmpty()
-            
-            // If it's a offline jar just always pack
-            if (!pack) {
-                try {
-                    var remote = new URL("${info.url}.sha1").getText('UTF-8')
-                    pack = info.sha1 != remote
-                } catch (FileNotFoundException e) {
-                    pack = !info.url.startsWith('https://libraries.minecraft.net/')
-                    // Oh noes its not there!
-                }
-            }
-            
-            if (pack) {
-                println("Adding: $file.absolutePath")
-                parent.from(file) {
-                    rename { "maven/$info.path" }
-                }
-            }
-        }
-    }
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/InstallerJson.groovy

@@ -1,73 +0,0 @@
-package net.minecraftforge.forge.tasks
-
-import groovy.json.JsonBuilder
-import org.gradle.api.DefaultTask
-import org.gradle.api.file.ConfigurableFileCollection
-import org.gradle.api.file.RegularFileProperty
-import org.gradle.api.provider.Property
-import org.gradle.api.provider.SetProperty
-import org.gradle.api.tasks.*
-import org.gradle.api.tasks.bundling.AbstractArchiveTask
-
-import java.nio.file.Files
-
-abstract class InstallerJson extends DefaultTask {
-    @OutputFile abstract RegularFileProperty getOutput()
-    @InputFiles abstract ConfigurableFileCollection getInput()
-    @Input @Optional final Map<String, Object> libraries = new LinkedHashMap<>()
-    @Input Map<String, Object> json = new LinkedHashMap<>()
-    @InputFile abstract RegularFileProperty getIcon()
-    @Input abstract Property<String> getLauncherJsonName()
-    @Input abstract Property<String> getLogo()
-    @Input abstract Property<String> getMirrors()
-    @Input abstract Property<String> getWelcome()
-
-    InstallerJson() {
-        launcherJsonName.convention('/version.json')
-        logo.convention('/big_logo.png')
-        mirrors.convention('https://files.minecraftforge.net/mirrors-2.0.json')
-        welcome.convention("Welcome to the ${project.name.capitalize()} installer.")
-        output.convention(project.layout.buildDirectory.file('libs/install_profile.json'))
-        
-        project.afterEvaluate {
-            [
-                project.tasks.universalJar,
-                project.tasks.serverShimJar
-            ].forEach { packed ->
-                dependsOn(packed)
-                input.from packed.archiveFile
-            }
-        }
-    }
-
-    @TaskAction
-    protected void exec() {
-        def libs = libraries
-        [
-            project.tasks.universalJar,
-            project.tasks.serverShimJar
-        ].forEach { AbstractArchiveTask packed ->
-            def info = Util.getMavenInfoFromTask(packed)
-            libs.put(info.name, [
-                name: info.name,
-                downloads: [
-                    artifact: [
-                        path: info.path,
-                        url: "https://maven.minecraftforge.net/$info.path",
-                        sha1: packed.archiveFile.get().asFile.sha1(),
-                        size: packed.archiveFile.get().asFile.length()
-                    ]
-                ]
-            ])
-        }
-        json.libraries = libs.values().sort{a,b -> a.name.compareTo(b.name)}
-        json.icon = "data:image/png;base64," + new String(Base64.getEncoder().encode(Files.readAllBytes(icon.get().asFile.toPath())))
-        json.json = launcherJsonName.get()
-        json.logo = logo.get()
-        if (!mirrors.get().isEmpty())
-            json.mirrorList = mirrors.get()
-        json.welcome = welcome.get()
-
-        Files.writeString(output.get().getAsFile().toPath(), new JsonBuilder(json).toPrettyString())
-    }
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/LauncherJson.groovy

@@ -1,96 +0,0 @@
-package net.minecraftforge.forge.tasks
-
-import groovy.json.JsonBuilder
-import org.gradle.api.DefaultTask
-import org.gradle.api.file.ConfigurableFileCollection
-import org.gradle.api.file.RegularFileProperty
-import org.gradle.api.provider.SetProperty
-import org.gradle.api.tasks.*
-import org.gradle.api.tasks.bundling.AbstractArchiveTask
-
-import java.nio.file.Files
-
-import static net.minecraftforge.forge.tasks.Util.getArtifacts
-import static net.minecraftforge.forge.tasks.Util.iso8601Now
-
-abstract class LauncherJson extends DefaultTask {
-    @OutputFile abstract RegularFileProperty getOutput()
-    @InputFiles abstract ConfigurableFileCollection getInput()
-    @Input Map<String, Object> json = new LinkedHashMap<>()
-
-    LauncherJson() {
-        output.convention(project.layout.buildDirectory.file('libs/version.json'))
-
-        dependsOn(project.tasks.universalJar)
-        input.from(project.tasks.universalJar.archiveFile)
-        input.from(project.configurations.installer)
-        input.from(project.configurations.installerextra)
-        configure {
-            def mc    = project.rootProject.ext.MC_VERSION
-            def forge = project.rootProject.ext.FORGE_VERSION
-            def timestamp = iso8601Now()
-            json.putAll([
-                _comment: [
-                    "Please do not automate the download and installation of Forge.",
-                    "Our efforts are supported by ads from the download page.",
-                    "If you MUST automate this, please consider supporting the project through https://www.patreon.com/LexManos/"
-                ],
-                id: "$mc-$project.name-$forge",
-                time: timestamp,
-                releaseTime: timestamp,
-                inheritsFrom: mc,
-                type: 'release',
-                logging: [:],
-                mainClass: '',
-                libraries: []
-            ] as LinkedHashMap)
-            
-            [
-                project.tasks.universalJar
-            ].forEach { packed ->
-                dependsOn(packed)
-                input.from packed.archiveFile
-            }
-            
-            def patched = project.tasks.applyClientBinPatches
-            dependsOn(patched)
-            input.from patched.output
-        }
-    }
-
-    @TaskAction
-    protected void exec() {
-        var packed = (AbstractArchiveTask) project.tasks.universalJar
-        def info = Util.getMavenInfoFromTask(packed)
-        json.libraries.add([
-            name: info.name,
-            downloads: [
-                artifact: [
-                    path: info.path,
-                    url: "https://maven.minecraftforge.net/$info.path",
-                    sha1: packed.archiveFile.get().asFile.sha1(),
-                    size: packed.archiveFile.get().asFile.length()
-                ]
-            ]
-        ])
-
-        var classifier = 'client'
-        var genned = project.tasks.applyClientBinPatches
-        info = Util.getMavenInfoFromTask(genned, classifier)
-        json.libraries.add([
-            name: info.name,
-            downloads: [
-                artifact: [
-                    path: info.path,
-                    url: "",
-                    sha1: genned.output.get().asFile.sha1(),
-                    size: genned.output.get().asFile.length()
-                ]
-            ]
-        ])
-
-        json.libraries.addAll(getArtifacts(project.configurations.installerextra).values())
-        json.libraries.addAll(getArtifacts(project.configurations.installer).values())
-        Files.writeString(output.get().asFile.toPath(), new JsonBuilder(json).toPrettyString())
-    }
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/MergeJars.groovy

@@ -1,46 +0,0 @@
-package net.minecraftforge.forge.tasks
-
-import groovy.transform.CompileStatic
-import org.apache.commons.io.IOUtils
-import org.gradle.api.DefaultTask
-import org.gradle.api.file.ConfigurableFileCollection
-import org.gradle.api.file.RegularFileProperty
-import org.gradle.api.tasks.InputFiles
-import org.gradle.api.tasks.OutputFile
-import org.gradle.api.tasks.TaskAction
-
-import java.util.zip.ZipEntry
-import java.util.zip.ZipInputStream
-import java.util.zip.ZipOutputStream
-
-@CompileStatic
-abstract class MergeJars extends DefaultTask {
-    MergeJars() {
-        output.convention(project.layout.buildDirectory.dir(name).map { it.file('output.jar') })
-    }
-
-    @TaskAction
-    void run() {
-        def jars = inputJars.files
-
-        try (ZipOutputStream zout = new ZipOutputStream(new FileOutputStream(output.get().asFile))) {
-            for (def jar : jars) {
-                try (ZipInputStream zin = new ZipInputStream(new FileInputStream(jar))) {
-                    ZipEntry entry
-                    while ((entry = zin.getNextEntry()) !== null) {
-                        ZipEntry _new = new ZipEntry(entry.getName())
-                        _new.setTime(0) //SHOULD be the same time as the main entry, but NOOOO _new.setTime(entry.getTime()) throws DateTimeException, so you get 0, screw you!
-                        zout.putNextEntry(_new)
-                        IOUtils.copy(zin, zout)
-                    }
-                }
-            }
-        }
-    }
-
-    @InputFiles
-    abstract ConfigurableFileCollection getInputJars()
-
-    @OutputFile
-    abstract RegularFileProperty getOutput()
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/ObjectTarget.groovy

@@ -1,32 +0,0 @@
-package net.minecraftforge.forge.tasks
-
-import groovy.transform.EqualsAndHashCode
-
-import org.gradle.api.tasks.Input
-import org.gradle.api.tasks.Nested
-import org.gradle.api.tasks.Optional
-
-@EqualsAndHashCode
-public class ObjectTarget implements Comparable<ObjectTarget> {
-    @Input
-    String owner
-    
-    @Input
-    String name
-    
-    @Input
-    @Optional
-    String desc
-    
-    @Override
-    String toString() {
-        if (desc == null)
-            return owner + '.' + name
-        return owner + '.' + name + desc
-    }
-    
-    @Override
-    int compareTo(ObjectTarget o) {
-        return toString() <=> o.toString()
-    }
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/SetupCheckJarCompatibility.groovy

@@ -1,47 +0,0 @@
-package net.minecraftforge.forge.tasks
-
-import org.gradle.api.DefaultTask
-import org.gradle.api.artifacts.Dependency
-import org.gradle.api.file.RegularFileProperty
-import org.gradle.api.provider.Property
-import org.gradle.api.tasks.Input
-import org.gradle.api.tasks.Optional
-import org.gradle.api.tasks.OutputFile
-import org.gradle.api.tasks.TaskAction
-
-import java.nio.file.Files
-import java.nio.file.StandardCopyOption
-
-abstract class SetupCheckJarCompatibility extends DefaultTask {
-    SetupCheckJarCompatibility() {
-        group = 'jar compatibility'
-        onlyIf {
-            inputVersion.getOrNull() !== null
-        }
-        outputs.upToDateWhen { false } // Never up to date, because this setup task should always run
-
-        baseBinPatchesOutput.convention(project.layout.buildDirectory.dir(name).map { it.file('joined.lzma') })
-    }
-
-    @TaskAction
-    void run() {
-        def inputVersion = inputVersion.get()
-
-        def baseForgeUserdev = project.layout.buildDirectory.dir(name).map { it.file("forge-${inputVersion}-userdev.jar") }.get().asFile
-        project.rootProject.extensions.download.run {
-            src "https://maven.minecraftforge.net/net/minecraftforge/forge/${inputVersion}/forge-${inputVersion}-userdev.jar"
-            dest baseForgeUserdev
-        }
-
-        def joinedLzma = project.zipTree(baseForgeUserdev).matching { it.include('joined.lzma') }.singleFile
-
-        Files.copy(joinedLzma.toPath(), baseBinPatchesOutput.get().asFile.toPath(), StandardCopyOption.REPLACE_EXISTING)
-    }
-
-    @Input
-    @Optional
-    abstract Property<String> getInputVersion()
-
-    @OutputFile
-    abstract RegularFileProperty getBaseBinPatchesOutput()
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/TeamcityRequests.groovy

@@ -1,74 +0,0 @@
-package net.minecraftforge.forge.tasks
-
-import com.google.gson.Gson
-import com.google.gson.reflect.TypeToken
-import groovy.transform.CompileStatic
-import org.eclipse.jgit.api.Git
-
-import javax.annotation.Nullable
-import java.util.stream.Collectors
-
-@CompileStatic
-class TeamcityRequests {
-    public static final Gson GSON = new Gson()
-
-    @Nullable
-    static <T> T jsonRequest(TypeToken<T> clazz, String url) throws Exception {
-        final HttpURLConnection conn = (HttpURLConnection) URI.create(url).toURL().openConnection()
-        conn.setRequestProperty('Accept', 'application/json')
-        conn.setReadTimeout(5 * 1000)
-        conn.setConnectTimeout(5 * 1000)
-        conn.connect()
-
-        if (conn.responseCode !== 200) {
-            return null
-        }
-
-        try (final InputStream is = conn.getInputStream()) {
-            GSON.fromJson(new InputStreamReader(is), clazz.getType())
-        }
-    }
-
-    @Nullable
-    static Map<String, Build> buildsByCommit() throws IOException {
-        final Map<String, Build> builds = [:]
-        jsonRequest(new TypeToken<Builds>() {}, 'https://teamcity.minecraftforge.net/guestAuth/app/rest/builds?fields=build:(revisions,number)&locator=buildType:(id:MinecraftForge_MinecraftForge_MinecraftForge_MinecraftForge__Build),defaultFilter:false,count:300,status:SUCCESS')
-                ?.build?.forEach {
-            it.revisions.revision.each { rev -> builds[rev.version] = it }
-        }
-        return builds
-    }
-
-    @Nullable
-    static String attemptFindBase(File gitPath) {
-        try (final git = Git.open(gitPath)) {
-            final Map<String, Build> buildByCommit = buildsByCommit()
-            for (final commit in git.log().setMaxCount(100).call()) {
-                // Find the first commit which was built on CI
-                final build = buildByCommit[commit.id.name]
-                if (build) {
-                    return build.number
-                }
-            }
-        } catch (Exception ignored) {}
-        return null
-    }
-
-    static final class Builds {
-        public List<Build> build
-    }
-
-    static final class Build {
-        public String number
-        public Revisions revisions
-    }
-
-    static final class Revisions {
-        public int count
-        public List<Revision> revision
-    }
-
-    static final class Revision {
-        public String version
-    }
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/Util.groovy

@@ -1,230 +0,0 @@
-package net.minecraftforge.forge.tasks
-
-import groovy.json.JsonBuilder
-import groovy.json.JsonSlurper
-import groovy.transform.CompileStatic
-import groovy.transform.stc.ClosureParams
-import groovy.transform.stc.SimpleType
-import org.gradle.api.Project
-import org.gradle.api.Task
-import org.gradle.api.artifacts.Configuration
-import org.gradle.api.artifacts.ResolvedArtifact
-import org.gradle.api.tasks.bundling.AbstractArchiveTask
-import org.objectweb.asm.ClassReader
-import org.objectweb.asm.Opcodes
-import org.objectweb.asm.tree.ClassNode
-
-import java.net.http.HttpClient
-import java.net.http.HttpRequest
-import java.net.http.HttpResponse
-import java.security.MessageDigest
-import java.text.SimpleDateFormat
-import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.Semaphore
-import java.util.zip.ZipEntry
-import java.util.zip.ZipInputStream
-
-final class Util {
-    public static final int ASM_LEVEL = Opcodes.ASM9
-    private static final HttpClient HTTP = HttpClient.newBuilder().build()
-
-    static void init() {
-        File.metaClass.sha1 = { ->
-            MessageDigest md = MessageDigest.getInstance('SHA-1')
-            delegate.eachByte(4096) { byte[] bytes, int size ->
-                md.update(bytes, 0, size)
-            }
-            return md.digest().collect(this.&toHex).join('')
-        }
-        File.metaClass.getSha1 = { !delegate.exists() ? null : delegate.sha1() }
-        File.metaClass.sha256 = { ->
-            MessageDigest md = MessageDigest.getInstance('SHA-256')
-            delegate.eachByte(4096) { byte[] bytes, int size ->
-                md.update(bytes, 0, size)
-            }
-            return md.digest().collect(this.&toHex).join('')
-        }
-        File.metaClass.getSha256 = { !delegate.exists() ? null : delegate.sha256() }
-
-        File.metaClass.json = { -> new JsonSlurper().parseText(delegate.text) }
-        File.metaClass.getJson = { return delegate.exists() ? new JsonSlurper().parse(delegate) : [:] }
-        File.metaClass.setJson = { json -> delegate.text = new JsonBuilder(json).toPrettyString() }
-
-        Date.metaClass.iso8601 = { ->
-            var format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
-            var result = format.format(delegate)
-            return result[0..21] + ':' + result[22..-1]
-        }
-
-        String.metaClass.rsplit = { String del, int limit = -1 ->
-            var lst = new ArrayList<String>()
-            int x = 0
-            int idx
-            String tmp = delegate
-            while ((idx = tmp.lastIndexOf(del)) != -1 && (limit === -1 || x++ < limit)) {
-                lst.add(0, tmp.substring(idx + del.length(), tmp.length()))
-                tmp = tmp.substring(0, idx)
-            }
-            lst.add(0, tmp)
-            return lst
-        }
-    }
-
-    static String[] getClasspath(Project project, Map libs, String artifact) {
-        def ret = []
-        artifactTree(project, artifact).each { key, lib ->
-            libs[lib.name] = lib
-            if (lib.name != artifact)
-                ret.add(lib.name)
-        }
-        return ret
-    }
-
-    @CompileStatic
-    static Map getArtifacts(Configuration config) {
-        var ret = [:]
-        var semaphore = new Semaphore(1, true)
-        config.resolvedConfiguration.resolvedArtifacts.parallelStream().forEachOrdered(dep -> {
-            var info = getMavenInfoFromDep(dep)
-            var domain = 'libraries.minecraft.net'
-            var url = "https://$domain/$info.path"
-            if (!checkExists(url))
-                url.values[0] = 'maven.minecraftforge.net'
-
-            var sha1 = sha1(dep.file)
-
-            semaphore.acquire()
-            ret[info.key] = [
-                name: info.name,
-                downloads: [
-                    artifact: [
-                        path: info.path,
-                        url: url.toString(),
-                        sha1: sha1,
-                        size: dep.file.length()
-                    ]
-                ]
-            ]
-            semaphore.release()
-        })
-        return ret
-    }
-
-    @CompileStatic
-    static Map getMavenInfoFromDep(ResolvedArtifact dep) {
-        return getMavenInfoFromMap([
-            group: dep.moduleVersion.id.group,
-            name: dep.moduleVersion.id.name,
-            version: dep.moduleVersion.id.version,
-            classifier: dep.classifier,
-            extension: dep.extension
-        ])
-    }
-
-    @CompileStatic
-    static Map getMavenInfoFromTask(AbstractArchiveTask task) {
-        return getMavenInfoFromMap([
-            group: task.project.group.toString(),
-            name: task.project.name,
-            version: task.project.version.toString(),
-            classifier: task.archiveClassifier.get(),
-            extension: task.archiveExtension.get()
-        ])
-    }
-
-    @CompileStatic
-    static Map getMavenInfoFromTask(Task task, String classifier) {
-        return getMavenInfoFromMap([
-            group: task.project.group.toString(),
-            name: task.project.name,
-            version: task.project.version.toString(),
-            classifier: classifier,
-            extension: 'jar'
-        ])
-    }
-
-    @CompileStatic
-    private static Map getMavenInfoFromMap(Map<String, String> art) {
-        var key = "$art.group:$art.name"
-        var name = "$art.group:$art.name:$art.version"
-        var path = "${art.group.replace('.', '/')}/$art.name/$art.version/$art.name-$art.version"
-        if (art.classifier !== null) {
-            name += ":$art.classifier"
-            path += "-$art.classifier"
-        }
-        if ('jar' != art.extension) {
-            name += "@$art.extension"
-            path += ".$art.extension"
-        } else {
-            path += ".jar"
-        }
-        return [
-            key: key.toString(),
-            name: name.toString(),
-            path: path.toString(),
-            art: art
-        ]
-    }
-
-    static String iso8601Now() { new Date().iso8601() }
-
-    @CompileStatic
-    static String sha1(File file) {
-        MessageDigest md = MessageDigest.getInstance('SHA-1')
-        file.eachByte(4096) { byte[] bytes, int size ->
-            md.update(bytes, 0, size)
-        }
-        return md.digest().collect(this.&toHex).join('')
-    }
-
-    @CompileStatic
-    private static String toHex(byte bite) {
-        return String.format('%02x', bite)
-    }
-
-    private static Map artifactTree(Project project, String artifact, boolean transitive = true) {
-        if (!project.ext.has('tree_resolver'))
-            project.ext.tree_resolver = 1
-        def cfg = project.configurations.create('tree_resolver_' + project.ext.tree_resolver++)
-        cfg.transitive = transitive
-        def dep = project.dependencies.create(artifact)
-        cfg.dependencies.add(dep)
-        def files = cfg.resolve()
-        return getArtifacts(cfg)
-    }
-
-    @CompileStatic
-    static boolean checkExists(String url) {
-        try {
-            return HTTP.send(HttpRequest.newBuilder(new URI(url))
-                    .method('HEAD', HttpRequest.BodyPublishers.noBody()).build(), HttpResponse.BodyHandlers.discarding()
-            ).statusCode() === 200
-        } catch (Exception e) {
-            if (e.toString().contains('unable to find valid certification path to requested target'))
-                throw new RuntimeException("Failed to connect to $url: Missing certificate root authority, try updating Java")
-            throw e
-        }
-    }
-
-    static String getLatestForgeVersion(String mcVersion) {
-        final json = new JsonSlurper().parseText(new URL('https://files.minecraftforge.net/net/minecraftforge/forge/promotions_slim.json').getText('UTF-8'))
-        final ver = json.promos["$mcVersion-latest"]
-        ver === null ? null : (mcVersion + '-' + ver)
-    }
-
-    @CompileStatic
-    static void processClassNodes(File file, @ClosureParams(value = SimpleType, options = 'org.objectweb.asm.tree.ClassNode') Closure process) {
-        file.withInputStream { i ->
-            new ZipInputStream(i).withCloseable { zin ->
-                ZipEntry zein
-                while ((zein = zin.nextEntry) !== null) {
-                    if (zein.name.endsWith('.class')) {
-                        var node = new ClassNode(ASM_LEVEL)
-                        new ClassReader(zin).accept(node, 0)
-                        process(node)
-                    }
-                }
-            }
-        }
-    }
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/ValidateDeprecations.groovy

@@ -1,94 +0,0 @@
-/*
- * Copyright (c) Forge Development LLC and contributors
- * SPDX-License-Identifier: LGPL-2.1-only
- */
-
-package net.minecraftforge.forge.tasks
-
-import groovy.transform.CompileStatic
-import net.minecraftforge.srgutils.MinecraftVersion
-import org.gradle.api.DefaultTask
-import org.gradle.api.file.RegularFileProperty
-import org.gradle.api.provider.Property
-import org.gradle.api.tasks.Input
-import org.gradle.api.tasks.InputFile
-import org.gradle.api.tasks.TaskAction
-import org.objectweb.asm.tree.AnnotationNode
-import org.objectweb.asm.tree.ClassNode
-
-abstract class ValidateDeprecations extends DefaultTask {
-    @InputFile
-    abstract RegularFileProperty getInput()
-
-    @Input
-    abstract Property<String> getMcVersion()
-
-    ValidateDeprecations() {
-        this.onlyIf { !System.env.TEAMCITY_VERSION }
-    }
-
-    @TaskAction
-    protected void exec() {
-        var mcVer = MinecraftVersion.from(mcVersion.get())
-        List<String> errors = []
-
-        Util.processClassNodes(input.get().asFile) {
-            processNode(mcVer, errors, it)
-        }
-
-        if (!errors.isEmpty()) {
-            errors.forEach {
-                this.logger.error("Deprecated ${it[0]} is marked for removal in ${it[1]} but is not yet removed")
-            }
-            throw new IllegalStateException("Found deprecated members marked for removal but not yet removed in ${mcVer}; see log for details")
-        }
-    }
-
-    protected processNode(MinecraftVersion mcVer, List<String> errors, ClassNode node) {
-        node.visibleAnnotations?.each { annotation ->
-            ValidateDeprecations.processAnnotations(annotation, mcVer, errors) {
-                "class ${node.name}"
-            }
-        }
-        node.fields?.each { field ->
-            field.visibleAnnotations?.each { annotation ->
-                ValidateDeprecations.processAnnotations(annotation, mcVer, errors) {
-                    "field ${node.name}#${field.name}"
-                }
-            }
-        }
-        node.methods?.each { method ->
-            method.visibleAnnotations?.each { annotation ->
-                ValidateDeprecations.processAnnotations(annotation, mcVer, errors) {
-                    "method ${node.name}#${method.name}${method.desc}"
-                }
-            }
-        }
-    }
-
-    private static void processAnnotations(AnnotationNode annotation, MinecraftVersion mcVer, List<String> errors, Closure<String> context) {
-        def values = annotation.values
-        if (values === null)
-            return
-        int forRemoval = values.indexOf('forRemoval')
-        int since = values.indexOf('since')
-        if (annotation.desc == 'Ljava/lang/Deprecated;' && forRemoval !== -1 && since !== -1 && values.size() >= 4 && values[forRemoval + 1] === true) {
-            def oldVersion = MinecraftVersion.from(values[since + 1])
-            int[] split = ValidateDeprecations.splitDots(oldVersion.toString())
-            if (split.length < 2)
-                return
-            def removeVersion = MinecraftVersion.from("${split[0]}.${split[1] + 1}")
-            if (removeVersion <= mcVer)
-                errors.add([context(), removeVersion])
-        }
-    }
-
-    @CompileStatic
-    private static int[] splitDots(String version) {
-        String[] pts = version.split('\\.')
-        int[] values = new int[pts.length]
-        for (int x = 0; x < pts.length; x++)
-            values[x] = Integer.parseInt(pts[x])
-        return values
-    }
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/checks/CheckATs.groovy

@@ -1,310 +0,0 @@
-package net.minecraftforge.forge.tasks.checks
-
-import groovy.transform.CompileStatic
-import groovy.transform.TupleConstructor
-import net.minecraftforge.forge.tasks.InheritanceData
-import net.minecraftforge.srgutils.IMappingFile
-import org.gradle.api.file.ConfigurableFileCollection
-import org.gradle.api.file.RegularFile
-import org.gradle.api.file.RegularFileProperty
-import org.gradle.api.tasks.InputFile
-import org.gradle.api.tasks.InputFiles
-import org.gradle.api.tasks.Optional
-import org.objectweb.asm.Opcodes
-
-@CompileStatic
-abstract class CheckATs extends CheckTask {
-
-    @InputFile abstract RegularFileProperty getInheritance()
-    @InputFiles abstract ConfigurableFileCollection getAts()
-    @InputFile @Optional abstract RegularFileProperty getMappings()
-
-    @Override
-    void check(Reporter reporter, boolean fix) {
-        final IMappingFile mappings = mappings.map { RegularFile it -> IMappingFile.load(it.asFile) }.getOrNull()
-        final inheritance = InheritanceData.parse(this.inheritance.get().asFile)
-
-        ats.each {
-            final lines = process(it, reporter, inheritance)
-            if (fix) {
-                it.text = joinBack(lines, inheritance, mappings).join('\n')
-            }
-        }
-    }
-
-    private static TreeMap<String, ATParser.Entry> process(File file, Reporter reporter, Map<String, InheritanceData> inheritance) {
-        final TreeMap<String, ATParser.Entry> lines = ATParser.parse(file.readLines(), reporter)
-        final Map<String, ATParser.Entry> constructorGroups = [:]
-
-        final itr = lines.entrySet().iterator()
-        final toRemove = []
-        while (itr.hasNext()) {
-            final next = itr.next()
-            String key = next.key
-            final entry = next.value
-            if (entry === null) continue
-
-            final binaryName = entry.cls.replaceAll('\\.', '/')
-
-            // Process Groups, this will remove any entries outside the group that is covered by the group
-            if (entry.group) {
-                final jcls = inheritance[binaryName]
-                if (jcls === null) {
-                    itr.remove()
-                    reporter.report("Invalid group: $key")
-                } else if ('*' == entry.desc) {
-                    if (!jcls.fields) {
-                        itr.remove()
-                        reporter.report("Invalid group, class has no fields: $key")
-                    } else {
-                        jcls.fields.each { field, value ->
-                            final fkey = entry.cls + ' ' + field
-                            if (accessLevel(value.access) < accessStr(entry.modifier)) {
-                                if (lines.containsKey(fkey)) {
-                                    toRemove.add(fkey)
-                                } else if (!entry.existing.contains(fkey)) {
-                                    reporter.report("Missing group entry: $fkey")
-                                }
-                                entry.children.add(fkey)
-                            } else if (lines.containsKey(fkey)) {
-                                toRemove.add(fkey)
-                                reporter.report("Found invalid group entry: $fkey")
-                            }
-                        }
-                        entry.existing.findAll { it !in entry.children }.each { println('Removed: ' + it) }
-                    }
-                } else if ('*()' == entry.desc) {
-                    if (!jcls.methods) {
-                        itr.remove()
-                        reporter.report("Invalid group, class has no methods: $key")
-                    } else {
-                        jcls.methods.each { mtd, value ->
-                            if (mtd.startsWith('<clinit>') || mtd.startsWith('lambda$')) return
-                            key = entry.cls + ' ' + mtd.replace(' ', '')
-                            if (accessLevel(value.access) < accessStr(entry.modifier)) {
-                                if (lines.containsKey(key)) {
-                                    toRemove.add(key)
-                                } else if (!entry.existing.contains(key)) {
-                                    reporter.report("Missing group entry: $key")
-                                }
-                                entry.children.add(key)
-                            } else if (lines.containsKey(key)) {
-                                toRemove.add(key)
-                                reporter.report("Found invalid group entry: $key")
-                            }
-                        }
-                        entry.existing.findAll { it !in entry.children }.each { println('Removed: ' + it) }
-                    }
-                } else if ('<init>' == entry.desc) { //Make all public non-abstract subclasses
-                    constructorGroups.put(binaryName, entry)
-                }
-            }
-
-            // Process normal lines, remove invalid and remove narrowing
-            else {
-                def jcls = inheritance.get(binaryName)
-                if (jcls === null) {
-                    itr.remove()
-                    reporter.report("Invalid: $key")
-                } else if (entry.desc == '') {
-                    if (accessLevel(jcls.access) > accessStr(entry.modifier) && (entry.comment === null || !entry.comment.startsWith('#force '))) {
-                        itr.remove()
-                        reporter.report("Invalid Narrowing: $key")
-                    }
-                } else if (!entry.desc.contains('(')) {
-                    if (!jcls.fields || !jcls.fields.containsKey(entry.desc)) {
-                        itr.remove()
-                        reporter.report("Invalid: $key")
-                    } else {
-                        final value = jcls.fields[entry.desc]
-                        if (accessLevel(value.access) > accessStr(entry.modifier) && (entry.comment === null || !entry.comment.startsWith('#force '))) {
-                            itr.remove()
-                            reporter.report("Invalid Narrowing: $key - ${entry.comment}")
-                        }
-                    }
-                } else {
-                    final jdesc = entry.desc.replace('(', ' (')
-                    if (!jcls.methods || !jcls.methods.containsKey(jdesc)) {
-                        itr.remove()
-                        reporter.report("Invalid: $key")
-                    } else {
-                        final value = jcls.methods[jdesc]
-                        if (accessLevel(value.access) > accessStr(entry.modifier) && (entry.comment === null || !entry.comment.startsWith('#force '))) {
-                            itr.remove()
-                            reporter.report("Invalid Narrowing: $key")
-                        }
-                    }
-                }
-            }
-        }
-
-        inheritance.each { tcls, value ->
-            if (!value.methods || ((value.access & Opcodes.ACC_ABSTRACT) !== 0)) return
-            String parent = tcls
-            while (parent !== null) {
-                constructorGroups[parent]?.tap { entry ->
-                    value.methods.each { mtd, v ->
-                        if (mtd.startsWith('<init>')) {
-                            final child = tcls.replaceAll('/', '\\.') + ' ' + mtd.replace(' ', '')
-                            if (accessLevel(v.access) < 3) {
-                                if (lines.containsKey(child)) {
-                                    toRemove.add(child)
-                                } else if (child !in entry.existing) {
-                                    reporter.report("Missing group entry: $child")
-                                }
-                                entry.children.add(child)
-                            } else if (lines.containsKey(child)) {
-                                toRemove.add(child)
-                                reporter.report("Found invalid group entry: $child")
-                            }
-                        }
-                    }
-                }
-                parent = inheritance[parent]?.superName
-            }
-        }
-        constructorGroups.values().each { entry -> entry.existing.findAll { it !in entry.children }.each{  reporter.report("Found invalid group entry: $it") } }
-
-        toRemove.each(lines.&remove)
-
-        return lines
-    }
-
-    private static List<String> joinBack(TreeMap<String, ATParser.Entry> lines, Map<String, InheritanceData> inheritance, IMappingFile mappings) {
-        final data = [] as List<String>
-        final remapComment = { ATParser.Entry entry ->
-            if (!mappings || !entry || !entry.desc) return null
-            final comment = entry.comment?.substring(1)?.trim()
-            final jsonCls = inheritance.get(entry.cls.replaceAll('\\.', '/'))
-            final mappingsClass = mappings?.getClass(jsonCls.name)
-            if (mappingsClass === null) return entry.comment
-            final idx = entry.desc.indexOf('(')
-
-            String mappedName = idx == -1
-                    ? mappingsClass.remapField(entry.desc)
-                    : mappingsClass.remapMethod(entry.desc.substring(0, idx), entry.desc.substring(idx))
-            if (!mappedName) return entry.comment
-            if (mappedName == '<init>')
-                mappedName = 'constructor'
-
-            if (comment?.startsWith(mappedName))
-                return '# ' + comment
-            if (comment && comment.indexOf(' ') !== -1) {
-                def split = comment.split(' - ').toList()
-                if (split[0].indexOf(' ') !== -1)
-                // The first string is more than one word, so append before it
-                    return "# ${mappedName} - ${comment}"
-                split.remove(0)
-                return "# ${mappedName} - ${String.join(' - ', split)}"
-            }
-            return '# ' + mappedName
-        }
-        lines.each { key, value ->
-            if (!value.group) {
-                def comment = remapComment.call(value)
-                data.add(value.modifier + ' ' + key + (comment ? ' ' + comment : ''))
-            } else {
-                data.add(('#group ' + value.modifier + ' ' + key + ' ' + (value.comment ?: '')).trim())
-                value.children.each {
-                    final line = value.modifier + ' ' + it
-                    final entry = ATParser.parseEntry(line)
-                    final comment = remapComment(entry)
-                    data.add(line + (comment ? ' ' + comment : ''))
-                }
-                data.add('#endgroup')
-            }
-        }
-        return data
-    }
-
-    static int accessStr(String access) {
-        if (access.endsWith('-f') || access.endsWith('+f')) return 4
-        switch (access.toLowerCase()) {
-            case 'public':    return 3
-            case 'protected': return 2
-            case 'default':   return 1
-            case 'private':   return 0
-            default:          return -1
-        }
-    }
-
-    static int accessLevel(int access) {
-        if ((access & Opcodes.ACC_PUBLIC)    !== 0) return 3
-        if ((access & Opcodes.ACC_PROTECTED) !== 0) return 2
-        if ((access & Opcodes.ACC_PRIVATE)   !== 0) return 0
-        return 1
-    }
-}
-
-@CompileStatic
-class ATParser {
-    static TreeMap<String, Entry> parse(List<String> lines, CheckTask.Reporter reporter) {
-        TreeMap<String, Entry> outLines = new TreeMap<>()
-        Entry group = null
-        for (final line : lines) {
-            if (line.isEmpty()) continue
-            if (line.startsWith('#group ')) {
-                final entry = parseEntry(line.substring(7))
-
-                if (entry.desc != '*' && entry.desc != '*()' && entry.desc != '<init>') {
-                    reporter.report("Invalid group: $line", false)
-                }
-
-                entry.group = true
-                entry.children = []
-                entry.existing = []
-
-                group = entry
-
-                if (outLines.containsKey(entry.key)) {
-                    reporter.report("Duplicate group: $line", false)
-                }
-
-                outLines[entry.key] = group
-            } else if (group !== null) {
-                if (line.startsWith('#endgroup')) {
-                    group = null
-                } else {
-                    final key = parseEntry(line).key
-                    group.existing.add(key)
-                }
-            } else if (line.startsWith('#endgroup')) {
-                reporter.report("Invalid group ending: $line", false)
-            } else if (line.startsWith('#')) {
-                //Nom
-            } else {
-                final entry = parseEntry(line)
-                if (outLines.containsKey(entry.key)) {
-                    reporter.report("Found duplicate: $line")
-                    continue
-                }
-                outLines[entry.key] = entry
-            }
-        }
-        return outLines
-    }
-
-    static Entry parseEntry(String line) {
-        final idx = line.indexOf('#')
-        final String comment = idx === -1 ? null : line.substring(idx)
-        if (idx !== -1) line = line.substring(0, idx - 1)
-        final data = (line.trim() + '     ').split(' ', -1)
-        new Entry(data[0], data[1], data[2], comment)
-    }
-
-    @TupleConstructor
-    static final class Entry {
-        String modifier, cls, desc, comment
-
-        Set<String> existing
-        TreeSet<String> children
-        boolean group = false
-
-        @Lazy
-        String key = {cls + (desc.isEmpty() ? '' : ' ' + desc)}()
-
-        Object getAt(String key) {
-            return getProperty(key)
-        }
-    }
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/checks/CheckExcs.groovy

@@ -1,95 +0,0 @@
-package net.minecraftforge.forge.tasks.checks
-
-import net.minecraftforge.forge.tasks.Util
-import org.gradle.api.file.ConfigurableFileCollection
-import org.gradle.api.file.RegularFileProperty
-import org.gradle.api.tasks.InputFile
-import org.gradle.api.tasks.InputFiles
-import org.objectweb.asm.ClassReader
-import org.objectweb.asm.ClassVisitor
-import org.objectweb.asm.MethodVisitor
-import org.objectweb.asm.Type
-
-import java.util.zip.ZipEntry
-import java.util.zip.ZipInputStream
-
-abstract class CheckExcs extends CheckTask {
-
-    @InputFile abstract RegularFileProperty getBinary()
-    @InputFiles abstract ConfigurableFileCollection getExcs()
-
-    @Override
-    void check(Reporter reporter, boolean fix) {
-        final Set<String> known = []
-        collectKnown(known)
-
-        excs.each { f ->
-            final lines = []
-            f.eachLine { line ->
-                int idx = line.indexOf('#')
-                if (idx === 0 || line.isEmpty()) {
-                    return
-                }
-
-                if (idx !== -1) line = line.substring(0, idx - 1)
-
-                if (!line.contains('=')) {
-                    reporter.report("Invalid: $line")
-                    return
-                }
-
-                def (String key, String value) = line.split('=', 2)
-                if (!known.contains(key)) {
-                    reporter.report("Unknown: $line")
-                    return
-                }
-
-                String desc = key.split('\\.', 2)[1]
-                if (!desc.contains('(')) {
-                    reporter.report("Invalid: $line")
-                    return
-                }
-                desc = '(' + desc.split('\\(', 2)[1]
-
-                def (exceptions, String args) = value.contains('|') ? value.split('|', 2) : [value, '']
-
-                if (args.split(',').length !== Type.getArgumentTypes(desc).length) {
-                    reporter.report("Invalid: $line")
-                    return
-                }
-                lines.add(line)
-
-                return
-            }
-
-            if (fix) f.text = lines.sort().join('\n')
-        }
-    }
-
-    private void collectKnown(Collection<String> known) {
-        binary.get().asFile.withInputStream { i ->
-            new ZipInputStream(i).withCloseable { zin ->
-                final visitor = new ClassVisitor(Util.ASM_LEVEL) {
-                    private String cls
-                    @Override
-                    void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
-                        this.cls = name
-                    }
-
-                    @Override
-                    MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
-                        known.add(this.cls + '.' + name + descriptor)
-                        super.visitMethod(access, name, descriptor, signature, exceptions)
-                    }
-                }
-                ZipEntry zein
-                while ((zein = zin.nextEntry) !== null) {
-                    if (zein.name.endsWith('.class')) {
-                        ClassReader reader = new ClassReader(zin)
-                        reader.accept(visitor, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES)
-                    }
-                }
-            }
-        }
-    }
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/checks/CheckMode.groovy

@@ -1,11 +0,0 @@
-package net.minecraftforge.forge.tasks.checks
-
-import groovy.transform.CompileStatic
-
-@CompileStatic
-enum CheckMode {
-    CHECK,
-    FIX
-
-    CheckMode() {}
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/checks/CheckPatches.groovy

@@ -1,182 +0,0 @@
-package net.minecraftforge.forge.tasks.checks
-
-import groovy.transform.CompileStatic
-import org.gradle.api.file.DirectoryProperty
-import org.gradle.api.provider.ListProperty
-import org.gradle.api.tasks.Input
-import org.gradle.api.tasks.InputDirectory
-import org.gradle.api.tasks.Optional
-
-import java.nio.file.Files
-import java.nio.file.Path
-import java.util.regex.Pattern
-
-@CompileStatic
-abstract class CheckPatches extends CheckTask {
-
-    private static final Pattern HUNK_START_PATTERN = Pattern.compile('^@@ -[0-9,]* \\+[0-9,_]* @@$')
-    private static final Pattern WHITESPACE_PATTERN = Pattern.compile('^[+\\-]\\s*$')
-    private static final Pattern IMPORT_PATTERN = Pattern.compile('^[+\\-]\\s*import.*')
-    private static final Pattern FIELD_PATTERN = Pattern.compile('^[+\\-][\\s]*((public|protected|private)[\\s]*)?(static[\\s]*)?(final)?([^=;]*)(=.*)?;\\s*$')
-    private static final Pattern METHOD_PATTERN = Pattern.compile('^[+\\-][\\s]*((public|protected|private)[\\s]*)?(static[\\s]*)?(final)?([^(]*)[(]([^)]*)?[)]\\s*[{]\\s*$')
-    private static final Pattern CLASS_PATTERN = Pattern.compile('^[+\\-][\\s]*((public|protected|private)[\\s]*)?(static[\\s]*)?(final[\\s]*)?(class|interface)([^{]*)[{]\\s*$')
-    private static final Map<String, Integer> ACCESS_MAP = [private: 0, protected: 2, public: 3].tap { it.put(null, 1) }
-
-    @InputDirectory abstract DirectoryProperty getPatchDir()
-    @Input @Optional abstract ListProperty<String> getPatchesWithS2SArtifact()
-
-    @Override
-    void check(Reporter reporter, boolean fix) {
-        final patchDir = getPatchDir().get().asFile.toPath()
-        Files.walk(patchDir).withCloseable {
-            it.filter(Files.&isRegularFile).forEach { path ->
-                final String relativeName = patchDir.relativize(path).toString()
-                verifyPatch(path, reporter, fix, relativeName, patchesWithS2SArtifact.get().contains(relativeName.replace('\\', '/')))
-            }
-        }
-    }
-    
-    static boolean accessChange(String previous, String current) {
-        //return ACCESS_MAP[previous] < ACCESS_MAP[current]
-        return previous != current
-    }
-
-    void verifyPatch(Path patch, Reporter reporter, boolean fix, String patchPath, boolean hasS2SArtifact) {
-        int oldFixedErrors = reporter.fixed.size()
-
-        final lines = Files.readAllLines(patch)
-
-        int hunksStart = 0
-        boolean onlyWhiteSpace = false
-
-        final List<String> newLines = []
-
-        // First two lines are file name ++/-- and we do not care
-        newLines.add(lines[0] + '\n')
-        newLines.add(lines[1] + '\n')
-
-        int i
-        for (i = 2; i < lines.size(); ++i) {
-            def line = lines[i]
-            newLines.add(line + '\n')
-
-            if (HUNK_START_PATTERN.matcher(line).find()) {
-                if (onlyWhiteSpace) {
-                    if (!hasS2SArtifact)
-                        reporter.report("Patch contains only white space hunk starting at line ${hunksStart + 1}, file: $patchPath")
-                    int toRemove = i - hunksStart
-                    while (toRemove-- > 0)
-                        newLines.remove(newLines.size() - 1)
-                }
-                hunksStart = i
-                onlyWhiteSpace = true
-                continue
-            }
-
-            if (line.startsWithAny('+','-')) {
-                def prefixChange = false
-                def prevLine = lines[i - 1]
-
-                if (line.charAt(0) == (char)'+' && prevLine.charAt(0) == (char)'-') {
-                    def prevTrim = prevLine.substring(1).replaceAll("\\s", "")
-                    def currTrim = line.substring(1).replaceAll("\\s", "")
-
-                    if (prevTrim == currTrim) {
-                        prefixChange = true
-                    }
-
-                    def pMatcher = FIELD_PATTERN.matcher(prevLine)
-                    def cMatcher = FIELD_PATTERN.matcher(line)
-
-                    if (pMatcher.find() && cMatcher.find() &&
-                            pMatcher.group(6) == cMatcher.group(6) && // = ...
-                            pMatcher.group(5) == cMatcher.group(5) && // field name
-                            pMatcher.group(3) == cMatcher.group(3) && // static
-                            (accessChange(pMatcher.group(2), cMatcher.group(2)) || pMatcher.group(4) != cMatcher.group(4))) {
-                        reporter.report("Patch contains access changes or final removal at line ${i + 1}, file: $patchPath", false)
-                    }
-
-                    pMatcher = METHOD_PATTERN.matcher(prevLine)
-                    cMatcher = METHOD_PATTERN.matcher(line)
-
-                    if (pMatcher.find() && cMatcher.find() &&
-                            pMatcher.group(6) == cMatcher.group(6) && // params
-                            pMatcher.group(5) == cMatcher.group(5) && // <T> void name
-                            pMatcher.group(3) == cMatcher.group(3) && // static
-                            (accessChange(pMatcher.group(2), cMatcher.group(2)) || pMatcher.group(4) != cMatcher.group(4))) {
-                        reporter.report("Patch contains access changes or final removal at line ${i + 1}, file: $patchPath", false)
-                    }
-
-                    pMatcher = CLASS_PATTERN.matcher(prevLine)
-                    cMatcher = CLASS_PATTERN.matcher(line)
-
-                    if (pMatcher.find() && cMatcher.find() &&
-                            pMatcher.group(6) == cMatcher.group(6) && // ClassName<> extends ...
-                            pMatcher.group(5) == cMatcher.group(5) && // class | interface
-                            pMatcher.group(3) == cMatcher.group(3) && // static
-                            (accessChange(pMatcher.group(2), cMatcher.group(2)) || pMatcher.group(4) != cMatcher.group(4))) {
-                        reporter.report("Patch contains access changes or final removal at line ${i + 1}, file: $patchPath", false)
-                    }
-                }
-
-                if (line.charAt(0) == (char)'-' && i + 1 < lines.size()) {
-                    final nextLine = lines[i + 1]
-                    if (nextLine.charAt(0) == (char)'+') {
-                        final nextTrim = nextLine.substring(1).replaceAll("\\s", "")
-                        final currTrim = line.substring(1).replaceAll("\\s", "")
-
-                        if (nextTrim == currTrim) {
-                            prefixChange = true
-                        }
-                    }
-                }
-
-                final isWhiteSpaceChange = WHITESPACE_PATTERN.matcher(line).find()
-
-                if (!prefixChange && !isWhiteSpaceChange) {
-                    onlyWhiteSpace = hasS2SArtifact && IMPORT_PATTERN.matcher(line).find()
-                } else if (isWhiteSpaceChange) {
-                    final prevLineChange = prevLine.startsWithAny('+','-')
-                    final nextLineChange = i + 1 < lines.size() && lines[i + 1].startsWithAny('+','-')
-
-                    if (!prevLineChange && !nextLineChange) {
-                        reporter.report("Patch contains white space change in valid hunk at line ${i + 1}, file: $patchPath \n$prevLine\n$line\n${lines[i+1]}", false)
-                    }
-                }
-
-                if (line.contains('\t')) {
-                    reporter.report("Patch contains tabs on line ${i + 1}, file: $patchPath")
-                    line = line.replaceAll('\t', '    ')
-                    newLines.remove(newLines.size() - 1)
-                    newLines.add(line + '\n')
-                }
-
-                if (IMPORT_PATTERN.matcher(line).find() && !hasS2SArtifact) {
-                    reporter.report("Patch contains import change on line ${i + 1}, file: $patchPath", false)
-                }
-            }
-        }
-
-        if (onlyWhiteSpace) {
-            if (!hasS2SArtifact)
-                reporter.report("Patch contains only white space hunk starting at line ${hunksStart + 1}, file: $patchPath")
-            def toRemove = i - hunksStart;
-            while (toRemove-- > 0)
-                newLines.remove(newLines.size() - 1)
-        }
-
-        if ((reporter.fixed.size() > oldFixedErrors && fix) || hasS2SArtifact) {
-            if (newLines.size() <= 2) {
-                logger.lifecycle("Patch is now empty removing, file: {}", patchPath)
-                Files.delete(patch)
-            }
-            else {
-                if (!hasS2SArtifact)
-                    logger.lifecycle("*** Updating patch file. Please run setup then genPatches again. ***")
-                Files.newBufferedWriter(patch).withCloseable {
-                    newLines.each { l -> it.write(l) }
-                }
-            }
-        }
-    }
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/checks/CheckSAS.groovy

@@ -1,110 +0,0 @@
-package net.minecraftforge.forge.tasks.checks
-
-import groovy.transform.CompileStatic
-import net.minecraftforge.forge.tasks.Annotatable
-import net.minecraftforge.forge.tasks.InheritanceData
-import org.gradle.api.file.ConfigurableFileCollection
-import org.gradle.api.file.RegularFileProperty
-import org.gradle.api.tasks.InputFile
-import org.gradle.api.tasks.InputFiles
-
-@CompileStatic
-abstract class CheckSAS extends CheckTask {
-
-    @InputFile abstract RegularFileProperty getInheritance()
-    @InputFiles abstract ConfigurableFileCollection getSass()
-
-    @Override
-    void check(Reporter reporter, boolean fix) {
-        final inheritance = InheritanceData.parse(this.inheritance.get().asFile)
-
-        sass.each { f ->
-            final lines = []
-            f.eachLine { line ->
-                if (line[0] == '\t') return // Skip any tabbed lines, those are ones we add
-                final idx = line.indexOf('#')
-                if (idx == 0 || line.isEmpty()) {
-                    lines.add(line)
-                    return
-                }
-                def comment = idx == -1 ? null : line.substring(idx)
-                if (idx != -1) line = line.substring(0, idx - 1)
-                final spl = (line.trim().replace('(', ' (') + '     ').split(' ', -1)
-                def (String cls, String name, String desc) = [spl[0], spl[1], spl[2]]
-                cls = cls.replaceAll('\\.', '/')
-
-                if (inheritance[cls] === null) {
-                    reporter.report("Invalid: $line")
-                } else if (name.isEmpty()) { //Class SAS
-                    final toAdd = []
-                    final clsSided = isSided(inheritance[cls])
-                    boolean sided = clsSided
-
-                    /* TODO: MergeTool doesn't do fields
-                    if (json[cls]['fields'] != null) {
-                        for (entry in json[cls]['fields']) {
-                            if (isSided(entry.value)) {
-                                sided = true
-                                toAdd.add('\t' + cls + ' ' + entry.key)
-                            }
-						}
-                    } */
-
-                    final clsInh = inheritance[cls]
-                    if (clsInh.methods) {
-                        for (entry in clsInh.methods) {
-                            if (isSided(entry.value)) {
-                                sided = true
-                                toAdd.add('\t' + cls + ' ' + entry.key.replaceAll(' ', ''))
-                                findChildMethods(inheritance, cls, entry.key).each { lines.add('\t' + it) }
-                                findChildMethods(inheritance, cls, entry.key).each { println(line + ' -- ' + it) }
-                            } else if (clsSided) {
-                                findChildMethods(inheritance, cls, entry.key).each { lines.add('\t' + it) }
-                                findChildMethods(inheritance, cls, entry.key).each { println(line + ' -- ' + it) }
-                            }
-                        }
-                    }
-
-                    if (sided) {
-                        lines.add(cls + (comment == null ? '' : ' ' + comment))
-                        lines.addAll(toAdd.sort())
-                    } else {
-                        reporter.report("Invalid: $line")
-                    }
-
-                } else if (desc.isEmpty()) { // Fields
-                    /* TODO: MergeTool doesn't do fields
-                    if (json[cls]['fields'] != null && isSided(json[cls]['fields'][name]))
-                        lines.add(cls + ' ' + name + (comment == null ? '' : ' ' + comment))
-                    else */
-                    reporter.report("Invalid: $line")
-                } else { // Methods
-                    final clsInh = inheritance[cls]
-                    if (clsInh.methods === null || !isSided(clsInh.methods[name + ' ' + desc]))
-                        reporter.report("Invalid: $line")
-                    else {
-                        lines.add(cls + ' ' + name + desc + (comment == null ? '' : ' ' + comment))
-                        findChildMethods(inheritance, cls, name + ' ' + desc).each { println(line + ' -- ' + it) }
-                        findChildMethods(inheritance, cls, name + ' ' + desc).each { lines.add('\t' + it) }
-                    }
-                }
-            }
-
-            if (fix) f.text = lines.join('\n')
-        }
-    }
-
-    protected static boolean isSided(Annotatable annotatable) {
-        if (annotatable === null) return false
-        for (ann in annotatable.annotations) {
-            if ('Lnet/minecraftforge/api/distmarker/OnlyIn;' == ann.desc)
-                return true
-        }
-        return false
-    }
-    
-    protected static findChildMethods(Map<String, InheritanceData> json, String cls, String desc) {
-        return json.values().findAll{ it.methods !== null && it.methods[desc] !== null && it.methods[desc].override == cls && isSided(it.methods[desc]) }
-                .collect { it.name + ' ' + desc.replace(' ', '') } as TreeSet
-    }
-}

buildSrc/src/main/groovy/net/minecraftforge/forge/tasks/checks/CheckTask.groovy

@@ -1,114 +0,0 @@
-package net.minecraftforge.forge.tasks.checks
-
-import groovy.transform.CompileStatic
-import groovy.transform.stc.ClosureParams
-import groovy.transform.stc.ThirdParam
-import net.minecraftforge.forge.tasks.Util
-import org.gradle.api.Action
-import org.gradle.api.DefaultTask
-import org.gradle.api.logging.LogLevel
-import org.gradle.api.provider.Property
-import org.gradle.api.tasks.Input
-import org.gradle.api.tasks.TaskAction
-import org.gradle.api.tasks.TaskContainer
-import org.gradle.api.tasks.VerificationTask
-
-@CompileStatic
-abstract class CheckTask extends DefaultTask implements VerificationTask {
-    @Input
-    abstract Property<CheckMode> getMode()
-
-    private boolean ignoreFailures = false
-
-    @Input
-    @Override
-    boolean getIgnoreFailures() {
-        return ignoreFailures
-    }
-
-    @Override
-    void setIgnoreFailures(boolean ignoreFailures) {
-        this.ignoreFailures = ignoreFailures
-    }
-
-    @TaskAction
-    void run() {
-        Util.init()
-
-        boolean doFix = getMode().get() === CheckMode.FIX
-        final Reporter reporter = new Reporter(doFix)
-        check(reporter, doFix)
-
-        if (reporter.messages) {
-            if (getMode().get() === CheckMode.CHECK) {
-                logger.error("Check task '{}' found errors:\n{}", name, reporter.messages.join('\n'))
-                if (!ignoreFailures) {
-                    throw new IllegalArgumentException("${reporter.messages.size()} errors were found!")
-                }
-            } else {
-                if (logger.isEnabled(LogLevel.DEBUG)) {
-                    logger.warn("Check task '{}' found {} errors and fixed {}:\n{}", name, reporter.messages.size(), reporter.fixed.size(), reporter.fixed.join('\n'))
-                } else {
-                    logger.warn("Check task '{}' found {} errors and fixed {}.", name, reporter.messages.size(), reporter.fixed.size())
-                }
-
-                if (reporter.notFixed) {
-                    logger.error('{} errors could not be fixed:\n{}', reporter.notFixed.size(), reporter.notFixed.join('\n'))
-                    if (!ignoreFailures) {
-                        throw new IllegalArgumentException("${reporter.notFixed.size()} errors which cannot be fixed were found!")
-                    }
-                }
-            }
-        }
-    }
-
-    abstract void check(Reporter reporter, boolean fix)
-
-    @CompileStatic
-    static final class Reporter {
-        final boolean trackFixed
-        Reporter(boolean trackFixed) {
-            this.trackFixed = trackFixed
-        }
-
-        public final List<String> messages = []
-
-        public final List<String> fixed = []
-        public final List<String> notFixed = []
-
-        void report(String message, boolean canBeFixed = true) {
-            messages.add(message)
-
-            if (trackFixed) {
-                if (canBeFixed) {
-                    fixed.add(message)
-                } else {
-                    notFixed.add(message)
-                }
-            }
-        }
-    }
-
-    static <T extends CheckTask> void registerTask(TaskContainer tasks, String taskName, @DelegatesTo.Target('type') Class<T> clazz,
-                                                   @DelegatesTo(genericTypeIndex = 0, target = 'type')
-                                                   @ClosureParams(ThirdParam.FirstGenericType) Closure configuration) {
-        taskName = taskName.capitalize()
-        tasks.register("check$taskName", clazz) { CheckTask task ->
-            def castedTask = task as T
-            configuration.setDelegate(castedTask)
-            configuration.call(castedTask)
-            castedTask.mode.set(CheckMode.CHECK)
-            castedTask.group = 'checks'
-        }
-        tasks.named('checkAll').configure { it.dependsOn("check$taskName") }
-
-        tasks.register("checkAndFix$taskName", clazz) { CheckTask task ->
-            def castedTask = task as T
-            configuration.setDelegate(castedTask)
-            configuration.call(castedTask)
-            castedTask.mode.set(CheckMode.FIX)
-            castedTask.group = 'checks'
-        }
-        tasks.named('checkAllAndFix').configure { it.dependsOn("checkAndFix$taskName") }
-    }
-}

build_clean.gradle

@@ -1,73 +0,0 @@
-plugins {
-    id 'java-library'
-    id 'net.minecraftforge.gradle.patcher'
-}
-
-evaluationDependsOn(':mcp')
-
-repositories {
-    mavenCentral()
-    maven gradleutils.forgeMaven
-    maven gradleutils.minecraftLibsMaven
-}
-    
-java.toolchain.languageVersion = JavaLanguageVersion.of(JAVA_VERSION)
-
-dependencies {
-	implementation(libs.forgespi)
-}
-
-patcher {
-	parent = project(':mcp')
-	mcVersion = MC_VERSION
-	patchedSrc = file('src/main/java')
-
-	mappings channel: MAPPING_CHANNEL, version: MAPPING_VERSION
-
-	runs {
-		clean_client {
-			client true
-			taskName 'clean_client'
-			ideaModule "${rootProject.name}.${project.name}.main"
-
-			main 'net.minecraft.client.main.Main'
-			workingDirectory project.file('run/client')
-
-			args '--gameDir', '.'
-			args '--version', MC_VERSION
-			args '--assetsDir', downloadAssets.output
-			args '--assetIndex', '{asset_index}'
-			args '--accessToken', '0'
-		}
-
-		clean_server {
-			client false
-			taskName 'clean_server'
-			ideaModule "${rootProject.name}.${project.name}.main"
-
-			main 'net.minecraft.server.Main'
-			workingDirectory project.file('run/server')
-		}
-	}
-}
-
-tasks.withType(JavaCompile).configureEach {
-    options.encoding = 'UTF-8' // Use the UTF-8 charset for Java compilation
-    options.warnings = false // Shutup deprecated for removal warnings
-}
-
-eclipse.classpath.file.whenMerged {
-	// Disable optional warnings on the minecraft decompiled source code. It just muddies the warning window and hides warnings in our own codebase
-	def src = entries.find { it.path == 'src/main/java' }
-    if (src == null) throw new IllegalStateException("You must run `setup` task before importing")
-    src.entryAttributes['ignore_optional_problems'] = 'true'
-}
-
-tasks.named('genPatches').configure {
-    onlyIf { false }
-}
-
-tasks.named('extractRangeMap').configure {
-    onlyIf { false }
-    tool = 'net.minecraftforge:Srg2Source:8.1.0:fatjar'
-}

build_shared.gradle

@@ -1,85 +0,0 @@
-import net.minecraftforge.forge.tasks.CleanProperties
-
-apply plugin: 'eclipse'
-apply plugin: 'idea'
-apply plugin: 'net.minecraftforge.gradleutils'
-
-group = 'net.minecraftforge'
-version = VERSION
-println("Version: $version")
-
-repositories {
-    mavenCentral()
-    maven gradleutils.forgeMaven
-    maven gradleutils.minecraftLibsMaven
-    //mavenLocal()
-}
-
-tasks.withType(Javadoc).configureEach {
-    options.tags = [
-        'apiNote:a:<em>API Note:</em>',
-        'implSpec:a:<em>Implementation Requirements:</em>',
-        'implNote:a:<em>Implementation Note:</em>'
-    ]
-    options.addStringOption('Xdoclint:all,-missing', '-public')
-}
-
-// We need to write the manifest to the binary file so we have properly versioned packaged at dev time.
-tasks.register('writeManifest') {
-    doLast {
-        if (plugins.findPlugin('net.minecraftforge.gradle.patcher')) // Forge project
-            universalJar.manifest.writeTo(rootProject.file('src/main/resources/META-INF/MANIFEST.MF'))
-        else
-            jar.manifest.writeTo(project.file('src/main/resources/META-INF/MANIFEST.MF'))
-    }
-}
-
-tasks.register('generateResources') {
-    dependsOn('writeManifest')
-}
-
-// Make sure out manifests get written before compiling the code, IDEA calls this task if you tell it to use the gradle build.
-tasks.withType(JavaCompile).configureEach {
-    dependsOn 'generateResources'
-    dependsOn 'processResources' // Needed because we merge the output of this with the output of the compile task. And gradle detects downstream tasks using the output without a hard dep
-    options.encoding = 'UTF-8' // Use the UTF-8 charset for Java compilation
-    options.warnings = false // Shutup deprecated for removal warnings
-    options.forkOptions.jvmArgs += '-Xmx6G' // Needed to make compiling faster, and not run out of heap space in some cases.
-}
-
-// Merge the resources and classes into the same directory. We'll need to split them at runtime because
-// Minecraft and Forge are in the same sourceSet as they are inter dependent.. for now..
-sourceSets.each {
-    def dir = layout.buildDirectory.dir("classes/java/$it.name")
-    it.output.resourcesDir = dir
-    it.java.destinationDirectory = dir
-}
-
-tasks.register('copyEclipseSettings') {
-    doLast {
-        rootProject.fileTree('ide/eclipse/template/.settings/').matching { include '**/*.prefs' }.each { file ->
-            def target = project.file('.settings/' + file.name)
-            def temp = new CleanProperties().load(file)
-            def exst = new CleanProperties().load(target)
-            exst.put('eclipse.preferences.version', '1')
-            exst.putAll(temp)
-            exst.store(target)
-        }
-    }
-}
-
-// TODO: [Gradle][IntelliJ] Auto trigger these tasks on import.
-eclipse {
-    // Run everytime eclipse builds the code
-    //autoBuildTasks writeManifest
-    // Run when importing the project
-    synchronizationTasks generateResources, copyEclipseSettings, eclipseClasspath, eclipseProject
-}
-
-idea {
-    module {
-        // IntelliJ IDEA does not do this by itself anymore...
-        downloadJavadoc = true
-        downloadSources = true
-    }
-}

docs/README.md

@@ -2,8 +2,8 @@
 
 MinecraftForge
 =============
-[![Stable Release](https://img.shields.io/badge/dynamic/json?url=https://files.minecraftforge.net/net/minecraftforge/forge/promotions_slim.json&label=Stable&prefix=1.21.8-&query=$.promos["1.21.8-recommended"]&color=brightgreen&logo=data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyBjbGFzcz0ic3ZnLWlubGluZS0tZmEgZmEtc3RhciBmYS13LTE4IiBhcmlhLWhpZGRlbj0idHJ1ZSIgZGF0YS1pY29uPSJzdGFyIiBkYXRhLXByZWZpeD0iZmFzIiBmb2N1c2FibGU9ImZhbHNlIiByb2xlPSJpbWciIHZpZXdCb3g9IjAgMCA1NzYgNTEyIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPgo8cGF0aCBkPSJNMjU5LjMgMTcuOEwxOTQgMTUwLjIgNDcuOSAxNzEuNWMtMjYuMiAzLjgtMzYuNyAzNi4xLTE3LjcgNTQuNmwxMDUuNyAxMDMtMjUgMTQ1LjVjLTQuNSAyNi4zIDIzLjIgNDYgNDYuNCAzMy43TDI4OCA0MzkuNmwxMzAuNyA2OC43YzIzLjIgMTIuMiA1MC45LTcuNCA0Ni40LTMzLjdsLTI1LTE0NS41IDEwNS43LTEwM2MxOS0xOC41IDguNS01MC44LTE3LjctNTQuNkwzODIgMTUwLjIgMzE2LjcgMTcuOGMtMTEuNy0yMy42LTQ1LjYtMjMuOS01Ny40IDB6IiBmaWxsPSJ3aGl0ZSIvPgo8L3N2Zz4K)][Download]
-[![Latest Release](https://img.shields.io/badge/dynamic/json?url=https://files.minecraftforge.net/net/minecraftforge/forge/promotions_slim.json&label=Latest&prefix=1.21.8-&query=$.promos["1.21.8-latest"]&color=blue&logo=data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyBjbGFzcz0ic3ZnLWlubGluZS0tZmEgZmEtYnVnIGZhLXctMTYiIGFyaWEtaGlkZGVuPSJ0cnVlIiBkYXRhLWljb249ImJ1ZyIgZGF0YS1wcmVmaXg9ImZhcyIgZm9jdXNhYmxlPSJmYWxzZSIgcm9sZT0iaW1nIiB2aWV3Qm94PSIwIDAgNTEyIDUxMiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTUxMS45ODggMjg4LjljLS40NzggMTcuNDMtMTUuMjE3IDMxLjEtMzIuNjUzIDMxLjFINDI0djE2YzAgMjEuODY0LTQuODgyIDQyLjU4NC0xMy42IDYxLjE0NWw2MC4yMjggNjAuMjI4YzEyLjQ5NiAxMi40OTcgMTIuNDk2IDMyLjc1OCAwIDQ1LjI1NS0xMi40OTggMTIuNDk3LTMyLjc1OSAxMi40OTYtNDUuMjU2IDBsLTU0LjczNi01NC43MzZDMzQ1Ljg4NiA0NjcuOTY1IDMxNC4zNTEgNDgwIDI4MCA0ODBWMjM2YzAtNi42MjctNS4zNzMtMTItMTItMTJoLTI0Yy02LjYyNyAwLTEyIDUuMzczLTEyIDEydjI0NGMtMzQuMzUxIDAtNjUuODg2LTEyLjAzNS05MC42MzYtMzIuMTA4bC01NC43MzYgNTQuNzM2Yy0xMi40OTggMTIuNDk3LTMyLjc1OSAxMi40OTYtNDUuMjU2IDAtMTIuNDk2LTEyLjQ5Ny0xMi40OTYtMzIuNzU4IDAtNDUuMjU1bDYwLjIyOC02MC4yMjhDOTIuODgyIDM3OC41ODQgODggMzU3Ljg2NCA4OCAzMzZ2LTE2SDMyLjY2NkMxNS4yMyAzMjAgLjQ5MSAzMDYuMzMuMDEzIDI4OC45LS40ODQgMjcwLjgxNiAxNC4wMjggMjU2IDMyIDI1Nmg1NnYtNTguNzQ1bC00Ni42MjgtNDYuNjI4Yy0xMi40OTYtMTIuNDk3LTEyLjQ5Ni0zMi43NTggMC00NS4yNTUgMTIuNDk4LTEyLjQ5NyAzMi43NTgtMTIuNDk3IDQ1LjI1NiAwTDE0MS4yNTUgMTYwaDIyOS40ODlsNTQuNjI3LTU0LjYyN2MxMi40OTgtMTIuNDk3IDMyLjc1OC0xMi40OTcgNDUuMjU2IDAgMTIuNDk2IDEyLjQ5NyAxMi40OTYgMzIuNzU4IDAgNDUuMjU1TDQyNCAxOTcuMjU1VjI1Nmg1NmMxNy45NzIgMCAzMi40ODQgMTQuODE2IDMxLjk4OCAzMi45ek0yNTcgMGMtNjEuODU2IDAtMTEyIDUwLjE0NC0xMTIgMTEyaDIyNEMzNjkgNTAuMTQ0IDMxOC44NTYgMCAyNTcgMHoiIGZpbGw9IndoaXRlIi8+Cjwvc3ZnPgo=
+[![Stable Release](https://img.shields.io/badge/dynamic/json?url=https://files.minecraftforge.net/net/minecraftforge/forge/promotions_slim.json&label=Stable&prefix=26.1.2-&query=$.promos["26.1.2-recommended"]&color=brightgreen&logo=data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyBjbGFzcz0ic3ZnLWlubGluZS0tZmEgZmEtc3RhciBmYS13LTE4IiBhcmlhLWhpZGRlbj0idHJ1ZSIgZGF0YS1pY29uPSJzdGFyIiBkYXRhLXByZWZpeD0iZmFzIiBmb2N1c2FibGU9ImZhbHNlIiByb2xlPSJpbWciIHZpZXdCb3g9IjAgMCA1NzYgNTEyIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPgo8cGF0aCBkPSJNMjU5LjMgMTcuOEwxOTQgMTUwLjIgNDcuOSAxNzEuNWMtMjYuMiAzLjgtMzYuNyAzNi4xLTE3LjcgNTQuNmwxMDUuNyAxMDMtMjUgMTQ1LjVjLTQuNSAyNi4zIDIzLjIgNDYgNDYuNCAzMy43TDI4OCA0MzkuNmwxMzAuNyA2OC43YzIzLjIgMTIuMiA1MC45LTcuNCA0Ni40LTMzLjdsLTI1LTE0NS41IDEwNS43LTEwM2MxOS0xOC41IDguNS01MC44LTE3LjctNTQuNkwzODIgMTUwLjIgMzE2LjcgMTcuOGMtMTEuNy0yMy42LTQ1LjYtMjMuOS01Ny40IDB6IiBmaWxsPSJ3aGl0ZSIvPgo8L3N2Zz4K)][Download]
+[![Latest Release](https://img.shields.io/badge/dynamic/json?url=https://files.minecraftforge.net/net/minecraftforge/forge/promotions_slim.json&label=Latest&prefix=26.1.2-&query=$.promos["26.1.2-latest"]&color=blue&logo=data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyBjbGFzcz0ic3ZnLWlubGluZS0tZmEgZmEtYnVnIGZhLXctMTYiIGFyaWEtaGlkZGVuPSJ0cnVlIiBkYXRhLWljb249ImJ1ZyIgZGF0YS1wcmVmaXg9ImZhcyIgZm9jdXNhYmxlPSJmYWxzZSIgcm9sZT0iaW1nIiB2aWV3Qm94PSIwIDAgNTEyIDUxMiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTUxMS45ODggMjg4LjljLS40NzggMTcuNDMtMTUuMjE3IDMxLjEtMzIuNjUzIDMxLjFINDI0djE2YzAgMjEuODY0LTQuODgyIDQyLjU4NC0xMy42IDYxLjE0NWw2MC4yMjggNjAuMjI4YzEyLjQ5NiAxMi40OTcgMTIuNDk2IDMyLjc1OCAwIDQ1LjI1NS0xMi40OTggMTIuNDk3LTMyLjc1OSAxMi40OTYtNDUuMjU2IDBsLTU0LjczNi01NC43MzZDMzQ1Ljg4NiA0NjcuOTY1IDMxNC4zNTEgNDgwIDI4MCA0ODBWMjM2YzAtNi42MjctNS4zNzMtMTItMTItMTJoLTI0Yy02LjYyNyAwLTEyIDUuMzczLTEyIDEydjI0NGMtMzQuMzUxIDAtNjUuODg2LTEyLjAzNS05MC42MzYtMzIuMTA4bC01NC43MzYgNTQuNzM2Yy0xMi40OTggMTIuNDk3LTMyLjc1OSAxMi40OTYtNDUuMjU2IDAtMTIuNDk2LTEyLjQ5Ny0xMi40OTYtMzIuNzU4IDAtNDUuMjU1bDYwLjIyOC02MC4yMjhDOTIuODgyIDM3OC41ODQgODggMzU3Ljg2NCA4OCAzMzZ2LTE2SDMyLjY2NkMxNS4yMyAzMjAgLjQ5MSAzMDYuMzMuMDEzIDI4OC45LS40ODQgMjcwLjgxNiAxNC4wMjggMjU2IDMyIDI1Nmg1NnYtNTguNzQ1bC00Ni42MjgtNDYuNjI4Yy0xMi40OTYtMTIuNDk3LTEyLjQ5Ni0zMi43NTggMC00NS4yNTUgMTIuNDk4LTEyLjQ5NyAzMi43NTgtMTIuNDk3IDQ1LjI1NiAwTDE0MS4yNTUgMTYwaDIyOS40ODlsNTQuNjI3LTU0LjYyN2MxMi40OTgtMTIuNDk3IDMyLjc1OC0xMi40OTcgNDUuMjU2IDAgMTIuNDk2IDEyLjQ5NyAxMi40OTYgMzIuNzU4IDAgNDUuMjU1TDQyNCAxOTcuMjU1VjI1Nmg1NmMxNy45NzIgMCAzMi40ODQgMTQuODE2IDMxLjk4OCAzMi45ek0yNTcgMGMtNjEuODU2IDAtMTEyIDUwLjE0NC0xMTIgMTEyaDIyNEMzNjkgNTAuMTQ0IDMxOC44NTYgMCAyNTcgMHoiIGZpbGw9IndoaXRlIi8+Cjwvc3ZnPgo=
 )][Download] [![Discord](https://img.shields.io/discord/313125603924639766.svg?color=%237289da&label=Discord&logo=discord&logoColor=%237289da)][Discord] [![Support](https://img.shields.io/badge/Patreon-Support-orange.svg?logo=Patreon)][Patreon]
 
 Forge is a free, open-source modding API all of your favourite mods use!
@@ -34,12 +34,13 @@ For support and questions, visit [the Support Forum][Support-Forum] or [the Forg
 
 We require the version of Java that Minecraft requires, which is currently:
 
-| Minecraft     | Java              |
-|---------------|-------------------|
-| 1.20.6+       | [21][Adoptium-21] |
-| 1.18 - 1.20.4 | [17][Adoptium-17] |
-| 1.17.1        | [16][Adoptium-16] |
-| 1.16.5-       | [8][Adoptium-8]   |
+| Minecraft        | Java              |
+|------------------|-------------------|
+| 26.1+            | [25][Adoptium-25] |
+| 1.20.6 - 1.21.11 | [21][Adoptium-21] |
+| 1.18 - 1.20.4    | [17][Adoptium-17] |
+| 1.17.1           | [16][Adoptium-16] |
+| 1.16.5-          | [8][Adoptium-8]   |
 
 **If you are on Windows and have difficulty using Java to launch JAR files, consider using [Jarfix by Johann Löfflmann][Jarfix].**
 
@@ -80,6 +81,7 @@ YourKit for providing us accesss to their [YourKit Java Profiler] which helps id
 
 [Download]: https://files.minecraftforge.net/
 
+[Adoptium-25]: https://adoptium.net/temurin/releases/?version=25
 [Adoptium-21]: https://adoptium.net/temurin/releases/?version=21
 [Adoptium-17]: https://adoptium.net/temurin/releases/?version=17
 [Adoptium-16]: https://adoptium.net/temurin/releases/?version=16

dump.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+
+for file in $(find repo | grep --invert-match -e md5 -e sha | grep -e .jar -e .zip); do
+    file_path=$(realpath $file)
+    file_name=$(basename $file)
+    
+    echo "$file_name"
+    files=$(unzip -l $file | awk '{print $4}')
+    for f in $files; do
+        out="_actual/$file_name/$f"
+        parent=$(dirname "$out")
+        echo $out
+        
+        if [ ! -d "$parent" ]; then
+            mkdir -p "$parent"
+        fi
+            
+        if [[ $f == *.class ]]; then
+            javap -v -p jar:file://$file_path!/$f | tail -n +4 >$out.txt
+        elif [[ $f != */ && $f != "Name" && $f != "----" ]]; then
+            unzip -o -q $file $f -d _actual/$file_name
+        fi
+    done
+done

fmlcore/build.gradle

@@ -1,68 +1,78 @@
-import net.minecraftforge.gradleutils.PomUtils
-
 plugins {
     id 'java-library'
     id 'maven-publish'
-    id 'net.minecraftforge.licenser'
-    id 'net.minecraftforge.gradleutils'
+    alias libs.plugins.licenser
+    alias libs.plugins.gradleutils
+    alias libs.plugins.gitversion
+    alias libs.plugins.changelog
+    id 'net.minecraftforge.forge.build.convention'
 }
 
-apply from: rootProject.file('build_shared.gradle')
+gradleutils.displayName = 'FML'
+final vendor = 'Forge Development LLC'
+description = 'Modifications to Minecraft to enable mod developers.'
 
 dependencies {
-    compileOnly(libs.jetbrains.annotations)
+    compileOnly libs.jetbrains.annotations
 
-    api(libs.eventbus)
-    annotationProcessor(libs.eventbus.validator)
+    api libs.eventbus
 
-    implementation(project(':fmlloader'))
-    implementation(libs.commons.io)
+    implementation projects.fmlloader
+    implementation libs.commons.io
 }
 
 java {
-    toolchain.languageVersion = JavaLanguageVersion.of(JAVA_VERSION)
+    toolchain.languageVersion = JavaLanguageVersion.of(javaVersion)
     withSourcesJar()
 }
 
-tasks.named('jar', Jar).configure {
-    manifest {
-        attributes([
-            'Automatic-Module-Name': 'net.minecraftforge.fmlcore',
-            'FMLModType': 'LIBRARY'
-        ] as LinkedHashMap)
-        attributes([
-            'Specification-Title':      'FML',
-            'Specification-Vendor':     'Forge Development LLC',
-            'Specification-Version':    '1',
-            'Implementation-Title':     'FML',
-            'Implementation-Version':   '1.0',
-            'Implementation-Vendor':    'Forge Development LLC'
-        ] as LinkedHashMap, 'net/minecraftforge/fml/')
-    }
+license {
+    header = rootProject.file('LICENSE-header.txt')
+}
+changelog {
+    from changelogBase
 }
 
 tasks.withType(JavaCompile).configureEach {
     options.compilerArgs << '-Xlint:-unchecked'
 }
 
-license {
-    header = rootProject.file('LICENSE-header.txt')
+tasks.named('jar', Jar) {
+    manifest {
+        attributes([
+                'Automatic-Module-Name': 'net.minecraftforge.fmlcore',
+                'FMLModType'           : 'LIBRARY'
+        ])
+        attributes([
+                'Specification-Title'   : gradleutils.displayName.get(),
+                'Specification-Vendor'  : vendor,
+                'Specification-Version' : '1',
+                'Implementation-Title'  : gradleutils.displayName.get(),
+                'Implementation-Version': '1.0',
+                'Implementation-Vendor' : vendor
+        ], 'net/minecraftforge/fml/')
+    }
 }
 
 publishing {
-    publications.register('mavenJava', MavenPublication).configure {
-        from components.java
-        artifactId = 'fmlcore'
-        pom {
-            name = project.name
-            description = 'Modifactions to Minecraft to enable mod developers.'
-            url = 'https://github.com/MinecraftForge/MinecraftForge'
-            PomUtils.setGitHubDetails(pom, 'MinecraftForge')
-            license PomUtils.Licenses.LGPLv2_1
-        }
-    }
-    
     repositories {
         maven gradleutils.publishingForgeMaven
     }
+
+    publications.register('mavenJava', MavenPublication) {
+        changelog.publish(it)
+        gradleutils.promote(it)
+
+        from components.java
+
+        pom {
+            description = project.description
+
+            gradleutils.pom.addRemoteDetails(pom)
+
+            licenses {
+                license gradleutils.pom.licenses.LGPLv2_1
+            }
+        }
+    }
 }

fmlcore/src/main/java/net/minecraftforge/fml/DistExecutor.java

@@ -1,273 +0,0 @@
-/*
- * Copyright (c) Forge Development LLC and contributors
- * SPDX-License-Identifier: LGPL-2.1-only
- */
-
-package net.minecraftforge.fml;
-
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.fml.loading.FMLEnvironment;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-
-import java.io.Serializable;
-import java.lang.invoke.SerializedLambda;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.Objects;
-import java.util.concurrent.Callable;
-import java.util.function.Supplier;
-
-/**
- * Use to execute code conditionally based on sidedness.
- * <ul>
- * <li>When you want to call something on one side and return a result {@link #safeCallWhenOn(Dist, Supplier)}</li>
- * <li>When you want to call one thing on one side, another thing on the other and return a result {@link #safeRunForDist(Supplier, Supplier)}</li>
- * <li>When you want to run something on one side {@link #safeRunWhenOn(Dist, Supplier)}</li>
- * </ul>
- *
- * @deprecated Historically, this allowed for safe execution of code on the correct side by exploiting a low-level
- * detail in Java 8, but in newer versions a simple if check is enough.
- * <br>
- * For example:
- * <pre>{@code
- * if (FMLEnvironment.dist.isClient()) {
- *     // client code here
- * }
- * }</pre>
- */
-@Deprecated(since = "1.21.5", forRemoval = true)
-public final class DistExecutor
-{
-    private static final Logger LOGGER = LogManager.getLogger();
-    private DistExecutor() {}
-
-    /**
-     * Run the callable in the supplier only on the specified {@link Dist}.
-     * This method is NOT sided-safe and special care needs to be taken in code using this method that implicit class
-     * loading is not triggered by the Callable.
-     *
-     * This method can cause unexpected ClassNotFound exceptions.
-     *
-     * Use {@link #safeCallWhenOn(Dist, Supplier)} where possible.
-     *
-     * @param dist The dist to run on
-     * @param toRun A supplier of the callable to run (Supplier wrapper to ensure classloading only on the appropriate dist)
-     * @param <T> The return type from the callable
-     * @return The callable's result
-     * @deprecated use {@link #safeCallWhenOn(Dist, Supplier)} instead. This remains for advanced use cases.
-     */
-    @Deprecated
-    public static <T> T callWhenOn(Dist dist, Supplier<Callable<T>> toRun) {
-        return unsafeCallWhenOn(dist, toRun);
-    }
-
-    public static <T> T unsafeCallWhenOn(Dist dist, Supplier<Callable<T>> toRun) {
-        if (dist == FMLEnvironment.dist) {
-            try
-            {
-                return toRun.get().call();
-            }
-            catch (Exception e)
-            {
-                throw new RuntimeException(e);
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Call the SafeCallable when on the correct {@link Dist}.
-     *
-     * <strong>The lambda supplied here is required to be a method reference to a method defined in
-     * another class, otherwise an invalid SafeReferent error will be thrown</strong>
-     * @param dist the dist which this will run on
-     * @param toRun the SafeCallable to run and return the result from
-     * @param <T> The type of the SafeCallable
-     * @return the result of the SafeCallable or null if on the wrong side
-     */
-    public static <T> T safeCallWhenOn(Dist dist, Supplier<SafeCallable<T>> toRun) {
-        validateSafeReferent(toRun);
-        return callWhenOn(dist, toRun::get);
-    }
-
-    /**
-     * Runs the supplied Runnable on the speicified side. Same warnings apply as {@link #callWhenOn(Dist, Supplier)}.
-     *
-     * This method can cause unexpected ClassNotFound exceptions.
-     *
-     * @see #callWhenOn(Dist, Supplier)
-     * @param dist Dist to run this code on
-     * @param toRun The code to run
-     * @deprecated use {@link #safeRunWhenOn(Dist, Supplier)} where possible. Advanced uses only.
-     */
-    @Deprecated
-    public static void runWhenOn(Dist dist, Supplier<Runnable> toRun) {
-        unsafeRunWhenOn(dist, toRun);
-    }
-    /**
-     * Runs the supplied Runnable on the speicified side. Same warnings apply as {@link #unsafeCallWhenOn(Dist, Supplier)}.
-     *
-     * This method can cause unexpected ClassNotFoundException problems in common scenarios. Understand the pitfalls of
-     * the way the class verifier works to load classes before using this.
-     *
-     * Use {@link #safeRunWhenOn(Dist, Supplier)} if you can.
-     *
-     * @see #unsafeCallWhenOn(Dist, Supplier)
-     * @param dist Dist to run this code on
-     * @param toRun The code to run
-     */
-    public static void unsafeRunWhenOn(Dist dist, Supplier<Runnable> toRun) {
-        if (dist == FMLEnvironment.dist) {
-            toRun.get().run();
-        }
-    }
-
-    /**
-     * Call the supplied SafeRunnable when on the correct Dist.
-     * @param dist The dist to run on
-     * @param toRun The code to run
-     */
-    public static void safeRunWhenOn(Dist dist, Supplier<SafeRunnable> toRun) {
-        validateSafeReferent(toRun);
-        if (dist == FMLEnvironment.dist)  {
-            toRun.get().run();
-        }
-    }
-    /**
-     * Executes one of the two suppliers, based on which side is active.
-     *
-     * <p>
-     *     Example (replacement for old SidedProxy):<br/>
-     * {@code Proxy p = DistExecutor.runForDist(()->ClientProxy::new, ()->ServerProxy::new);}
-     *
-     * NOTE: the double supplier is required to avoid classloading the secondary target.
-     *
-     * @param clientTarget The supplier supplier to run when on the {@link Dist#CLIENT}
-     * @param serverTarget The supplier supplier to run when on the {@link Dist#DEDICATED_SERVER}
-     * @param <T> The common type to return
-     * @return The returned instance
-     * @deprecated Use {@link #safeRunForDist(Supplier, Supplier)}
-     */
-    @Deprecated
-    public static <T> T runForDist(Supplier<Supplier<T>> clientTarget, Supplier<Supplier<T>> serverTarget) {
-        return unsafeRunForDist(clientTarget, serverTarget);
-    }
-
-    /**
-     * Unsafe version of {@link #safeRunForDist(Supplier, Supplier)}. Use only when you know what you're doing
-     * and understand why the verifier can cause unexpected ClassNotFoundException crashes even when code is apparently
-     * not sided. Ensure you test both sides fully to be confident in using this.
-     *
-     * @param clientTarget The supplier supplier to run when on the {@link Dist#CLIENT}
-     * @param serverTarget The supplier supplier to run when on the {@link Dist#DEDICATED_SERVER}
-     * @param <T> The common type to return
-     * @return The returned instance
-     */
-    public static <T> T unsafeRunForDist(Supplier<Supplier<T>> clientTarget, Supplier<Supplier<T>> serverTarget) {
-        switch (FMLEnvironment.dist)
-        {
-            case CLIENT:
-                return clientTarget.get().get();
-            case DEDICATED_SERVER:
-                return serverTarget.get().get();
-            default:
-                throw new IllegalArgumentException("UNSIDED?");
-        }
-    }
-    /**
-     * Executes one of the two suppliers, based on which side is active.
-     *
-     * <p>
-     *     Example (replacement for old SidedProxy):<br/>
-     * {@code Proxy p = DistExecutor.safeRunForDist(()->ClientProxy::new, ()->ServerProxy::new);}
-     *
-     * NOTE: the double supplier is required to avoid classloading the secondary target.
-     *
-     * @param clientTarget The supplier supplier to run when on the {@link Dist#CLIENT}
-     * @param serverTarget The supplier supplier to run when on the {@link Dist#DEDICATED_SERVER}
-     * @param <T> The common type to return
-     * @return The returned instance
-     */
-    public static <T> T safeRunForDist(Supplier<SafeSupplier<T>> clientTarget, Supplier<SafeSupplier<T>> serverTarget) {
-        validateSafeReferent(clientTarget);
-        validateSafeReferent(serverTarget);
-        switch (FMLEnvironment.dist)
-        {
-            case CLIENT:
-                return clientTarget.get().get();
-            case DEDICATED_SERVER:
-                return serverTarget.get().get();
-            default:
-                throw new IllegalArgumentException("UNSIDED?");
-        }
-    }
-
-    /**
-     * A safe referent. This will assert that it is being called via a separated class method reference. This will
-     * avoid the common pitfalls of {@link #callWhenOn(Dist, Supplier)} above.
-     *
-     * SafeReferents assert that they are defined as a separate method outside the scope of the calling class.
-     *
-     * <strong>Implementations need to be defined in a separate class to the referring site, with appropriate
-     * visibility to be accessible at the callsite (generally, avoid private methods).</strong>
-     *
-     * <p>
-     * Valid:<br/>
-     *
-     * {@code DistExecutor.safeCallWhenOn(Dist.CLIENT, ()->AnotherClass::clientOnlyMethod);}
-     *
-     * <p>
-     * Invalid:<br/>
-     *
-     * {@code DistExecutor.safeCallWhenOn(Dist.CLIENT, ()->()->Minecraft.getInstance().world);}
-     */
-    public interface SafeReferent {}
-
-    /**
-     * SafeCallable version of {@link SafeReferent}.
-     * @see SafeReferent
-     * @param <T> The return type of the Callable
-     */
-    public interface SafeCallable<T> extends SafeReferent, Callable<T>, Serializable {}
-
-    /**
-     * SafeSupplier version of {@link SafeReferent}
-     * @param <T> The return type of the Supplier
-     */
-    public interface SafeSupplier<T> extends SafeReferent, Supplier<T>, Serializable {}
-
-    /**
-     * SafeRunnable version of {@link SafeReferent}
-     */
-    public interface SafeRunnable extends SafeReferent, Runnable, Serializable {}
-
-    private static final void validateSafeReferent(Supplier<? extends SafeReferent> safeReferentSupplier) {
-        if (FMLEnvironment.production) return;
-        final SafeReferent setter;
-        try {
-            setter = safeReferentSupplier.get();
-        } catch (Exception e) {
-            // Typically a class cast exception, just return out, expected.
-            return;
-        }
-
-        for (Class<?> cl = setter.getClass(); cl != null; cl = cl.getSuperclass()) {
-            try {
-                Method m = cl.getDeclaredMethod("writeReplace");
-                m.setAccessible(true);
-                Object replacement = m.invoke(setter);
-                if (!(replacement instanceof SerializedLambda))
-                    break;// custom interface implementation
-                SerializedLambda l = (SerializedLambda) replacement;
-                if (Objects.equals(l.getCapturingClass(), l.getImplClass())) {
-                    LOGGER.fatal("Detected unsafe referent usage, please view the code at {}",Thread.currentThread().getStackTrace()[3]);
-                    throw new RuntimeException("Unsafe Referent usage found in safe referent method");
-                }
-            } catch (NoSuchMethodException e) {
-            } catch (IllegalAccessException | InvocationTargetException e) {
-                break;
-            }
-        }
-    }
-}

fmlcore/src/main/java/net/minecraftforge/fml/IModLoadingState.java

@@ -6,13 +6,14 @@
 package net.minecraftforge.fml;
 
 import net.minecraftforge.fml.loading.progress.ProgressMeter;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
-import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executor;
-import java.util.function.Consumer;
 import java.util.function.Function;
-import java.util.function.ToIntFunction;
+import java.util.function.IntSupplier;
+import java.util.function.Supplier;
 
 /**
  * A mod loading state. During mod loading, the mod loader transitions between states in a defined sorted list of states,
@@ -20,6 +21,7 @@ import java.util.function.ToIntFunction;
  *
  * @see IModStateProvider
  */
+@NullMarked
 public interface IModLoadingState {
     /**
      * {@return the name of this state}
@@ -42,19 +44,21 @@ public interface IModLoadingState {
     /**
      * {@return a function returning a human-friendly message for this state}
      */
-    Function<ModList, String> message();
+    Supplier<String> message();
 
     /**
      * @return a function that computes the size of this transition based on the size of the modlist.
      * Used to compute progress.
      */
-    ToIntFunction<ModList> size();
+    default IntSupplier size() {
+        return ModList::size;
+    }
 
     /**
      * {@return an optional runnable, which runs before starting the transition from this state to the next}
      * @see #buildTransition(Executor, Executor, ProgressMeter, Function, Function)
      */
-    Optional<Consumer<ModList>> inlineRunnable();
+    @Nullable Runnable inlineRunnable();
 
     /**
      * Builds the transition task for this state with a blank pre-sync and post-sync task.
@@ -65,14 +69,14 @@ public interface IModLoadingState {
      * @return a transition task for this state
      * @see #buildTransition(Executor, Executor, ProgressMeter, Function, Function)
      */
-    default Optional<CompletableFuture<Void>> buildTransition(
+    default @Nullable CompletableFuture<Void> buildTransition(
         final Executor syncExecutor,
         final Executor parallelExecutor,
         final ProgressMeter progressBar
     ) {
         return buildTransition(syncExecutor, parallelExecutor, progressBar,
-            e -> CompletableFuture.completedFuture(null),
-            e -> CompletableFuture.completedFuture(null)
+            _ -> CompletableFuture.completedFuture(null),
+            _ -> CompletableFuture.completedFuture(null)
         );
     }
 
@@ -87,7 +91,7 @@ public interface IModLoadingState {
      * @param postSyncTask     a function which returns a task to run after event post-dispatch hook
      * @return a transition task for this state
      */
-    Optional<CompletableFuture<Void>> buildTransition(final Executor syncExecutor,
+    @Nullable CompletableFuture<Void> buildTransition(final Executor syncExecutor,
                                                       final Executor parallelExecutor,
                                                       final ProgressMeter progressBar,
                                                       final Function<Executor, CompletableFuture<Void>> preSyncTask,

fmlcore/src/main/java/net/minecraftforge/fml/IModStateTransition.java

@@ -6,21 +6,16 @@
 package net.minecraftforge.fml;
 
 import net.minecraftforge.fml.event.IModBusEvent;
-import net.minecraftforge.fml.loading.progress.ProgressMeter;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executor;
 import java.util.function.BiFunction;
 import java.util.function.Function;
-import java.util.function.Supplier;
-import java.util.stream.Stream;
 
+import net.minecraftforge.fml.loading.progress.ProgressMeter;
 import org.jetbrains.annotations.Nullable;
 
 public interface IModStateTransition {
-    /** Magic value to allow me to optimize the futures list by ignoring the default value without making old methods nullable. */
-    BiFunction<Executor, ? extends EventGenerator<?>, CompletableFuture<Void>> NULL_HOOK = (e, g) -> CompletableFuture.completedFuture(null);
-
     static IModStateTransition buildNoopTransition() {
         return ModStateTransitionHelper.NOOP;
     }
@@ -40,15 +35,6 @@ public interface IModStateTransition {
         return ModLoadingStage::nextState;
     }
 
-    /**
-     * This used to allow you to fire multiple events during the transition. However, in doing so it would cause issues with the default
-     * ModContainer's event handlers causing issues such as mod classes being constructed multiple times.
-     */
-    @Deprecated(since = "1.21.3", forRemoval = true)
-    default Supplier<Stream<EventGenerator<?>>> eventFunctionStream() {
-        return () -> Stream.ofNullable(eventFunction());
-    }
-
     @Nullable
     default <T extends IModBusEvent> EventGenerator<T> eventFunction() {
         return null;
@@ -57,25 +43,9 @@ public interface IModStateTransition {
     ThreadSelector threadSelector();
     BiFunction<Executor, CompletableFuture<Void>, CompletableFuture<Void>> finalActivityGenerator();
 
-    /**
-     * I think this was meant as a way to do some things for each mod container beforge/after the transition had been sent to the container.
-     * However, the Future returned by this was never linked to the main transition future in any way.  Which means that it was run
-     * in parallel and couldn't guarantee the state of the ModContainer.
-     * <p>
-     * Plus all existing code that I could find returned a completedFuture, so I don't think anyone ever used this.
-     * <p>
-     * If I were to add this back it would be a CompletableFuture wrap(ModContainer, CompletableFuture)
-     * <p>
-     * Added magic value NULL_HOOK to allow me to optimize the futures list by ignoring the default value without making this method nullable.
-     */
-    @Deprecated(since = "1.21.3", forRemoval = true)
-    default BiFunction<Executor, ? extends EventGenerator<?>, CompletableFuture<Void>> preDispatchHook() { return NULL_HOOK; }
-    @Deprecated(since = "1.21.3", forRemoval = true)
-    default BiFunction<Executor, ? extends EventGenerator<?>, CompletableFuture<Void>> postDispatchHook() { return NULL_HOOK; }
-
     interface EventGenerator<T extends IModBusEvent> extends Function<ModContainer, T> {
         static <FN extends IModBusEvent> EventGenerator<FN> fromFunction(Function<ModContainer, FN> fn) {
             return fn::apply;
         }
     }
-}
+}

fmlcore/src/main/java/net/minecraftforge/fml/InterModComms.java

@@ -5,63 +5,20 @@
 
 package net.minecraftforge.fml;
 
-
 import java.util.Iterator;
 import java.util.Spliterator;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.ConcurrentMap;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
-public class InterModComms
-{
-    public record IMCMessage(String senderModId, String modId, String method, Supplier<?> messageSupplier) {
+public final class InterModComms {
+    public record IMCMessage(String senderModId, String modId, String method, Supplier<?> messageSupplier) {}
 
-        /**
-         * Deprecated: use {@link #senderModId()}
-         * @return The modid of the sender. This is supplied by the caller, or by the active mod container context.
-         * Consider it unreliable.
-         */
-        @Deprecated
-        public final String getSenderModId() {
-            return this.senderModId;
-        }
-
-        /**
-         * Deprecated: use {@link #modId()}
-         * @return The modid being sent to.
-         */
-        @Deprecated
-        public final String getModId() {
-            return this.modId;
-        }
-
-        /**
-         * Deprecated: use {@link #method()}
-         * @return The method being sent to.
-         */
-        @Deprecated
-        public final String getMethod() {
-            return this.method;
-        }
-
-        /**
-         * @param <T> The type of the message.
-         * @return A {@link Supplier} of the message.
-         * Use {@link #messageSupplier()}
-         */
-        @SuppressWarnings("unchecked")
-        @Deprecated
-        public final <T> Supplier<T> getMessageSupplier() {
-            return (Supplier<T>) this.messageSupplier;
-        }
-    }
-
-    private static final ConcurrentMap<String, ConcurrentLinkedQueue<IMCMessage>> containerQueues = new ConcurrentHashMap<>();
+    private static final ConcurrentHashMap<String, ConcurrentLinkedQueue<IMCMessage>> containerQueues = new ConcurrentHashMap<>();
 
     /**
      * Send IMC to remote. Sender will default to the active modcontainer, or minecraft if not.
@@ -72,8 +29,9 @@ public class InterModComms
      * @return true if the message was enqueued for sending (the target modid is loaded)
      */
     public static boolean sendTo(final String modId, final String method, final Supplier<?> thing) {
-        if (!ModList.get().isLoaded(modId)) return false;
-        containerQueues.computeIfAbsent(modId, k->new ConcurrentLinkedQueue<>()).add(new IMCMessage(ModLoadingContext.get().getActiveContainer().getModId(), modId, method, thing));
+        if (!ModList.isLoaded(modId)) return false;
+        containerQueues.computeIfAbsent(modId, _ -> new ConcurrentLinkedQueue<>())
+                .add(new IMCMessage(ModLoadingContext.get().getContainer().getModId(), modId, method, thing));
         return true;
     }
 
@@ -87,8 +45,9 @@ public class InterModComms
      * @return true if the message was enqueued for sending (the target modid is loaded)
      */
     public static boolean sendTo(final String senderModId, final String modId, final String method, final Supplier<?> thing) {
-        if (!ModList.get().isLoaded(modId)) return false;
-        containerQueues.computeIfAbsent(modId, k->new ConcurrentLinkedQueue<>()).add(new IMCMessage(senderModId, modId, method, thing));
+        if (!ModList.isLoaded(modId)) return false;
+        containerQueues.computeIfAbsent(modId, _ -> new ConcurrentLinkedQueue<>())
+                .add(new IMCMessage(senderModId, modId, method, thing));
         return true;
     }
 
@@ -112,7 +71,7 @@ public class InterModComms
      * @return All messages
      */
     public static Stream<IMCMessage> getMessages(final String modId) {
-        return getMessages(modId, s->Boolean.TRUE);
+        return getMessages(modId, _ -> true);
     }
 
     private record QueueFilteringSpliterator(
@@ -136,13 +95,10 @@ public class InterModComms
         }
 
         @Override
-        public boolean tryAdvance(final Consumer<? super IMCMessage> action)
-        {
+        public boolean tryAdvance(final Consumer<? super IMCMessage> action) {
             IMCMessage next;
-            do
-            {
-                if (!iterator.hasNext())
-                {
+            do {
+                if (!iterator.hasNext()) {
                     return false;
                 }
                 next = this.iterator.next();
@@ -157,6 +113,5 @@ public class InterModComms
         public Spliterator<IMCMessage> trySplit() {
             return null;
         }
-
     }
 }

fmlcore/src/main/java/net/minecraftforge/fml/ModContainer.java

@@ -5,6 +5,7 @@
 
 package net.minecraftforge.fml;
 
+import net.minecraftforge.eventbus.api.bus.BusGroup;
 import net.minecraftforge.fml.config.IConfigEvent;
 import net.minecraftforge.fml.config.ModConfig;
 import net.minecraftforge.fml.event.IModBusEvent;
@@ -18,7 +19,6 @@ import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.BiPredicate;
-import java.util.function.Consumer;
 import java.util.function.Supplier;
 
 /**
@@ -40,11 +40,6 @@ public abstract class ModContainer {
     protected final Map<Class<? extends IExtensionPoint<?>>, Supplier<?>> extensionPoints = new IdentityHashMap<>();
     protected final EnumMap<ModConfig.Type, ModConfig> configs = new EnumMap<>(ModConfig.Type.class);
     final Set<ModContainer> dependencies = new HashSet<>();
-    /**
-     * If you want to handle the event, override {@link #dispatchConfigEvent(IConfigEvent)}
-     */
-    @Deprecated(since = "1.21.3", forRemoval = true)
-    protected Optional<Consumer<IConfigEvent>> configHandler = Optional.empty();
 
     public ModContainer(IModInfo info) {
         this.modId = info.getModId();
@@ -137,12 +132,7 @@ public abstract class ModContainer {
        configs.put(modConfig.getType(), modConfig);
     }
 
-    public void dispatchConfigEvent(IConfigEvent event) {
-        var handler = configHandler.orElse(null);
-        if (handler != null) {
-            handler.accept(event);
-        }
-    }
+    public void dispatchConfigEvent(IConfigEvent event) {}
 
     /**
      * Does this mod match the supplied mod?
@@ -157,6 +147,14 @@ public abstract class ModContainer {
      */
     public abstract Object getMod();
 
+    /**
+     * @return the mod bus group for this specific mod, or null if there is none.
+     *         Leave null if you use {@link BusGroup#DEFAULT} for your mod lifecycle events.
+     */
+    public BusGroup getModBusGroup() {
+        return null;
+    }
+
     /**
      * Accept an arbitrary event for processing by the mod. Probably posted to an event bus in the lower level container.
      * @param e Event to accept

fmlcore/src/main/java/net/minecraftforge/fml/ModList.java

@@ -5,14 +5,14 @@
 
 package net.minecraftforge.fml;
 
+import net.minecraftforge.fml.loading.LoadingModList;
 import net.minecraftforge.forgespi.language.IModFileInfo;
 import net.minecraftforge.forgespi.language.IModInfo;
 import net.minecraftforge.forgespi.language.ModFileScanData;
 import net.minecraftforge.fml.loading.moddiscovery.ModFile;
 import net.minecraftforge.fml.loading.moddiscovery.ModFileInfo;
-import net.minecraftforge.fml.loading.moddiscovery.ModInfo;
 import net.minecraftforge.forgespi.locating.IModFile;
-import java.util.Collections;
+
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
@@ -30,33 +30,36 @@ import java.util.stream.Stream;
  * Master list of all mods - game-side version. This is classloaded in the game scope and
  * can dispatch game level events as a result.
  */
-public class ModList {
-    private static ModList INSTANCE;
-    private final List<IModFileInfo> modFiles;
-    private final List<IModInfo> sortedList;
-    private final Map<String, IModFileInfo> fileById;
-    private List<ModContainer> mods;
-    private Map<String, ModContainer> indexedMods;
-    private List<ModFileScanData> modFileScanData;
-    private List<ModContainer> sortedContainers;
+public final class ModList {
+    private ModList() {}
 
-    private ModList(final List<ModFile> modFiles, final List<ModInfo> sortedList) {
-        this.modFiles = modFiles.stream().map(ModFile::getModFileInfo).toList();
-        this.sortedList = sortedList.stream().map(IModInfo.class::cast).toList();
+    private static final List<IModFileInfo> MOD_FILES;
+    private static final List<IModInfo> SORTED_LIST;
+    private static final Map<String, IModFileInfo> FILE_BY_ID;
+    private static List<ModContainer> mods;
+    private static Map<String, ModContainer> indexedMods;
+    private static List<ModContainer> sortedContainers;
+
+    static {
+        var loadingModFiles = LoadingModList.getModFiles().stream().map(ModFileInfo::getFile).toList();
+        var loadingSortedList = LoadingModList.getMods();
+
+        var modFileInfos = MOD_FILES = loadingModFiles.stream().map(ModFile::getModFileInfo).toList();
+        SORTED_LIST = loadingSortedList.stream().map(IModInfo.class::cast).toList();
         var byId = new HashMap<String, IModFileInfo>();
-        for (var file : this.modFiles) {
+        for (var file : modFileInfos) {
             for (var mod : file.getMods())
                 byId.put(mod.getModId(), mod.getOwningFile());
         }
-        this.fileById = Collections.unmodifiableMap(byId);
-        CrashReportCallables.registerCrashCallable("Mod List", this::crashReport);
+        FILE_BY_ID = Map.copyOf(byId);
+        CrashReportCallables.registerCrashCallable("Mod List", ModList::crashReport);
     }
 
-    private String getModContainerState(String modId) {
+    private static String getModContainerState(String modId) {
         return getModContainerById(modId).map(ModContainer::getCurrentState).map(Object::toString).orElse("NONE");
     }
 
-    private String fileToLine(IModFile mf) {
+    private static String fileToLine(IModFile mf) {
         var mainMod = mf.getModInfos().getFirst();
         return String.format(Locale.ENGLISH, "%-50.50s|%-30.30s|%-30.30s|%-20.20s|%-10.10s|Manifest: %s", mf.getFileName(),
                 mainMod.getDisplayName(),
@@ -66,93 +69,92 @@ public class ModList {
                 ((ModFileInfo)mf.getModFileInfo()).getCodeSigningFingerprint().orElse("NOSIGNATURE"));
     }
 
-    private String crashReport() {
-        return "\n"+applyForEachModFile(this::fileToLine).collect(Collectors.joining("\n\t\t", "\t\t", ""));
+    private static String crashReport() {
+        return "\n" + applyForEachModFile(ModList::fileToLine).collect(Collectors.joining("\n\t\t", "\t\t", ""));
     }
 
-    public static ModList of(List<ModFile> modFiles, List<ModInfo> sortedList) {
-        INSTANCE = new ModList(modFiles, sortedList);
-        return INSTANCE;
+    public static void init() {}
+
+    public static List<IModFileInfo> getModFiles() {
+        return MOD_FILES;
     }
 
-    public static ModList get() {
-        return INSTANCE;
+    public static IModFileInfo getModFileById(String modid) {
+        return FILE_BY_ID.get(modid);
     }
 
-    public List<IModFileInfo> getModFiles() {
-        return modFiles;
+    static void setLoadedMods(final List<ModContainer> modContainers) {
+        mods = modContainers;
+        sortedContainers = modContainers.stream().sorted(Comparator.comparingInt(c -> SORTED_LIST.indexOf(c.getModInfo()))).toList();
+        indexedMods = modContainers.stream().collect(Collectors.toUnmodifiableMap(ModContainer::getModId, Function.identity()));
     }
 
-    public IModFileInfo getModFileById(String modid) {
-        return this.fileById.get(modid);
-    }
-
-    void setLoadedMods(final List<ModContainer> modContainers) {
-        this.mods = modContainers;
-        this.sortedContainers = modContainers.stream().sorted(Comparator.comparingInt(c -> sortedList.indexOf(c.getModInfo()))).toList();
-        this.indexedMods = modContainers.stream().collect(Collectors.toMap(ModContainer::getModId, Function.identity()));
+    static void clearLoadedMods() {
+        mods = List.of();
+        indexedMods = Map.of();
+        sortedContainers = List.of();
     }
 
     @SuppressWarnings("unchecked")
-    public <T> Optional<T> getModObjectById(String modId) {
+    public static <T> Optional<T> getModObjectById(String modId) {
         return getModContainerById(modId).map(ModContainer::getMod).map(o -> (T) o);
     }
 
-    public Optional<? extends ModContainer> getModContainerById(String modId) {
-        return Optional.ofNullable(this.indexedMods.get(modId));
+    public static Optional<? extends ModContainer> getModContainerById(String modId) {
+        return Optional.ofNullable(indexedMods.get(modId));
     }
 
-    public Optional<? extends ModContainer> getModContainerByObject(Object obj) {
+    public static Optional<? extends ModContainer> getModContainerByObject(Object obj) {
         return mods.stream().filter(mc -> mc.getMod() == obj).findFirst();
     }
 
-    public List<IModInfo> getMods() {
-        return this.sortedList;
+    public static List<IModInfo> getMods() {
+        return SORTED_LIST;
     }
 
-    public boolean isLoaded(String modTarget) {
-        return this.indexedMods.containsKey(modTarget);
+    public static boolean isLoaded(String modTarget) {
+        return indexedMods.containsKey(modTarget);
     }
 
-    public int size() {
+    public static int size() {
         return mods.size();
     }
 
-    public List<ModFileScanData> getAllScanData() {
-        if (modFileScanData == null) {
-            modFileScanData = this.sortedList.stream().
-                    map(IModInfo::getOwningFile).
-                    filter(Objects::nonNull).
-                    map(IModFileInfo::getFile).
-                    distinct().
-                    map(IModFile::getScanResult).
-                    collect(Collectors.toList());
+    public static List<ModFileScanData> getAllScanData() {
+        final class LazyInit {
+            private LazyInit() {}
+            private static final List<ModFileScanData> MOD_FILE_SCAN_DATA = SORTED_LIST.stream()
+                    .map(IModInfo::getOwningFile)
+                    .filter(Objects::nonNull)
+                    .map(IModFileInfo::getFile)
+                    .distinct()
+                    .map(IModFile::getScanResult)
+                    .toList();
         }
-        return modFileScanData;
-
+        return LazyInit.MOD_FILE_SCAN_DATA;
     }
 
-    public void forEachModFile(Consumer<IModFile> fileConsumer) {
-        modFiles.stream().map(IModFileInfo::getFile).forEach(fileConsumer);
+    public static void forEachModFile(Consumer<IModFile> fileConsumer) {
+        MOD_FILES.stream().map(IModFileInfo::getFile).forEach(fileConsumer);
     }
 
-    public <T> Stream<T> applyForEachModFile(Function<IModFile, T> function) {
-        return modFiles.stream().map(IModFileInfo::getFile).map(function);
+    public static <T> Stream<T> applyForEachModFile(Function<IModFile, T> function) {
+        return MOD_FILES.stream().map(IModFileInfo::getFile).map(function);
     }
 
-    public void forEachModContainer(BiConsumer<String, ModContainer> modContainerConsumer) {
+    public static void forEachModContainer(BiConsumer<String, ModContainer> modContainerConsumer) {
         indexedMods.forEach(modContainerConsumer);
     }
 
-    public void forEachModInOrder(Consumer<ModContainer> containerConsumer) {
-        this.sortedContainers.forEach(containerConsumer);
+    public static void forEachModInOrder(Consumer<ModContainer> containerConsumer) {
+        sortedContainers.forEach(containerConsumer);
     }
 
-    public List<ModContainer> getLoadedMods() {
-        return this.sortedContainers;
+    public static List<ModContainer> getLoadedMods() {
+        return sortedContainers;
     }
 
-    public <T> Stream<T> applyForEachModContainer(Function<ModContainer, T> function) {
+    public static <T> Stream<T> applyForEachModContainer(Function<ModContainer, T> function) {
         return indexedMods.values().stream().map(function);
     }
 }

fmlcore/src/main/java/net/minecraftforge/fml/ModLoader.java

@@ -5,15 +5,11 @@
 
 package net.minecraftforge.fml;
 
-import com.google.common.collect.ImmutableList;
+import net.minecraftforge.eventbus.api.bus.BusGroup;
 import net.minecraftforge.fml.event.IModBusEvent;
-import net.minecraftforge.fml.loading.FMLEnvironment;
-import net.minecraftforge.fml.loading.FMLLoader;
-import net.minecraftforge.fml.loading.ImmediateWindowHandler;
-import net.minecraftforge.fml.loading.LoadingModList;
+import net.minecraftforge.fml.loading.*;
 import net.minecraftforge.fml.loading.moddiscovery.InvalidModIdentifier;
 import net.minecraftforge.fml.loading.moddiscovery.ModFileInfo;
-import net.minecraftforge.fml.loading.moddiscovery.ModInfo;
 import net.minecraftforge.fml.loading.progress.ProgressMeter;
 import net.minecraftforge.fml.loading.progress.StartupNotificationManager;
 import net.minecraftforge.forgespi.language.IModInfo;
@@ -70,92 +66,76 @@ import static net.minecraftforge.fml.Logging.LOADING;
  *     and completes the mod loading sequence.</dd>
  * </dl>
  */
-public class ModLoader {
+public final class ModLoader {
+    private ModLoader() {}
+
     private static final Logger LOGGER = LogManager.getLogger();
-    private final LoadingModList loadingModList;
-
-    private final List<ModLoadingException> loadingExceptions;
-    private final Set<IModInfo> erroredModInfos;
-    private final List<ModLoadingWarning> loadingWarnings;
-    private final ModStateManager stateManager;
+    private static final ArrayList<ModLoadingException> LOADING_EXCEPTIONS = new ArrayList<>();
+    private static final ArrayList<ModLoadingWarning> LOADING_WARNINGS = new ArrayList<>();
+    private static final Consumer<String> STATUS_CONSUMER = StartupNotificationManager.modLoaderConsumer().orElse(_ -> {});
+    private static final HashSet<IModLoadingState> COMPLETED_STATES = new HashSet<>();
     private static boolean loadingStateValid;
-    private final Consumer<String> statusConsumer = StartupNotificationManager.modLoaderConsumer().orElse(msg -> {});
-    private final Set<IModLoadingState> completedStates = new HashSet<>();
-    private ModList modList;
-
-    private ModLoader() {
-        this.loadingModList = FMLLoader.getLoadingModList();
-        this.loadingExceptions = this.loadingModList.getErrors().stream()
-                .flatMap(ModLoadingException::fromEarlyException)
-                .collect(Collectors.toList());
-        this.loadingWarnings = this.loadingModList.getBrokenFiles().stream()
-                .map(file -> new ModLoadingWarning(null, ModLoadingStage.VALIDATE, InvalidModIdentifier.identifyJarProblem(file.getFilePath()).orElse("fml.modloading.brokenfile"), file.getFileName()))
-                .collect(Collectors.toList());
-        if (this.loadingExceptions.isEmpty()) {
-            this.erroredModInfos = Collections.emptySet();
-        } else {
-            this.erroredModInfos = Collections.newSetFromMap(new IdentityHashMap<>());
-            this.erroredModInfos.addAll(this.loadingExceptions.stream().map(ModLoadingException::getModInfo).toList());
-        }
-        this.loadingModList.getModFiles().stream()
-                .filter(ModFileInfo::missingLicense)
-                .filter(modFileInfo -> modFileInfo.getMods().stream().noneMatch(this.erroredModInfos::contains)) //Ignore files where any other mod already encountered an error
-                .map(modFileInfo -> new ModLoadingException(null, ModLoadingStage.VALIDATE, "fml.modloading.missinglicense", null, modFileInfo.getFile()))
-                .forEach(this.loadingExceptions::add);
-        this.stateManager = new ModStateManager();
-        CrashReportCallables.registerCrashCallable("ModLauncher", FMLLoader::getLauncherInfo);
-        CrashReportCallables.registerCrashCallable("ModLauncher launch target", FMLLoader::launcherHandlerName);
-        CrashReportCallables.registerCrashCallable("ModLauncher naming", FMLLoader::getNaming);
-        CrashReportCallables.registerCrashCallable("ModLauncher services", ModLoader::computeModLauncherServiceList);
-        CrashReportCallables.registerCrashCallable("FML Language Providers", ModLoader::computeLanguageList);
-    }
 
     private static String computeLanguageList() {
-        return "\n" + FMLLoader.getLanguageLoadingProvider()
-                .applyForEach(lp -> lp.name() + "@" + lp.getClass().getPackage().getImplementationVersion())
+        return "\n" + LanguageLoadingProvider
+                .applyForEach(lp -> lp.name() + '@' + lp.getClass().getPackage().getImplementationVersion())
                 .collect(Collectors.joining("\n\t\t", "\t\t", ""));
     }
 
     private static String computeModLauncherServiceList() {
         final List<Map<String, String>> mods = FMLLoader.modLauncherModList();
-        return "\n"+mods.stream().map(mod->mod.getOrDefault("file","nofile")+
-                " "+mod.getOrDefault("name", "missing")+
-                " "+mod.getOrDefault("type","NOTYPE")+
-                " "+mod.getOrDefault("description", "")).
+        return "\n" + mods.stream().map(mod -> mod.getOrDefault("file","nofile") +
+                ' ' + mod.getOrDefault("name", "missing") +
+                ' ' + mod.getOrDefault("type","NOTYPE") +
+                ' ' + mod.getOrDefault("description", "")).
                 collect(Collectors.joining("\n\t\t","\t\t",""));
     }
 
-    public static ModLoader get() {
-        return LazyInit.INSTANCE;
-    }
-
-    private static final class LazyInit {
-        private static final ModLoader INSTANCE = new ModLoader();
-        private LazyInit() {}
-    }
-
     /**
      * Run on the primary starting thread by ClientModLoader and ServerModLoader
      * @param syncExecutor An executor to run tasks on the main thread
      * @param parallelExecutor An executor to run tasks on a parallel loading thread pool
      * @param periodicTask Optional periodic task to perform on the main thread while other activities run
      */
-    public void gatherAndInitializeMods(final ModWorkManager.DrivenExecutor syncExecutor, final Executor parallelExecutor, final Runnable periodicTask) {
+    public static void gatherAndInitializeMods(final ModWorkManager.DrivenExecutor syncExecutor, final Executor parallelExecutor, final Runnable periodicTask) {
+        var loadingExceptions = LoadingModList.getErrors().stream()
+                .flatMap(ModLoadingException::fromEarlyException)
+                .toList();
+        ModLoader.LOADING_EXCEPTIONS.addAll(loadingExceptions);
+        LOADING_WARNINGS.addAll(LoadingModList.getBrokenFiles().stream()
+                .map(file -> new ModLoadingWarning(null, ModLoadingStage.VALIDATE, InvalidModIdentifier.identifyJarProblem(file.getFilePath()).orElse("fml.modloading.brokenfile"), file.getFileName()))
+                .toList());
+        Set<IModInfo> erroredModInfos;
+        if (loadingExceptions.isEmpty()) {
+            erroredModInfos = Collections.emptySet();
+        } else {
+            erroredModInfos = Collections.newSetFromMap(new IdentityHashMap<>());
+            erroredModInfos.addAll(loadingExceptions.stream().map(ModLoadingException::getModInfo).toList());
+        }
+        LoadingModList.getModFiles().stream()
+                .filter(ModFileInfo::missingLicense)
+                .filter(modFileInfo -> modFileInfo.getMods().stream().noneMatch(erroredModInfos::contains)) //Ignore files where any other mod already encountered an error
+                .map(modFileInfo -> new ModLoadingException(null, ModLoadingStage.VALIDATE, "fml.modloading.missinglicense", null, modFileInfo.getFile()))
+                .forEach(LOADING_EXCEPTIONS::add);
+        CrashReportCallables.registerCrashCallable("ModLauncher", FMLLoader::getLauncherInfo);
+        CrashReportCallables.registerCrashCallable("ModLauncher launch target", FMLLoader::launcherHandlerName);
+        CrashReportCallables.registerCrashCallable("ModLauncher naming", FMLLoader::getNaming);
+        CrashReportCallables.registerCrashCallable("ModLauncher services", ModLoader::computeModLauncherServiceList);
+        CrashReportCallables.registerCrashCallable("FML Language Providers", ModLoader::computeLanguageList);
+
         ForgeFeature.registerFeature("javaVersion", ForgeFeature.VersionFeatureTest.forVersionString(IModInfo.DependencySide.BOTH, System.getProperty("java.version")));
         ForgeFeature.registerFeature("openGLVersion", ForgeFeature.VersionFeatureTest.forVersionString(IModInfo.DependencySide.CLIENT, ImmediateWindowHandler.getGLVersion()));
         loadingStateValid = true;
         FMLLoader.backgroundScanHandler.waitForScanToComplete(periodicTask);
-        final ModList modList = ModList.of(loadingModList.getModFiles().stream().map(ModFileInfo::getFile).toList(),
-                loadingModList.getMods());
-        if (!this.loadingExceptions.isEmpty()) {
-            LOGGER.fatal(CORE, "Error during pre-loading phase", loadingExceptions.getFirst());
-            statusConsumer.accept("ERROR DURING MOD LOADING");
-            modList.setLoadedMods(Collections.emptyList());
+        if (!LOADING_EXCEPTIONS.isEmpty()) {
+            LOGGER.fatal(CORE, "Error during pre-loading phase", LOADING_EXCEPTIONS.getFirst());
+            STATUS_CONSUMER.accept("ERROR DURING MOD LOADING");
+            ModList.clearLoadedMods();
             loadingStateValid = false;
-            throw new LoadingFailedException(loadingExceptions);
+            throw new LoadingFailedException(LOADING_EXCEPTIONS);
         }
         var failedBounds = new ArrayList<ForgeFeature.Bound>();
-        for (var mod : loadingModList.getMods()) {
+        for (var mod : LoadingModList.getMods()) {
             for (var feature : mod.getForgeFeatures()) {
                 if (!ForgeFeature.testFeature(FMLEnvironment.dist, feature))
                     failedBounds.add(feature);
@@ -164,8 +144,8 @@ public class ModLoader {
 
         if (!failedBounds.isEmpty()) {
             LOGGER.fatal(CORE, "Failed to validate feature bounds for mods: {}", failedBounds);
-            statusConsumer.accept("ERROR DURING MOD LOADING");
-            modList.setLoadedMods(Collections.emptyList());
+            STATUS_CONSUMER.accept("ERROR DURING MOD LOADING");
+            ModList.clearLoadedMods();
             loadingStateValid = false;
             throw new LoadingFailedException(failedBounds.stream()
                     .map(fb -> new ModLoadingException(fb.modInfo(), ModLoadingStage.CONSTRUCT, "fml.modloading.feature.missing", null, fb, ForgeFeature.featureValue(fb)))
@@ -173,18 +153,18 @@ public class ModLoader {
         }
 
         final var modContainers = new HashMap<String, ModContainer>();
-        for (var file : loadingModList.getModFiles()) {
-            var containers = this.buildMods(file.getFile());
+        for (var file : LoadingModList.getModFiles()) {
+            var containers = buildMods(file.getFile());
             for (var container : containers)
                 modContainers.put(container.getModId(), container);
         }
 
-        if (!loadingExceptions.isEmpty()) {
-            LOGGER.fatal(CORE, "Failed to initialize mod containers", loadingExceptions.getFirst());
-            statusConsumer.accept("ERROR DURING MOD LOADING");
-            modList.setLoadedMods(Collections.emptyList());
+        if (!LOADING_EXCEPTIONS.isEmpty()) {
+            LOGGER.fatal(CORE, "Failed to initialize mod containers", LOADING_EXCEPTIONS.getFirst());
+            STATUS_CONSUMER.accept("ERROR DURING MOD LOADING");
+            ModList.clearLoadedMods();
             loadingStateValid = false;
-            throw new LoadingFailedException(loadingExceptions);
+            throw new LoadingFailedException(LOADING_EXCEPTIONS);
         }
 
         // Gather all dependencies, so we can make sure they have finished their transition events before we fire ours
@@ -207,36 +187,47 @@ public class ModLoader {
             }
         }
 
-        modList.setLoadedMods(modContainers.values().stream().toList());
-        this.modList = modList;
-        var stateList = stateManager.getStates(ModLoadingPhase.GATHER);
-        var progress = StartupMessageManager.addProgressBar("Mod Gather", stateList.stream().mapToInt(mls -> mls.size().applyAsInt(this.modList)).sum());
+        ModList.setLoadedMods(modContainers.values().stream().toList());
+        var stateList = ModStateManager.getStates(ModLoadingPhase.GATHER);
+        var progress = StartupMessageManager.addProgressBar("Mod Gather", stateList.stream().mapToInt(mls -> mls.size().getAsInt()).sum());
         for (IModLoadingState mls : stateList) {
             dispatchAndHandleError(mls, syncExecutor, parallelExecutor, periodicTask, progress);
         }
         progress.complete();
     }
 
-    public void loadMods(final ModWorkManager.DrivenExecutor syncExecutor, final Executor parallelExecutor, final Runnable periodicTask) {
-        var stateList = stateManager.getStates(ModLoadingPhase.LOAD);
-        var progress = StartupMessageManager.addProgressBar("Mod Loading", stateList.stream().mapToInt(mls -> mls.size().applyAsInt(modList)).sum());
+    public static void loadMods(final ModWorkManager.DrivenExecutor syncExecutor, final Executor parallelExecutor, final Runnable periodicTask) {
+        var stateList = ModStateManager.getStates(ModLoadingPhase.LOAD);
+        var progress = StartupMessageManager.addProgressBar("Mod Loading", stateList.stream().mapToInt(mls -> mls.size().getAsInt()).sum());
         for (IModLoadingState mls : stateList) {
             dispatchAndHandleError(mls, syncExecutor, parallelExecutor, periodicTask, progress);
         }
         progress.complete();
     }
 
-    public void finishMods(final ModWorkManager.DrivenExecutor syncExecutor, final Executor parallelExecutor, final Runnable periodicTask) {
-        var stateList = stateManager.getStates(ModLoadingPhase.COMPLETE);
-        var progress = StartupMessageManager.addProgressBar("Mod Complete", stateList.stream().mapToInt(mls -> mls.size().applyAsInt(modList)).sum());
+    public static void finishMods(final ModWorkManager.DrivenExecutor syncExecutor, final Executor parallelExecutor, final Runnable periodicTask) {
+        var stateList = ModStateManager.getStates(ModLoadingPhase.COMPLETE);
+        var progress = StartupMessageManager.addProgressBar("Mod Complete", stateList.stream().mapToInt(mls -> mls.size().getAsInt()).sum());
         for (IModLoadingState mls : stateList) {
             dispatchAndHandleError(mls, syncExecutor, parallelExecutor, periodicTask, progress);
         }
-        statusConsumer.accept(String.format("Mod loading complete - %d mods loaded", this.modList.size()));
+
+        var modBusGroups = Set.of(
+                ModList.getLoadedMods().stream()
+                        .map(ModContainer::getModBusGroup)
+                        .filter(Objects::nonNull)
+                        .toArray(BusGroup[]::new)
+        );
+        for (var modBusGroup : modBusGroups) {
+            parallelExecutor.execute(modBusGroup::trim);
+        }
+        parallelExecutor.execute(BusGroup.DEFAULT::trim);
+
+        STATUS_CONSUMER.accept("Mod loading complete - %d mods loaded".formatted(ModList.size()));
         progress.complete();
     }
 
-    private void dispatchAndHandleError(IModLoadingState state, ModWorkManager.DrivenExecutor syncExecutor, Executor parallelExecutor, final Runnable ticker, final ProgressMeter progressBar) {
+    private static void dispatchAndHandleError(IModLoadingState state, ModWorkManager.DrivenExecutor syncExecutor, Executor parallelExecutor, final Runnable ticker, final ProgressMeter progressBar) {
         if (!isLoadingStateValid()) {
             LOGGER.error("Cowardly refusing to process mod state change request from {}", state);
             return;
@@ -244,25 +235,25 @@ public class ModLoader {
         progressBar.label(progressBar.name() + " working");
         syncExecutor.drive(ticker);
 
-        var inlineRunnable = state.inlineRunnable().orElse(null);
+        var inlineRunnable = state.inlineRunnable();
         if (inlineRunnable != null) handleInlineTransition(inlineRunnable, state, syncExecutor, ticker);
 
-        var transition = state.buildTransition(syncExecutor, parallelExecutor, progressBar).orElse(null);
+        var transition = state.buildTransition(syncExecutor, parallelExecutor, progressBar);
         if (transition != null) waitForTransition(state, syncExecutor, ticker, transition);
 
-        completedStates.add(state);
+        COMPLETED_STATES.add(state);
     }
 
-    private void handleInlineTransition(final Consumer<ModList> transition, final IModLoadingState state, final ModWorkManager.DrivenExecutor syncExecutor, final Runnable ticker) {
-        var pb = StartupMessageManager.addProgressBar("State transition " +state.name()+" running", 0);
+    private static void handleInlineTransition(final Runnable transition, final IModLoadingState state, final ModWorkManager.DrivenExecutor syncExecutor, final Runnable ticker) {
+        var pb = StartupMessageManager.addProgressBar("State transition " + state.name() + " running", 0);
         syncExecutor.drive(ticker);
-        transition.accept(this.modList);
+        transition.run();
         syncExecutor.drive(ticker);
         pb.complete();
         syncExecutor.drive(ticker);
     }
 
-    private void waitForTransition(final IModLoadingState state, final ModWorkManager.DrivenExecutor syncExecutor, final Runnable ticker, final CompletableFuture<Void> transition) {
+    private static void waitForTransition(final IModLoadingState state, final ModWorkManager.DrivenExecutor syncExecutor, final Runnable ticker, final CompletableFuture<Void> transition) {
         while (!transition.isDone()) {
             syncExecutor.drive(ticker);
         }
@@ -276,7 +267,7 @@ public class ModLoader {
                     .anyMatch(obj -> !(obj instanceof ModLoadingException));
             if (hasNotModLoadingEx) {
                 LOGGER.fatal("Encountered non-modloading exceptions!", e);
-                statusConsumer.accept("ERROR DURING MOD LOADING");
+                STATUS_CONSUMER.accept("ERROR DURING MOD LOADING");
                 throw e;
             }
 
@@ -285,12 +276,12 @@ public class ModLoader {
                     .map(ModLoadingException.class::cast)
                     .toList();
             LOGGER.fatal(LOADING,"Failed to complete lifecycle event {}, {} errors found", state.name(), modLoadingExceptions.size());
-            statusConsumer.accept("ERROR DURING MOD LOADING");
+            STATUS_CONSUMER.accept("ERROR DURING MOD LOADING");
             throw new LoadingFailedException(modLoadingExceptions);
         }
     }
 
-    private List<ModContainer> buildMods(final IModFile modFile) {
+    private static List<ModContainer> buildMods(final IModFile modFile) {
         final Map<String, IModInfo> modInfoMap = new HashMap<>();
         for (var mod : modFile.getModFileInfo().getMods())
             modInfoMap.put(mod.getModId(), mod);
@@ -320,14 +311,14 @@ public class ModLoader {
             missingMods.removeAll(modIds);
             LOGGER.fatal(LOADING, "The following mods are missing, but have classes in the jar: {}", missingMods);
 
-            loadingExceptions.add(new ModLoadingException(null, ModLoadingStage.CONSTRUCT, "fml.modloading.missingclasses", null, modFile.getFilePath()));
+            LOADING_EXCEPTIONS.add(new ModLoadingException(null, ModLoadingStage.CONSTRUCT, "fml.modloading.missingclasses", null, modFile.getFilePath()));
         }
 
         // remove errored mod containers
         return containers.stream().filter(mc -> mc.modLoadingStage != ModLoadingStage.ERROR).toList();
     }
 
-    private ModContainer buildModContainerFromTOML(final IModFile modFile, final Map<String, IModInfo> modInfoMap,
+    private static ModContainer buildModContainerFromTOML(final IModFile modFile, final Map<String, IModInfo> modInfoMap,
         final String modId, final IModLanguageProvider.IModLanguageLoader languageLoader
     ) {
         try {
@@ -339,7 +330,7 @@ public class ModLoader {
             return languageLoader.loadMod(info, modFile.getScanResult(), FMLLoader.getGameLayer());
         } catch (ModLoadingException mle) {
             // exceptions are caught and added to the error list for later handling
-            loadingExceptions.add(mle);
+            LOADING_EXCEPTIONS.add(mle);
             // return an errored container instance here, because we tried and failed building a container.
             return new ErroredModContainer();
         }
@@ -353,9 +344,8 @@ public class ModLoader {
         return loadingStateValid;
     }
 
-    public boolean hasCompletedState(final String stateName) {
-        IModLoadingState state = stateManager.findState(stateName);
-        return completedStates.contains(state);
+    public static boolean hasCompletedState(IModLoadingState state) {
+        return COMPLETED_STATES.contains(state);
     }
 
     public static <T extends IModBusEvent> void runEventGenerator(Function<ModContainer, T> generator) {
@@ -363,7 +353,7 @@ public class ModLoader {
             LOGGER.error("Cowardly refusing to send event generator to a broken mod state");
             return;
         }
-        for (var mod : ModList.get().getLoadedMods())
+        for (var mod : ModList.getLoadedMods())
             mod.acceptEvent(generator.apply(mod));
     }
 
@@ -372,7 +362,7 @@ public class ModLoader {
             LOGGER.error("Cowardly refusing to send event {} to a broken mod state", e.getClass().getName());
             return;
         }
-        for (var mod : ModList.get().getLoadedMods())
+        for (var mod : ModList.getLoadedMods())
             mod.acceptEvent(e);
     }
 
@@ -381,7 +371,7 @@ public class ModLoader {
             LOGGER.error("Cowardly refusing to send event {} to a broken mod state", e.getClass().getName());
             return e;
         }
-        for (var mod : ModList.get().getLoadedMods())
+        for (var mod : ModList.getLoadedMods())
             mod.acceptEvent(e);
         return e;
     }
@@ -399,19 +389,19 @@ public class ModLoader {
             LOGGER.error("Cowardly refusing to send event {} to a broken mod state", e.getClass().getName());
             return;
         }
-        for (var mod : ModList.get().getLoadedMods()) {
+        for (var mod : ModList.getLoadedMods()) {
             pre.accept(mod, e);
             mod.acceptEvent(e);
             post.accept(mod, e);
         }
     }
 
-    public List<ModLoadingWarning> getWarnings() {
-        return ImmutableList.copyOf(this.loadingWarnings);
+    public static List<ModLoadingWarning> getWarnings() {
+        return List.copyOf(LOADING_WARNINGS);
     }
 
-    public void addWarning(ModLoadingWarning warning) {
-        this.loadingWarnings.add(warning);
+    public static void addWarning(ModLoadingWarning warning) {
+        LOADING_WARNINGS.add(warning);
     }
 
     private static boolean runningDataGen = false;

fmlcore/src/main/java/net/minecraftforge/fml/ModLoadingContext.java

@@ -19,31 +19,24 @@ public class ModLoadingContext {
     private Object languageExtension;
 
     /**
-     * @deprecated Use the context provided by your language loader in your mod's constructor
+     * @deprecated Use the context provided by your language loader in your mod's constructor. Example for Java mods: {@snippet :
+     * @Mod("examplemod")
+     * public final class ExampleMod {
+     *      public ExampleMod(FMLJavaModLoadingContext context) {
+     *           // Use context from the param instead of FMLJavaModLoadingContext.get() or ModLoadingContext.get()
+     *      }
+     * }}
      */
     @Deprecated(forRemoval = true, since="1.21.1")
     public static ModLoadingContext get() {
         return context.get();
     }
 
-    /**
-     * @deprecated Going to be moved to ForgeHooks for Internal use.
-     */
-    @Deprecated(forRemoval = true, since="1.21.1")
-    public void setActiveContainer(final ModContainer container) {
+    void setActiveContainer(final ModContainer container) {
         this.activeContainer = container;
         this.languageExtension = container == null ? null : container.contextExtension.get();
     }
 
-    /**
-     * Going to be moved to ForgeHooks for Internal use.
-     * @deprecated Override/Use {@link ModLoadingContext#getContainer()}
-     */
-    @Deprecated(forRemoval = true, since="1.21.1")
-    public ModContainer getActiveContainer() {
-        return activeContainer == null ? ModList.get().getModContainerById("minecraft").orElseThrow(()->new RuntimeException("Where is minecraft???!")) : activeContainer;
-    }
-
     /**
      * @deprecated Going to be moved to ForgeHooks for Internal use.
      */
@@ -52,11 +45,10 @@ public class ModLoadingContext {
         return activeContainer == null ? "minecraft" : activeContainer.getNamespace();
     }
 
-    /**
-     * @return {@link ModLoadingContext#getActiveContainer()} by default.
-     */
     public ModContainer getContainer() {
-        return getActiveContainer();
+        return activeContainer == null
+                ? ModList.getModContainerById("minecraft").orElseThrow(()->new RuntimeException("Where is minecraft???!"))
+                : activeContainer;
     }
 
     /**
@@ -108,8 +100,7 @@ public class ModLoadingContext {
     }
 
     public void registerConfig(ModConfig.Type type, IConfigSpec<?> spec) {
-        if (spec.isEmpty())
-        {
+        if (spec.isEmpty()) {
             // This handles the case where a mod tries to register a config, without any options configured inside it.
             LOGGER.debug("Attempted to register an empty config for type {} on mod {}", type, getContainer().getModId());
             return;
@@ -119,8 +110,7 @@ public class ModLoadingContext {
     }
 
     public void registerConfig(ModConfig.Type type, IConfigSpec<?> spec, String fileName) {
-        if (spec.isEmpty())
-        {
+        if (spec.isEmpty()) {
             // This handles the case where a mod tries to register a config, without any options configured inside it.
             LOGGER.debug("Attempted to register an empty config for type {} on mod {} using file name {}", type, getContainer().getModId(), fileName);
             return;
@@ -129,7 +119,6 @@ public class ModLoadingContext {
         getContainer().addConfig(new ModConfig(type, spec, getContainer(), fileName));
     }
 
-
     @SuppressWarnings("unchecked")
     public <T> T extension() {
         return (T)languageExtension;

fmlcore/src/main/java/net/minecraftforge/fml/ModLoadingState.java

@@ -6,13 +6,15 @@
 package net.minecraftforge.fml;
 
 import net.minecraftforge.fml.loading.progress.ProgressMeter;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
-import java.util.Optional;
+import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executor;
-import java.util.function.Consumer;
 import java.util.function.Function;
-import java.util.function.ToIntFunction;
+import java.util.function.IntSupplier;
+import java.util.function.Supplier;
 
 /**
  * Implementation of the {@link IModLoadingState} interface.
@@ -24,27 +26,26 @@ import java.util.function.ToIntFunction;
  * @param inlineRunnable an optional runnable, which runs before starting the transition from this state to the next
  * @param transition     optional state transition information
  */
+@NullMarked
 public record ModLoadingState(
     String name,
     String previous,
-    Function<ModList, String> message,
-    ToIntFunction<ModList> size,
+    Supplier<String> message,
+    IntSupplier size,
     ModLoadingPhase phase,
-    Optional<Consumer<ModList>> inlineRunnable,
-    Optional<IModStateTransition> transition
+    @Nullable Runnable inlineRunnable,
+    @Nullable IModStateTransition transition
 ) implements IModLoadingState {
     @Override
-    public Optional<CompletableFuture<Void>> buildTransition(
+    public @Nullable CompletableFuture<Void> buildTransition(
         final Executor syncExecutor,
         final Executor parallelExecutor,
         final ProgressMeter progressBar,
         final Function<Executor, CompletableFuture<Void>> preSyncTask,
         final Function<Executor, CompletableFuture<Void>> postSyncTask
     ) {
-        var transition = this.transition.orElse(null);
-        return transition == null
-                ? Optional.empty()
-                : Optional.ofNullable(transition.build(name, syncExecutor, parallelExecutor, progressBar, preSyncTask, postSyncTask));
+        if (transition == null) return null;
+        return transition.build(name, syncExecutor, parallelExecutor, progressBar, preSyncTask, postSyncTask);
     }
 
     /**
@@ -59,7 +60,7 @@ public record ModLoadingState(
      */
     @Deprecated(since = "1.21.3", forRemoval = true)
     public static ModLoadingState empty(final String name, final String previous, final ModLoadingPhase phase) {
-        return of(name, phase).after(previous).empty();
+        return new ModLoadingState(name, previous, () -> "", () -> 0, phase, null, null);
     }
 
     /**
@@ -93,7 +94,7 @@ public record ModLoadingState(
      */
     @Deprecated(since = "1.21.3", forRemoval = true)
     public static ModLoadingState withTransition(final String name, final String previous,
-                                                 final Function<ModList, String> message, final ModLoadingPhase phase,
+                                                 final Supplier<String> message, final ModLoadingPhase phase,
                                                  final IModStateTransition transition) {
         return of(name, phase).after(previous).message(message).withTransition(transition);
     }
@@ -112,7 +113,7 @@ public record ModLoadingState(
      */
     @Deprecated(since = "1.21.3", forRemoval = true)
     public static ModLoadingState withInline(final String name, final String previous, final ModLoadingPhase phase,
-                                             final Consumer<ModList> inline) {
+                                             final Runnable inline) {
         return of(name, phase).after(previous).withInline(inline);
     }
 
@@ -120,12 +121,28 @@ public record ModLoadingState(
         return new Builder(name, phase);
     }
 
-    public static class Builder {
+    @Override
+    public boolean equals(Object o) {
+        return o instanceof ModLoadingState that
+                && this.phase == that.phase
+                && this.name.equals(that.name)
+                && this.previous.equals(that.previous);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = phase.hashCode();
+        result = 31 * result + name.hashCode();
+        result = 31 * result + previous.hashCode();
+        return result;
+    }
+
+    public static final class Builder {
         private final String name;
         private final ModLoadingPhase phase;
-        private String after;
-        private Function<ModList, String> message = null;
-        private ToIntFunction<ModList> size = null;
+        private String after = "";
+        private @Nullable Supplier<String> message = null;
+        private @Nullable IntSupplier size = null;
 
         private Builder(final String name, final ModLoadingPhase phase) {
             this.name = name;
@@ -138,28 +155,28 @@ public record ModLoadingState(
             return this;
         }
 
-        public Builder message(final String value) { return message(ml -> value); }
-        public Builder message(final Function<ModList, String> value) {
+        public Builder message(final String value) { return message(() -> value); }
+        public Builder message(final Supplier<String> value) {
             this.message = value;
             return this;
         }
 
-        public Builder size(final int value) { return size(ml -> value); }
-        public Builder size(final ToIntFunction<ModList> value) {
+        public Builder size(final int value) { return size(() -> value); }
+        public Builder size(final IntSupplier value) {
             this.size = value;
             return this;
         }
 
         public ModLoadingState empty() {
-            return new ModLoadingState(name, after, message != null ? message : ml -> "", size != null ? size : ml -> 0, phase, Optional.empty(), Optional.empty());
+            return new ModLoadingState(name, after, message != null ? message : () -> "", size != null ? size : () -> 0, phase, null, null);
         }
 
         public ModLoadingState withTransition(final IModStateTransition transition) {
-            return new ModLoadingState(name, after, message != null ? message : ml -> "Processing transition " + name, size != null ? size : ModList::size, phase, Optional.empty(), Optional.of(transition));
+            return new ModLoadingState(name, after, message != null ? message : () -> "Processing transition " + name, size != null ? size : ModList::size, phase, null, transition);
         }
 
-        public ModLoadingState withInline(final Consumer<ModList> inline) {
-            return new ModLoadingState(name, after, message != null ? message : ml -> "Processing work " + name, size != null ? size : ml -> 0, phase, Optional.of(inline), Optional.empty());
+        public ModLoadingState withInline(final Runnable inline) {
+            return new ModLoadingState(name, after, message != null ? message : () -> "Processing work " + name, size != null ? size : () -> 0, phase, inline, null);
         }
     }
-}
+}

fmlcore/src/main/java/net/minecraftforge/fml/ModLoadingWarning.java

@@ -5,41 +5,27 @@
 
 package net.minecraftforge.fml;
 
-import com.google.common.collect.Streams;
 import net.minecraftforge.forgespi.language.IModInfo;
 
-import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Stream;
 
-public class ModLoadingWarning {
-    /**
-     * Mod Info for mod with warning
-     */
-    private final IModInfo modInfo;
-    /**
-     * The stage where this warning was encountered
-     */
-    private final ModLoadingStage warningStage;
-
-    /**
-     * I18N message to use for display
-     */
-    private final String i18nMessage;
-
-    /**
-     * Context for message display
-     */
-    private final List<Object> context;
-
+/**
+ * @param modInfo Mod info for mod with warning
+ * @param warningStage The stage where this warning was encountered
+ * @param i18nMessage I18N message to use for display
+ * @param context Context for message display
+ */
+public record ModLoadingWarning(IModInfo modInfo, ModLoadingStage warningStage, String i18nMessage, List<Object> context) {
     public ModLoadingWarning(final IModInfo modInfo, final ModLoadingStage warningStage, final String i18nMessage, Object... context) {
-        this.modInfo = modInfo;
-        this.warningStage = warningStage;
-        this.i18nMessage = i18nMessage;
-        this.context = Arrays.asList(context);
+        this(modInfo, warningStage, i18nMessage, List.of(context));
+    }
+
+    public ModLoadingWarning {
+        context = List.copyOf(context);
     }
 
     public String formatToString() {
-        return Bindings.getMessageParser().get().parseMessage(i18nMessage, Streams.concat(Stream.of(modInfo, warningStage), context.stream()).toArray());
+        return Bindings.getMessageParser().get().parseMessage(i18nMessage, Stream.concat(Stream.of(modInfo, warningStage), context.stream()).toArray());
     }
 }

fmlcore/src/main/java/net/minecraftforge/fml/ModStateManager.java

@@ -15,18 +15,19 @@ import java.util.function.Function;
 import java.util.stream.Collectors;
 
 @SuppressWarnings("UnstableApiUsage")
-public class ModStateManager {
-    private final EnumMap<ModLoadingPhase, List<IModLoadingState>> stateMap;
+public final class ModStateManager {
+    private ModStateManager() {}
+    private static final EnumMap<ModLoadingPhase, List<IModLoadingState>> stateMap;
 
-    public ModStateManager() {
+    static {
         final var sp = ServiceLoader.load(FMLLoader.getGameLayer(), IModStateProvider.class);
-        this.stateMap = ServiceLoaderUtils.streamWithErrorHandling(sp, sce->{})
+        stateMap = ServiceLoaderUtils.streamWithErrorHandling(sp, _ -> {})
                 .map(IModStateProvider::getAllStates)
                 .flatMap(List::stream)
-                .collect(Collectors.groupingBy(IModLoadingState::phase, ()->new EnumMap<>(ModLoadingPhase.class), Collectors.toUnmodifiableList()));
+                .collect(Collectors.groupingBy(IModLoadingState::phase, () -> new EnumMap<>(ModLoadingPhase.class), Collectors.toUnmodifiableList()));
     }
 
-    public List<IModLoadingState> getStates(final ModLoadingPhase phase) {
+    public static List<IModLoadingState> getStates(final ModLoadingPhase phase) {
         var nodes = stateMap.get(phase);
         var lookup = nodes.stream().collect(Collectors.toMap(IModLoadingState::name, Function.identity()));
 
@@ -40,12 +41,14 @@ public class ModStateManager {
         return TopologicalSort.topologicalSort(graph, Comparator.comparingInt(nodes::indexOf)).stream().filter(st->st!=dummy).toList();
     }
 
-    public IModLoadingState findState(final String stateName) {
-        return stateMap.values()
+    public static IModLoadingState findState(final String stateName) {
+        var result = stateMap.values()
                 .stream()
                 .flatMap(List::stream)
                 .filter(mls -> mls.name().equals(stateName))
                 .findFirst()
-                .orElseThrow(() -> new IllegalArgumentException("Unknown IModLoadingState: " + stateName));
+                .orElse(null);
+        if (result != null) return result;
+        else throw new IllegalArgumentException("Unknown IModLoadingState: " + stateName);
     }
 }

fmlcore/src/main/java/net/minecraftforge/fml/ModStateTransitionHelper.java

@@ -24,7 +24,7 @@ import net.minecraftforge.fml.event.IModBusEvent;
 import net.minecraftforge.fml.loading.progress.ProgressMeter;
 
 @ApiStatus.Internal
-class ModStateTransitionHelper {
+final class ModStateTransitionHelper {
     static final IModStateTransition NOOP = new NoopTransition();
     record NoopTransition() implements IModStateTransition {
         @Override
@@ -62,7 +62,30 @@ class ModStateTransitionHelper {
         }
     }
 
-    record FutureResult<V>(V value, Throwable exception){}
+    /// Same as [#completableFutureFromExceptionList(List)] but specialised for a single future
+    static <V> CompletionStage<Void> completableFutureFromException(FutureResult<V> t) {
+        if (t.exception() == null) {
+            return CompletableFuture.completedFuture(null);
+        } else {
+            var exception = t.exception();
+            CompletableFuture<Void> cf = new CompletableFuture<>();
+            RuntimeException accumulator = new RuntimeException();
+            cf.completeExceptionally(accumulator);
+            if (exception instanceof CompletionException) {
+                exception = exception.getCause();
+            }
+            if (exception.getSuppressed().length != 0) {
+                for (Throwable throwable : exception.getSuppressed()) {
+                    accumulator.addSuppressed(throwable);
+                }
+            } else {
+                accumulator.addSuppressed(exception);
+            }
+            return cf;
+        }
+    }
+
+    record FutureResult<V>(V value, Throwable exception) {}
 
     static <V> CompletableFuture<List<FutureResult<V>>> gather(Collection<? extends CompletableFuture<? extends V>> futures) {
         var list = new ArrayList<FutureResult<V>>(futures.size());
@@ -79,22 +102,14 @@ class ModStateTransitionHelper {
         return CompletableFuture.allOf(results).handle((r, th)->null).thenApply(res -> list);
     }
 
-    private static <T extends IModBusEvent> void addCompletableFutureTaskForModDispatch(
-        final IModStateTransition transition,
+    private static <T extends IModBusEvent> CompletableFuture<Void> addCompletableFutureTaskForModDispatch(
         final Executor executor,
-        final List<CompletableFuture<Void>> completableFutures,
         final ProgressMeter progressBar,
         final EventGenerator<T> eventGenerator,
         final BiFunction<ModLoadingStage, Throwable, ModLoadingStage> nextState
      ) {
-
-        @SuppressWarnings("removal")
-        var preDispatchHook = getHook(transition.preDispatchHook(), executor, eventGenerator);
-        if (preDispatchHook != null)
-            completableFutures.add(preDispatchHook);
-
         var modFutures = new LinkedHashMap<String, CompletableFuture<Void>>();
-        for (var mod : ModList.get().getLoadedMods()) {
+        for (var mod : ModList.getLoadedMods()) {
 
             CompletableFuture<Void> parent = null;
             if (mod.dependencies.isEmpty()) {
@@ -129,20 +144,7 @@ class ModStateTransitionHelper {
             modFutures.put(mod.getModId(), dispatch);
         }
 
-        var dispatch = gather(modFutures.values()).thenComposeAsync(ModStateTransitionHelper::completableFutureFromExceptionList, executor);
-        completableFutures.add(dispatch);
-
-        @SuppressWarnings("removal")
-        var postDispatchHook = getHook(transition.preDispatchHook(), executor, eventGenerator);
-        if (postDispatchHook != null)
-            completableFutures.add(postDispatchHook);
-    }
-
-    private static <T extends IModBusEvent> CompletableFuture<Void> getHook(BiFunction<Executor, ? extends EventGenerator<?>, CompletableFuture<Void>> hook, Executor executor, EventGenerator<T> eventGenerator) {
-        if (hook == null || hook == IModStateTransition.NULL_HOOK) return null;
-        @SuppressWarnings("unchecked")
-        var hookTyped = (BiFunction<Executor, EventGenerator<T>, CompletableFuture<Void>>)hook;
-        return hookTyped.apply(executor, eventGenerator);
+        return gather(modFutures.values()).thenComposeAsync(ModStateTransitionHelper::completableFutureFromExceptionList, executor);
     }
 
     static <T extends IModBusEvent> CompletableFuture<Void> build(
@@ -154,31 +156,25 @@ class ModStateTransitionHelper {
         final Function<Executor, CompletableFuture<Void>> preSyncTask,
         final Function<Executor, CompletableFuture<Void>> postSyncTask
     ) {
-        List<CompletableFuture<Void>> futures = new ArrayList<>();
+        CompletableFuture<Void> future;
         final var executor = transition.threadSelector().apply(syncExecutor, parallelExecutor);
 
-        @SuppressWarnings({ "removal", "unchecked" })
-        var events = transition.eventFunctionStream().get().map(f -> (EventGenerator<T>)f).toList();
-        for (int x = 0; x < events.size(); x++) {
-            var gen = events.get(x);
-            BiFunction<ModLoadingStage, Throwable, ModLoadingStage> state = x == events.size() - 1
-                ? transition.nextModLoadingStage()
-                : ModLoadingStage::currentState;
-            addCompletableFutureTaskForModDispatch(transition, executor, futures, progressBar, gen, state);
+        final CompletableFuture<Void> preSyncTaskCF = preSyncTask.apply(syncExecutor);
+        CompletableFuture<Void> postEventDispatchCF = preSyncTaskCF
+            .thenRunAsync(() -> progressBar.label(progressBar.name() + ": dispatching " + name), parallelExecutor);
+
+        var eventGenerator = transition.eventFunction();
+        if (eventGenerator != null) {
+            BiFunction<ModLoadingStage, Throwable, ModLoadingStage> state = transition.nextModLoadingStage();
+            future = addCompletableFutureTaskForModDispatch(executor, progressBar, eventGenerator, state);
+
+            final CompletableFuture<Void> eventDispatchCF = future.handle(FutureResult::new)
+                    .thenCompose(ModStateTransitionHelper::completableFutureFromException);
+            postEventDispatchCF = postEventDispatchCF.thenComposeAsync(_ -> eventDispatchCF, parallelExecutor);
         }
 
-        final CompletableFuture<Void> preSyncTaskCF = preSyncTask.apply(syncExecutor);
-        final CompletableFuture<Void> eventDispatchCF = gather(futures).thenCompose(ModStateTransitionHelper::completableFutureFromExceptionList);
-        final CompletableFuture<Void> postEventDispatchCF = preSyncTaskCF
-            .thenApplyAsync(n -> {
-                progressBar.label(progressBar.name() + ": dispatching " + name);
-                return null;
-            }, parallelExecutor)
-            .thenComposeAsync(n -> eventDispatchCF, parallelExecutor)
-            .thenApply(r -> {
-                postSyncTask.apply(syncExecutor);
-                return null;
-            });
+        postEventDispatchCF = postEventDispatchCF.thenRun(() -> postSyncTask.apply(syncExecutor));
+
         return transition.finalActivityGenerator().apply(syncExecutor, postEventDispatchCF);
     }
 }

fmlcore/src/main/java/net/minecraftforge/fml/ModWorkManager.java

@@ -14,25 +14,12 @@ import java.util.concurrent.locks.LockSupport;
 
 import static net.minecraftforge.fml.Logging.LOADING;
 
-public class ModWorkManager {
+public final class ModWorkManager {
     private static final Logger LOGGER = LogManager.getLogger();
     private static final long PARK_TIME = TimeUnit.MILLISECONDS.toNanos(1);
 
-    public interface DrivenExecutor extends Executor {
-        boolean selfDriven();
-        boolean driveOne();
-
-        default void drive(Runnable ticker) {
-            if (!selfDriven()) {
-                ticker.run();
-                while (true) {
-                    if (!driveOne()) break;
-                }
-            } else {
-                // park for a bit so other threads can schedule
-                LockSupport.parkNanos(PARK_TIME);
-            }
-        }
+    public sealed interface DrivenExecutor extends Executor {
+        void drive(Runnable ticker);
     }
 
     private record SyncExecutor(ConcurrentLinkedDeque<Runnable> tasks) implements DrivenExecutor {
@@ -40,8 +27,7 @@ public class ModWorkManager {
             this(new ConcurrentLinkedDeque<>());
         }
 
-        @Override
-        public boolean driveOne() {
+        private boolean driveOne() {
             final Runnable task = tasks.pollFirst();
             if (task != null) {
                 task.run();
@@ -50,31 +36,30 @@ public class ModWorkManager {
         }
 
         @Override
-        public boolean selfDriven() {
-            return false;
+        public void execute(final Runnable command) {
+            tasks.addLast(command);
         }
 
         @Override
-        public void execute(final Runnable command) {
-            tasks.addLast(command);
+        public void drive(Runnable ticker) {
+            ticker.run();
+            while (true) {
+                if (!driveOne()) break;
+            }
         }
     }
 
     private record WrappingExecutor(Executor wrapped) implements DrivenExecutor {
-        @Override
-        public boolean selfDriven() {
-            return true;
-        }
-
-        @Override
-        public boolean driveOne() {
-            return false;
-        }
-
         @Override
         public void execute(final Runnable command) {
             wrapped.execute(command);
         }
+
+        @Override
+        public void drive(Runnable ticker) {
+            // Park for a bit so other threads can schedule
+            LockSupport.parkNanos(PARK_TIME);
+        }
     }
 
     private static final SyncExecutor syncExecutor = new SyncExecutor();

fmlcore/src/main/java/net/minecraftforge/fml/OptionalMod.java

@@ -43,7 +43,7 @@ public final class OptionalMod<T>
     private T getValue()
     {
         if (!searched) {
-            this.value = ModList.get().<T>getModObjectById(this.modId).orElse(null);
+            this.value = ModList.<T>getModObjectById(this.modId).orElse(null);
             searched = true;
         }
         return this.value;

fmlcore/src/main/java/net/minecraftforge/fml/VersionChecker.java

@@ -93,8 +93,8 @@ public class VersionChecker {
                     return;
                 }
 
-                var mc = ModList.get().getModContainerById("minecraft");
-                var forge = ModList.get().getModContainerById("forge");
+                var mc = ModList.getModContainerById("minecraft");
+                var forge = ModList.getModContainerById("forge");
                 this.mcVersion = mc.get().getModInfo().getVersion().toString();
 
                 this.agent = "Java-http-client/" + System.getProperty("java.version")
@@ -223,7 +223,7 @@ public class VersionChecker {
     // Gather a list of mods that have opted in to this update system by providing a URL.
     private static List<IModInfo> gatherMods() {
         List<IModInfo> ret = new LinkedList<>();
-        for (IModInfo info : ModList.get().getMods()) {
+        for (IModInfo info : ModList.getMods()) {
             if (info.getUpdateURL().isPresent())
                 ret.add(info);
         }

fmlcore/src/main/java/net/minecraftforge/fml/config/ConfigTracker.java

@@ -8,8 +8,7 @@ package net.minecraftforge.fml.config;
 import com.electronwill.nightconfig.core.CommentedConfig;
 import com.electronwill.nightconfig.core.file.CommentedFileConfig;
 import com.mojang.logging.LogUtils;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.fml.DistExecutor;
+import net.minecraftforge.fml.loading.FMLEnvironment;
 import net.minecraftforge.fml.loading.FMLPaths;
 import org.slf4j.Logger;
 import org.slf4j.Marker;
@@ -19,57 +18,54 @@ import java.nio.file.Path;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 
-public class ConfigTracker {
+public final class ConfigTracker {
+    private ConfigTracker() {}
+
     private static final Logger LOGGER = LogUtils.getLogger();
     static final Marker CONFIG = MarkerFactory.getMarker("CONFIG");
-    public static final ConfigTracker INSTANCE = new ConfigTracker();
-    private final ConcurrentHashMap<String, ModConfig> fileMap;
-    private final EnumMap<ModConfig.Type, Set<ModConfig>> configSets;
-    private final ConcurrentHashMap<String, Map<ModConfig.Type, ModConfig>> configsByMod;
+    private static final ConcurrentHashMap<String, ModConfig> FILE_MAP = new ConcurrentHashMap<>();
+    private static final Map<ModConfig.Type, Set<ModConfig>> CONFIG_SETS = Map.of(
+            ModConfig.Type.CLIENT, Collections.synchronizedSet(new LinkedHashSet<>()),
+            ModConfig.Type.COMMON, Collections.synchronizedSet(new LinkedHashSet<>()),
+            ModConfig.Type.SERVER, Collections.synchronizedSet(new LinkedHashSet<>())
+    );
+    private static final ConcurrentHashMap<String, Map<ModConfig.Type, ModConfig>> CONFIGS_BY_MOD = new ConcurrentHashMap<>();
 
-    private ConfigTracker() {
-        this.fileMap = new ConcurrentHashMap<>();
-        this.configSets = new EnumMap<>(ModConfig.Type.class);
-        this.configsByMod = new ConcurrentHashMap<>();
-        this.configSets.put(ModConfig.Type.CLIENT, Collections.synchronizedSet(new LinkedHashSet<>()));
-        this.configSets.put(ModConfig.Type.COMMON, Collections.synchronizedSet(new LinkedHashSet<>()));
-//        this.configSets.put(ModConfig.Type.PLAYER, new ConcurrentSkipListSet<>());
-        this.configSets.put(ModConfig.Type.SERVER, Collections.synchronizedSet(new LinkedHashSet<>()));
-    }
-
-    void trackConfig(final ModConfig config) {
-        if (this.fileMap.containsKey(config.getFileName())) {
-            LOGGER.error(CONFIG,"Detected config file conflict {} between {} and {}", config.getFileName(), this.fileMap.get(config.getFileName()).getModId(), config.getModId());
+    static void trackConfig(final ModConfig config) {
+        if (FILE_MAP.containsKey(config.getFileName())) {
+            LOGGER.error(CONFIG,"Detected config file conflict {} between {} and {}", config.getFileName(), FILE_MAP.get(config.getFileName()).getModId(), config.getModId());
             throw new RuntimeException("Config conflict detected!");
         }
-        this.fileMap.put(config.getFileName(), config);
-        this.configSets.get(config.getType()).add(config);
-        this.configsByMod.computeIfAbsent(config.getModId(), (k)->new EnumMap<>(ModConfig.Type.class)).put(config.getType(), config);
+        FILE_MAP.put(config.getFileName(), config);
+        CONFIG_SETS.get(config.getType()).add(config);
+        CONFIGS_BY_MOD.computeIfAbsent(config.getModId(), _ -> new EnumMap<>(ModConfig.Type.class)).put(config.getType(), config);
         LOGGER.debug(CONFIG, "Config file {} for {} tracking", config.getFileName(), config.getModId());
     }
 
-    public void loadConfigs(ModConfig.Type type, Path configBasePath) {
+    public static void loadConfigs(ModConfig.Type type, Path configBasePath) {
         LOGGER.debug(CONFIG, "Loading configs type {}", type);
-        for (ModConfig config : this.configSets.get(type)) {
+        for (ModConfig config : CONFIG_SETS.get(type)) {
             openConfig(config, configBasePath);
         }
     }
 
     // TODO: [FML] This is only called for the server (outside of forceUnload)
     // rethink config implementation for eventual FML rewrite
-    public void unloadConfigs(ModConfig.Type type, Path configBasePath) {
+    public static void unloadConfigs(ModConfig.Type type, Path configBasePath) {
         LOGGER.debug(CONFIG, "Unloading configs type {}", type);
-        for (ModConfig config : this.configSets.get(type)) {
+        for (ModConfig config : CONFIG_SETS.get(type)) {
             closeConfig(config, configBasePath);
         }
         ConfigFileTypeHandler.get(type).stopWatcher();
     }
 
     // If there is a better way to do this, please tell me. Because this is FUCKED
-    public void forceUnload() {
+    public static void forceUnload() {
         // This is how ModStateProvider handles loading configs. So we're doing the same but with unloadConfigs instead
-        DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> this.unloadConfigs(ModConfig.Type.CLIENT, FMLPaths.CONFIGDIR.get()));
-        this.unloadConfigs(ModConfig.Type.COMMON, FMLPaths.CONFIGDIR.get());
+        if (FMLEnvironment.dist.isClient())
+            unloadConfigs(ModConfig.Type.CLIENT, FMLPaths.CONFIGDIR.get());
+
+        unloadConfigs(ModConfig.Type.COMMON, FMLPaths.CONFIGDIR.get());
 
         // just in case server watcher is still alive somehow...
         ConfigFileTypeHandler.get(ModConfig.Type.SERVER).stopWatcher();
@@ -96,8 +92,8 @@ public class ConfigTracker {
         }
     }
 
-    public void loadDefaultServerConfigs() {
-        configSets.get(ModConfig.Type.SERVER).forEach(modConfig -> {
+    public static void loadDefaultServerConfigs() {
+        CONFIG_SETS.get(ModConfig.Type.SERVER).forEach(modConfig -> {
             final CommentedConfig commentedConfig = CommentedConfig.inMemory();
             modConfig.getSpec().correct(commentedConfig);
             modConfig.setConfigData(commentedConfig);
@@ -105,16 +101,16 @@ public class ConfigTracker {
         });
     }
 
-    public String getConfigFileName(String modId, ModConfig.Type type) {
-        return Optional.ofNullable(configsByMod.getOrDefault(modId, Collections.emptyMap()).getOrDefault(type, null)).
+    public static String getConfigFileName(String modId, ModConfig.Type type) {
+        return Optional.ofNullable(CONFIGS_BY_MOD.getOrDefault(modId, Collections.emptyMap()).getOrDefault(type, null)).
                 map(ModConfig::getFullPath).map(Object::toString).orElse(null);
     }
 
-    public Map<ModConfig.Type, Set<ModConfig>> configSets() {
-        return configSets;
+    public static Map<ModConfig.Type, Set<ModConfig>> configSets() {
+        return CONFIG_SETS;
     }
 
-    public ConcurrentHashMap<String, ModConfig> fileMap() {
-        return fileMap;
+    public static ConcurrentHashMap<String, ModConfig> fileMap() {
+        return FILE_MAP;
     }
 }

fmlcore/src/main/java/net/minecraftforge/fml/config/IConfigEvent.java

@@ -13,6 +13,7 @@ import java.util.function.Function;
 import org.jetbrains.annotations.Nullable;
 
 public interface IConfigEvent {
+    // TODO: [FML] Get rid of this indirection somehow
     record ConfigConfig(Function<ModConfig, IConfigEvent> loading, Function<ModConfig, IConfigEvent> reloading, @Nullable Function<ModConfig, IConfigEvent> unloading) {}
 
     ConfigConfig CONFIGCONFIG = Bindings.getConfigConfiguration().get();

fmlcore/src/main/java/net/minecraftforge/fml/config/ModConfig.java

@@ -31,7 +31,7 @@ public class ModConfig
         this.fileName = fileName;
         this.container = container;
         this.configHandler = ConfigFileTypeHandler.get(type);
-        ConfigTracker.INSTANCE.trackConfig(this);
+        ConfigTracker.trackConfig(this);
     }
 
     public ModConfig(final Type type, final IConfigSpec<?> spec, final ModContainer activeContainer) {
@@ -40,8 +40,9 @@ public class ModConfig
 
     private static String defaultConfigName(Type type, String modId) {
         // config file name would be "forge-client.toml" and "forge-server.toml"
-        return String.format(Locale.ROOT, "%s-%s.toml", modId, type.extension());
+        return modId + '-' + type.extension() + ".toml";
     }
+
     public Type getType() {
         return type;
     }

fmlcore/src/main/java/net/minecraftforge/fml/event/IModBusEvent.java

@@ -8,16 +8,22 @@ package net.minecraftforge.fml.event;
 import net.minecraftforge.eventbus.api.bus.BusGroup;
 import net.minecraftforge.eventbus.api.bus.EventBus;
 import net.minecraftforge.eventbus.api.event.InheritableEvent;
+import org.jspecify.annotations.NonNull;
 
 /**
- * Marker interface for events dispatched on the ModLifecycle event bus instead of the primary event bus
+ * Marker interface for mod lifecycle events dispatched on the
+ * {@linkplain net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext#getModBusGroup() mod BusGroup} instead
+ * of the {@linkplain BusGroup#DEFAULT default BusGroup}.
+ *
+ * @apiNote Each mod gets its own unique mod BusGroup instance, obtained from the mod loading context. Most events
+ *          should go on the default BusGroup.
  */
 public interface IModBusEvent extends InheritableEvent {
     /**
      * @param modEventBusGroup Obtained from {@link net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext#getModBusGroup()} or your language provider's equivalent.
      * @param eventClass The event type you want to get the associated bus for.
      */
-    static <T extends IModBusEvent> EventBus<T> getBus(BusGroup modEventBusGroup, Class<T> eventClass) {
+    static <T extends IModBusEvent> @NonNull EventBus<@NonNull T> getBus(@NonNull BusGroup modEventBusGroup, @NonNull Class<T> eventClass) {
         // Do not copy! Temporary solution until the FML rewrite is complete. May throw in future
         // without prior notice.
         //

fmlcore/src/main/java/net/minecraftforge/fml/util/thread/EffectiveSide.java

@@ -7,8 +7,11 @@ package net.minecraftforge.fml.util.thread;
 
 import net.minecraftforge.fml.LogicalSide;
 
-public class EffectiveSide
-{
+/**
+ * Attempts to determine the effect side of the current thread, based on know threads in networking.
+ * This is not guaranteed to be correct, and modders should use other methods to determine the logical side when possible.
+ */
+public class EffectiveSide {
     public static LogicalSide get() {
         final ThreadGroup group = Thread.currentThread().getThreadGroup();
         return group instanceof SidedThreadGroup ? ((SidedThreadGroup) group).getSide() : LogicalSide.CLIENT;

fmlcore/src/main/java/net/minecraftforge/fml/util/thread/SidedThreadGroups.java

@@ -7,11 +7,13 @@ package net.minecraftforge.fml.util.thread;
 
 import net.minecraftforge.fml.LogicalSide;
 
-public final class SidedThreadGroups
-{
+public final class SidedThreadGroups {
     public static final SidedThreadGroup CLIENT = new SidedThreadGroup(LogicalSide.CLIENT);
     public static final SidedThreadGroup SERVER = new SidedThreadGroup(LogicalSide.SERVER);
 
-    private SidedThreadGroups() {
+    public static SidedThreadGroup get(boolean client) {
+        return client ? CLIENT : SERVER;
     }
+
+    private SidedThreadGroups() { }
 }

fmlearlydisplay/build.gradle

@@ -1,67 +1,74 @@
-import net.minecraftforge.gradleutils.PomUtils
+import org.gradle.api.plugins.jvm.JvmTestSuite
+import org.gradle.internal.os.OperatingSystem
 
 plugins {
     id 'java-library'
+    id 'jvm-test-suite'
     id 'maven-publish'
-    id 'net.minecraftforge.licenser'
-    id 'net.minecraftforge.gradleutils'
+    alias libs.plugins.licenser
+    alias libs.plugins.gradleutils
+    alias libs.plugins.gitversion
+    alias libs.plugins.changelog
+    id 'net.minecraftforge.forge.build.convention'
 }
 
-apply from: rootProject.file('build_shared.gradle')
-
-import org.gradle.internal.os.OperatingSystem
 switch (OperatingSystem.current()) {
-	case OperatingSystem.LINUX:
-		project.ext.lwjglNatives = "natives-linux"
-		break
-	case OperatingSystem.MAC_OS:
-		project.ext.lwjglNatives = "natives-macos"
-		break
-	case OperatingSystem.WINDOWS:
-		project.ext.lwjglNatives = "natives-windows"
-		break
+    case OperatingSystem.LINUX:
+        project.ext.lwjglNatives = "natives-linux"
+        break
+    case OperatingSystem.MAC_OS:
+        project.ext.lwjglNatives = "natives-macos"
+        break
+    case OperatingSystem.WINDOWS:
+        project.ext.lwjglNatives = "natives-windows"
+        break
 }
 
+gradleutils.displayName = 'FML Early Display'
+final vendor = 'Forge Development LLC'
+description = 'A pretty looking, but prone to erroring screen displayed during Forge loading.'
+
 java {
-    toolchain.languageVersion = JavaLanguageVersion.of(JAVA_VERSION)
+    toolchain.languageVersion = JavaLanguageVersion.of(javaVersion)
     withSourcesJar()
 }
 
+license {
+    header = rootProject.file('LICENSE-header.txt')
+}
+
+changelog {
+    from changelogBase
+}
+
 dependencies {
-    compileOnly(libs.jetbrains.annotations)
-    implementation(project(':fmlloader'))
-    implementation(project(':fmlcore'))
-    implementation(libs.bundles.lwjgl)
-    implementation('org.slf4j:slf4j-api:1.8.0-beta4')
-    implementation(libs.jopt.simple)
-    testImplementation('org.junit.jupiter:junit-jupiter-api:5.8.2')
-    testImplementation('org.powermock:powermock-core:2.0.9')
-    testRuntimeOnly('org.junit.jupiter:junit-jupiter-engine:5.8.2')
-    testRuntimeOnly('org.slf4j:slf4j-jdk14:1.8.0-beta4')
-    testRuntimeOnly("org.lwjgl:lwjgl::$lwjglNatives")
-    testRuntimeOnly("org.lwjgl:lwjgl-glfw::$lwjglNatives")
-    testRuntimeOnly("org.lwjgl:lwjgl-opengl::$lwjglNatives")
-    testRuntimeOnly("org.lwjgl:lwjgl-stb::$lwjglNatives")
+    compileOnly libs.jetbrains.annotations
+
+    implementation projects.fmlloader
+    implementation projects.fmlcore
+    implementation libs.bundles.lwjgl
+    implementation earlyDisplayLibs.slf4j.api
+    implementation libs.jopt.simple
 }
 
-tasks.named('test', Test).configure {
-    useJUnitPlatform()
+// See gradle/gradle#35070 (https://github.com/gradle/gradle/issues/35070)
+// We are making the list of providers first BEFORE mapping them to a provider of the resolved objects so that they can be finalized after configuration.
+var lwjglTestLibs = [
+        dependencies.variantOf(earlyDisplayTestLibs.lwjgl) { classifier lwjglNatives },
+        dependencies.variantOf(earlyDisplayTestLibs.lwjgl.glfw) { classifier lwjglNatives },
+        dependencies.variantOf(earlyDisplayTestLibs.lwjgl.opengl) { classifier lwjglNatives },
+        dependencies.variantOf(earlyDisplayTestLibs.lwjgl.stb) { classifier lwjglNatives }
+].with { list ->
+    provider { list.collect { it.get() } }
 }
 
-tasks.named('jar', Jar).configure {
-    manifest {
-        attributes([
-            'Automatic-Module-Name': 'net.minecraftforge.earlydisplay',
-            'Forge-Module-Layer':    'boot'
-        ] as LinkedHashMap)
-        attributes([
-            'Specification-Title':      'FML Early Display',
-            'Specification-Vendor':     'Forge Development LLC',
-            'Specification-Version':    '1',
-            'Implementation-Title':     'FML Early Display',
-            'Implementation-Vendor':    'Forge Development LLC',
-            'Implementation-Version':   '1.0'
-        ] as LinkedHashMap, 'net/minecraftforge/fml/earlydisplay/')
+testing.suites.named('test', JvmTestSuite) {
+    useJUnitJupiter('5.8.2')
+
+    dependencies {
+        implementation earlyDisplayTestLibs.powermock.core
+        runtimeOnly earlyDisplayLibs.slf4j.jdk14
+        runtimeOnly.bundle lwjglTestLibs
     }
 }
 
@@ -69,24 +76,42 @@ tasks.withType(JavaCompile).configureEach {
     options.compilerArgs << '-Xlint:unchecked'
 }
 
-license {
-    header = rootProject.file('LICENSE-header.txt')
+tasks.named('jar', Jar) {
+    manifest {
+        attributes([
+                'Automatic-Module-Name': 'net.minecraftforge.earlydisplay',
+                'Forge-Module-Layer'   : 'boot'
+        ])
+        attributes([
+                'Specification-Title'   : gradleutils.displayName.get(),
+                'Specification-Vendor'  : vendor,
+                'Specification-Version' : '1',
+                'Implementation-Title'  : gradleutils.displayName.get(),
+                'Implementation-Vendor' : vendor,
+                'Implementation-Version': '1.0'
+        ], 'net/minecraftforge/fml/earlydisplay/')
+    }
 }
 
 publishing {
-    publications.register('mavenJava', MavenPublication).configure {
-        from components.java
-        artifactId = 'fmlearlydisplay'
-        pom {
-            name = project.name
-            description = 'A pretty looking, but prone to erroring screen displayed during Forge loading.'
-            url = 'https://github.com/MinecraftForge/MinecraftForge'
-            PomUtils.setGitHubDetails(pom, 'MinecraftForge')
-            license PomUtils.Licenses.LGPLv2_1
-        }
-    }
-    
     repositories {
         maven gradleutils.publishingForgeMaven
     }
-}
+
+    publications.register('mavenJava', MavenPublication) {
+        changelog.publish(it)
+        gradleutils.promote(it)
+
+        from components.java
+
+        pom {
+            description = project.description
+
+            gradleutils.pom.addRemoteDetails(pom)
+
+            licenses {
+                license gradleutils.pom.licenses.LGPLv2_1
+            }
+        }
+    }
+}

fmlearlydisplay/src/main/java/net/minecraftforge/fml/earlydisplay/DisplayWindow.java

@@ -46,8 +46,6 @@ import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import java.util.function.IntConsumer;
-import java.util.function.IntSupplier;
-import java.util.function.LongSupplier;
 import java.util.function.Supplier;
 import java.util.stream.Collector;
 import java.util.stream.Collectors;
@@ -70,7 +68,7 @@ import static org.lwjgl.opengl.GL32C.*;
  * Based on the prior ClientVisualization, with some personal touches.
  */
 public class DisplayWindow implements ImmediateWindowProvider {
-    private static final int[][] GL_VERSIONS = new int[][] {{4,6}, {4,5}, {4,4}, {4,3}, {4,2}, {4,1}, {4,0}, {3,3}, {3,2}};
+    private static final int[][] GL_VERSIONS = new int[][] {{4,6}, {4,5}, {4,4}, {4,3}, {4,2}, {4,1}, {4,0}, {3,3}};
     private static final Logger LOGGER = LoggerFactory.getLogger("EARLYDISPLAY");
     private final AtomicBoolean animationTimerTrigger = new AtomicBoolean(true);
 
@@ -314,17 +312,18 @@ public class DisplayWindow implements ImmediateWindowProvider {
         LOGGER.error("ERROR DISPLAY\n"+msgBuilder);
         // we show the display on a new dedicated thread
         Executors.newSingleThreadExecutor().submit(()-> {
-            var res = TinyFileDialogs.tinyfd_messageBox("Minecraft: Forge", msgBuilder.toString(), "yesno", "error", false);
-            if (res) {
+            var res = TinyFileDialogs.tinyfd_messageBox("Minecraft: Forge", msgBuilder.toString(), "yesno", "error", 0);
+            if (res != 0) {
                 try {
                     Desktop.getDesktop().browse(URI.create(ERROR_URL));
                 } catch (IOException ioe) {
-                    TinyFileDialogs.tinyfd_messageBox("Minecraft: Forge", "Sadly, we couldn't open your browser.\nVisit " + ERROR_URL, "ok", "error", false);
+                    TinyFileDialogs.tinyfd_messageBox("Minecraft: Forge", "Sadly, we couldn't open your browser.\nVisit " + ERROR_URL, "ok", "error", 0);
                 }
             }
             System.exit(1);
         });
     }
+
     /**
      * Called to initialize the window when preparing for the Render Thread.
      *
@@ -460,7 +459,9 @@ public class DisplayWindow implements ImmediateWindowProvider {
         this.winWidth = x[0];
         this.winHeight = y[0];
 
+        // Setting the window position isn't supported on wayland, so check the error here
         glfwSetWindowPos(window, (vidmode.width() - this.winWidth) / 2 + monitorX, (vidmode.height() - this.winHeight) / 2 + monitorY);
+        handleLastGLFWError();
 
         // Attempt setting the icon
 //        int[] channels = new int[1];
@@ -483,7 +484,10 @@ public class DisplayWindow implements ImmediateWindowProvider {
 
         // Show the window
         glfwShowWindow(window);
+        // Getting the window position isn't supported on wayland, so check the error here
         glfwGetWindowPos(window, x, y);
+        handleLastGLFWError();
+        
         this.winX = x[0];
         this.winY = y[0];
         glfwGetFramebufferSize(window, x, y);
@@ -492,6 +496,18 @@ public class DisplayWindow implements ImmediateWindowProvider {
         glfwPollEvents();
     }
 
+    private static void handleLastGLFWError() {
+        handleLastGLFWError((error, description) -> {
+            if (error == GLFW_FEATURE_UNAVAILABLE) {
+                // suppress window pos errors for unsupported platforms (wayland)
+                LOGGER.debug(String.format("Suppressing GLFW error: [0x%X]%s", error, description));
+                return;
+            }
+
+            throw new IllegalStateException(String.format("GLFW error: [0x%X]%s", error, description));
+        });
+    }
+
     private void winResize(long window, int width, int height) {
         if (window == this.window && width != 0 && height != 0) {
             this.winWidth = width;
@@ -529,7 +545,7 @@ public class DisplayWindow implements ImmediateWindowProvider {
      *
      * @return the Window we own.
      */
-    public long setupMinecraftWindow(final IntSupplier width, final IntSupplier height, final Supplier<String> title, final LongSupplier monitorSupplier) {
+    public long setupMinecraftWindow(final int width, final int height, final String title, final long monitorSupplier, final Supplier<Object> backend) {
         // wait for the window to actually be initialized
         try {
             this.initializationFuture.get(30, TimeUnit.SECONDS);
@@ -549,11 +565,11 @@ public class DisplayWindow implements ImmediateWindowProvider {
         var renderlockticket = false;
         do {
             try {
-                    renderlockticket = renderLock.tryAcquire(100, TimeUnit.MILLISECONDS);
-                    if (++tries > 9) {
-                        Thread.dumpStack();
-                        crashElegantly("We seem to be having trouble handing off the window, tried for 1 second");
-                    }
+                renderlockticket = renderLock.tryAcquire(100, TimeUnit.MILLISECONDS);
+                if (++tries > 9) {
+                    Thread.dumpStack();
+                    crashElegantly("We seem to be having trouble handing off the window, tried for 1 second");
+                }
             } catch (InterruptedException e) {
                 Thread.interrupted();
             }
@@ -563,7 +579,7 @@ public class DisplayWindow implements ImmediateWindowProvider {
 
         glfwMakeContextCurrent(window);
         // Set the title to what the game wants
-        glfwSetWindowTitle(window, title.get());
+        glfwSetWindowTitle(window, title);
         glfwSwapInterval(0);
         // Clean up our hooks
         glfwSetFramebufferSizeCallback(window, null).free();
@@ -649,4 +665,4 @@ public class DisplayWindow implements ImmediateWindowProvider {
         this.context.elementShader().close();
         SimpleBufferBuilder.destroy();
     }
-}
+}

fmlloader/build.gradle

@@ -1,69 +1,75 @@
-import net.minecraftforge.gradleutils.PomUtils
+import groovy.transform.CompileDynamic
+import groovy.transform.CompileStatic
+import groovy.transform.PackageScope
+import net.minecraftforge.forgedev.legacy.tasks.JarJarMetadataOptions
+import org.gradle.api.plugins.jvm.JvmTestSuite
+
+import javax.inject.Inject
 
 plugins {
     id 'java-library'
+    id 'jvm-test-suite'
     id 'maven-publish'
-    id 'net.minecraftforge.licenser'
-    id 'net.minecraftforge.gradleutils'
-    alias(libs.plugins.apt)
+    alias libs.plugins.licenser
+    alias libs.plugins.gradleutils
+    alias libs.plugins.gitversion
+    alias libs.plugins.changelog
+    alias libs.plugins.apt
+    id 'net.minecraftforge.forge.build.convention'
 }
 
-apply from: rootProject.file('build_shared.gradle')
-
-configurations.forEach{ it.transitive = false }
-
-dependencies {
-    compileOnly(libs.jetbrains.annotations)
-
-    api(libs.bundles.asm) // Needed by all the black magic
-    api(libs.forgespi)
-    api(libs.mergetool.api)
-    api(libs.log4j.api)
-    api(libs.slf4j.api)
-    api(libs.guava)
-    api(libs.gson)
-    api(libs.maven.artifact)
-    api(libs.apache.commons)
-    api(libs.bundles.night.config)
-    api(libs.modlauncher)
-    api(libs.coremods)
-    api(libs.mojang.logging)
-    api(libs.jarjar.selector)
-    api(libs.jarjar.meta)
-
-    implementation(libs.jopt.simple)
-    implementation(libs.securemodules)
-    implementation(libs.accesstransformers)
-    implementation(libs.terminalconsoleappender)
-    implementation(libs.jimfs)
-
-    // Needed because we have a custom log4j plugin, and they removed package scanning and require a data file to be generated
-    implementation(libs.log4j.core)
-    annotationProcessor(libs.bundles.log4j)
-
-    testCompileOnly(libs.jetbrains.annotations)
-    testRuntimeOnly(libs.bootstrap)
-}
+gradleutils.displayName = 'FMLLoader'
+final vendor = 'Forge Development LLC'
+description = 'Modifications to Minecraft to enable mod developers.'
 
 java {
-    toolchain.languageVersion = JavaLanguageVersion.of(JAVA_VERSION)
+    toolchain.languageVersion = JavaLanguageVersion.of(javaVersion)
     withSourcesJar()
 }
 
-tasks.named('jar', Jar).configure {
-    manifest {
-        attributes([
-            'Automatic-Module-Name': 'net.minecraftforge.fmlloader',
-            'Forge-Module-Layer':    'boot'
-        ] as LinkedHashMap)
-        attributes([
-            'Specification-Title':   'FMLLoader',
-            'Specification-Vendor':  'Forge Development LLC',
-            'Specification-Version': '1',
-            'Implementation-Title':  'FMLLoader',
-            'Implementation-Vendor': 'Forge Development LLC',
-            'Implementation-Version': FORGE_VERSION
-        ] as LinkedHashMap, 'net/minecraftforge/fml/loading/')
+license {
+    header = rootProject.file('LICENSE-header.txt')
+}
+
+changelog {
+    from changelogBase
+}
+
+dependencies {
+    compileOnly libs.jetbrains.annotations
+
+    // TODO [FMLLoader] Figure out a better way to lock transitive dependencies to the explicit versions shipped by the isntaller
+    api(libs.bundles.asm         ){ transitive = false } // Needed by all the black magic
+    api(libs.forgespi            ){ transitive = false }
+    api(libs.mergetool.api       ){ transitive = false }
+    api(libs.log4j.api           ){ transitive = false }
+    api(libs.slf4j.api           ){ transitive = false }
+    api(libs.guava               ){ transitive = false }
+    api(libs.gson                ){ transitive = false }
+    api(libs.maven.artifact      ){ transitive = false }
+    api(libs.apache.commons      ){ transitive = false }
+    api(libs.bundles.night.config){ transitive = false }
+    api(libs.modlauncher         ){ transitive = false }
+    api(libs.mojang.logging      ){ transitive = false }
+    api(libs.jarjar.selector     ){ transitive = false }
+    api(libs.jarjar.meta         ){ transitive = false }
+
+    implementation(libs.jopt.simple            ){ transitive = false }
+    implementation(libs.securemodules          ){ transitive = false }
+    implementation(libs.accesstransformers     ){ transitive = false }
+    implementation(libs.terminalconsoleappender){ transitive = false }
+    implementation(libs.jimfs                  ){ transitive = false }
+    implementation(libs.roimfs                 ){ transitive = false }
+
+    // Needed because we have a custom log4j plugin, and they removed package scanning and require a data file to be generated
+    implementation(libs.log4j.core        ){ transitive = false }
+    annotationProcessor(libs.bundles.log4j){ transitive = false }
+}
+
+testing.suites.named('test', JvmTestSuite) {
+    dependencies {
+        compileOnly libs.jetbrains.annotations
+        runtimeOnly libs.bootstrap
     }
 }
 
@@ -71,56 +77,114 @@ tasks.withType(JavaCompile).configureEach {
     options.compilerArgs << '-Xlint:unchecked'
 }
 
-license {
-    header = rootProject.file('LICENSE-header.txt')
+tasks.named('jar', Jar) {
+    manifest {
+        attributes([
+                'Automatic-Module-Name': 'net.minecraftforge.fmlloader',
+                'Forge-Module-Layer'   : 'boot'
+        ])
+        attributes([
+                'Specification-Title'   : gradleutils.displayName.get(),
+                'Specification-Vendor'  : vendor,
+                'Specification-Version' : '1',
+                'Implementation-Title'  : gradleutils.displayName.get(),
+                'Implementation-Vendor' : vendor,
+                'Implementation-Version': forgeVersion
+        ], 'net/minecraftforge/fml/loading/')
+    }
 }
 
 publishing {
-    publications.register('mavenJava', MavenPublication).configure {
-        from components.java
-        artifactId = 'fmlloader'
-        pom {
-            name = project.name
-            description = 'Modifactions to Minecraft to enable mod developers.'
-            url = 'https://github.com/MinecraftForge/MinecraftForge'
-            PomUtils.setGitHubDetails(pom, 'MinecraftForge')
-            license PomUtils.Licenses.LGPLv2_1
-        }
-    }
-
     repositories {
         maven gradleutils.publishingForgeMaven
     }
-}
 
-tasks.register('writeForgeVersionJson') {
-    doLast {
-        file('src/main/resources/forge_version.json').json = [
-            forge: FORGE_VERSION,
-            mc: MC_VERSION,
-            mcp: MCP_VERSION
-        ]
+    publications.register('mavenJava', MavenPublication) {
+        changelog.publish(it)
+        gradleutils.promote(it)
+
+        from components.java
+
+        pom {
+            description = project.description
+
+            gradleutils.pom.addRemoteDetails(pom)
+
+            licenses {
+                license gradleutils.pom.licenses.LGPLv2_1
+            }
+        }
     }
 }
 
-tasks.named('generateResources').configure {
-    dependsOn('eclipseJdt')
-    dependsOn('eclipseJdtApt')
-    dependsOn('eclipseFactorypath')
-    dependsOn('writeForgeVersionJson')
-}
+// A simple task to write JSON to a file. Using Task#doLast to output files is no longer supported.
+// This code may seem verbose, but it's better this way.  If more projects need this, we can move it to buildSrc.
+@CompileStatic
+@PackageScope abstract class WriteForgeVersionJson extends DefaultTask {
+    abstract @Input Property<String> getForgeVersion()
+    abstract @Input Property<String> getMinecraftVersion()
+    abstract @Input Property<String> getMcpVersion()
 
-eclipse {
-    classpath {
-       // We need to set the default output directory for the log4j annotation processor
-       // Ideally we'd just set the value, but the eclipse plugin deduplicates the output directories
-       // So we have to do a hacky whenMerged
-       //defaultOutputDir = file('bin/main')
-       file.whenMerged {
-           entries.each { entry ->
-               if (entry.kind == 'output' && entry.hasProperty('path'))
-                   entry.path = 'bin/main'
-           }
-       }
+    abstract @OutputFile RegularFileProperty getOutputFile()
+
+    @Inject
+    WriteForgeVersionJson() {}
+
+    @TaskAction
+    @CompileDynamic
+    void exec() {
+        var json = new groovy.json.JsonBuilder()
+        json {
+            forge this.forgeVersion.get()
+            mc    this.minecraftVersion.get()
+            mcp   this.mcpVersion.get()
+        }
+        this.outputFile.asFile.get().text = json.toPrettyString()
+    }
+}
+
+tasks.register('writeForgeVersionJson', WriteForgeVersionJson) {
+    forgeVersion = project.forgeVersion
+    minecraftVersion = project.minecraftVersion
+    mcpVersion = project.mcpVersion
+
+    outputFile = file('src/main/resources/forge_version.json')
+}
+
+tasks.register('jarJarOptionsJson', JarJarMetadataOptions) {
+    metadataFile = project.file('src/main/resources/jarjar_options.json')
+    // This is resolved too early by cpw.mods.modlauncher.TransformationServicesHandler.discoverServices(DiscoveryData) But eventually...
+    //add(libs.mixin, 'org/spongepowered/asm/mixin/Mixin.class')
+    add(libs.mixinextras.forge) {
+        containedJarMetadata {
+            path = ''
+        }
+        resource = 'com/llamalad7/mixinextras/platform/forge/MixinExtrasConfigPlugin.class'
+        layer = 'GAMELIBRARY'
+        id = 'mixinextras'
+        nested = true
+    }
+}
+
+tasks.named('generateResources') {
+    dependsOn(
+            tasks.named('eclipseJdt'),
+            tasks.named('eclipseJdtApt'),
+            tasks.named('eclipseFactorypath'),
+            tasks.named('writeForgeVersionJson', WriteForgeVersionJson),
+            tasks.named('jarJarOptionsJson')
+    )
+}
+
+eclipse.classpath {
+    // We need to set the default output directory for the log4j annotation processor
+    // Ideally we'd just set the value, but the eclipse plugin deduplicates the output directories
+    // So we have to do a hacky whenMerged
+    //defaultOutputDir = file('bin/main')
+    file.whenMerged {
+        entries.each { entry ->
+            if (entry.kind == 'output' && entry.hasProperty('path'))
+                entry.path = 'bin/main'
+        }
     }
 }

fmlloader/src/main/java/net/minecraftforge/fml/common/asm/CapabilityTokenSubclass.java

@@ -34,11 +34,10 @@ import cpw.mods.modlauncher.serviceapi.ILaunchPluginService;
  *  }</code>
  * </pre>
  */
-public class CapabilityTokenSubclass implements ILaunchPluginService {
-
+public final class CapabilityTokenSubclass implements ILaunchPluginService {
     private static final String FUNC_NAME = "getType";
     private static final String FUNC_DESC = "()Ljava/lang/String;";
-    private static final String CAP_INJECT = "net/minecraftforge/common/capabilities/CapabilityToken"; //Don't directly reference this to prevent class loading.
+    private static final String CAP_INJECT = "net/minecraftforge/common/capabilities/CapabilityToken"; // Don't directly reference this to prevent class loading.
 
     @Override
     public String name() {
@@ -56,8 +55,11 @@ public class CapabilityTokenSubclass implements ILaunchPluginService {
         String internalName = classType.getInternalName();
         if (internalName.startsWith("net/minecraft/") || internalName.startsWith("com/mojang/"))
             return NAY;
+
+        if (internalName.startsWith("net/minecraftforge/common/capabilities/"))
+            return YAY;
         
-        return YAY;
+        return internalName.contains("$") ? YAY : NAY; // Anonymous subclasses only
     }
 
     @Override
@@ -70,7 +72,7 @@ public class CapabilityTokenSubclass implements ILaunchPluginService {
             }
             return ComputeFlags.SIMPLE_REWRITE;
         } else if (CAP_INJECT.equals(classNode.superName)) {
-            Holder cls = new Holder();
+            var cls = new Object() { String value = null; };
 
             SignatureReader reader = new SignatureReader(classNode.signature); // Having a node version of this would probably be useful.
             reader.accept(new SignatureVisitor(Opcodes.ASM9) {
@@ -106,8 +108,4 @@ public class CapabilityTokenSubclass implements ILaunchPluginService {
             return ComputeFlags.NO_REWRITE;
         }
     }
-
-    private static final class Holder {
-        String value;
-    }
 }

fmlloader/src/main/java/net/minecraftforge/fml/common/asm/RuntimeEnumExtender.java

@@ -49,7 +49,7 @@ public class RuntimeEnumExtender implements ILaunchPluginService {
 
     private static final class LazyInit {
         private LazyInit() {}
-        private static final boolean ANY_MODS = LoadingModList.get().getMods().size() > 2; // 2: forge, minecraft
+        private static final boolean ANY_MODS = LoadingModList.getMods().size() > 2; // 2: forge, minecraft
     }
 
     @Override

fmlloader/src/main/java/net/minecraftforge/fml/loading/FMLLoader.java

@@ -16,7 +16,6 @@ import net.minecraftforge.accesstransformer.service.AccessTransformerService;
 import net.minecraftforge.api.distmarker.Dist;
 import net.minecraftforge.fml.loading.targets.CommonLaunchHandler;
 import net.minecraftforge.forgespi.Environment;
-import net.minecraftforge.forgespi.coremod.ICoreModProvider;
 import org.slf4j.Logger;
 
 import java.nio.file.Path;
@@ -31,14 +30,11 @@ import java.util.function.BiFunction;
 import static net.minecraftforge.fml.loading.LogMarkers.CORE;
 import static net.minecraftforge.fml.loading.LogMarkers.SCAN;
 
-public class FMLLoader {
+public final class FMLLoader {
     private static final Logger LOGGER = LogUtils.getLogger();
     private static AccessTransformerService accessTransformer;
-    private static ICoreModProvider coreModProvider;
-    private static LanguageLoadingProvider languageLoadingProvider;
     private static Dist dist;
     private static String naming;
-    private static LoadingModList loadingModList;
     private static RuntimeDistCleaner runtimeDistCleaner;
     private static Path gamePath;
     private static final VersionInfo versionInfo = VersionInfo.detect();
@@ -57,8 +53,6 @@ public class FMLLoader {
         checkPackage(ITransformationService.class, "4.0", "ModLauncher");
         accessTransformer  = getPlugin(env, "accesstransformer",  "1.0", "AccessTransformer");
         runtimeDistCleaner = getPlugin(env, "runtimedistcleaner", "1.0", "RuntimeDistCleaner");
-        coreModProvider = getSingleService(ICoreModProvider.class, "CoreMod");
-        LOGGER.debug(CORE, "FML found CoreMod version : {}", JarVersionLookupHandler.getInfo(coreModProvider.getClass()).impl().version().orElse("MISSING"));
         checkPackage(Environment.class, "2.0", "ForgeSPI");
 
         try {
@@ -96,6 +90,7 @@ public class FMLLoader {
         }
     }
 
+    @SuppressWarnings("unused")
     private static <T> T getSingleService(Class<T> clazz, String name) throws IncompatibleEnvironmentException {
           var providers = new ArrayList<T>();
           for (var itr = ServiceLoader.load(FMLLoader.class.getModule().getLayer(), clazz).iterator(); itr.hasNext(); ) {
@@ -146,35 +141,25 @@ public class FMLLoader {
     }
 
     public static List<ITransformationService.Resource> beginModScan(final Map<String,?> arguments) {
-        LOGGER.debug(SCAN,"Scanning for Mod Locators");
-        var modDiscoverer = new ModDiscoverer(arguments);
-        modValidator = modDiscoverer.discoverMods();
+        LOGGER.debug(SCAN, "Scanning for Mod Locators");
+        modValidator = ModDiscoverer.discoverMods(arguments);
         var pluginResources = modValidator.getPluginResources();
         return List.of(pluginResources);
     }
 
     public static List<ITransformationService.Resource> completeScan(IModuleLayerManager layerManager) {
         moduleLayerManager = layerManager;
-        languageLoadingProvider = new LanguageLoadingProvider();
+        LanguageLoadingProvider.reload();
         backgroundScanHandler = modValidator.stage2Validation();
-        loadingModList = backgroundScanHandler.getLoadingModList();
         return List.of(modValidator.getModResources());
     }
 
-    public static ICoreModProvider getCoreModProvider() {
-        return coreModProvider;
-    }
-
-    public static LanguageLoadingProvider getLanguageLoadingProvider() {
-        return languageLoadingProvider;
-    }
-
     public static CommonLaunchHandler getLaunchHandler() {
         return commonLaunchHandler;
     }
 
     public static void addAccessTransformer(Path atPath, ModFile modName) {
-        LOGGER.debug(SCAN, "Adding Access Transformer in {}", modName.getFilePath());
+        LOGGER.debug(SCAN, "Adding Access Transformer {} in {}", atPath, modName.getFilePath());
         accessTransformer.offerResource(atPath, modName.getFileName());
     }
 
@@ -188,10 +173,6 @@ public class FMLLoader {
         progressWindowTick.run();
     }
 
-    public static LoadingModList getLoadingModList() {
-        return loadingModList;
-    }
-
     public static Path getGamePath() {
         return gamePath;
     }

fmlloader/src/main/java/net/minecraftforge/fml/loading/FMLServiceProvider.java

@@ -68,7 +68,6 @@ public class FMLServiceProvider implements ITransformationService {
     @SuppressWarnings("rawtypes")
     @Override
     public @NotNull List<ITransformer> transformers() {
-        LOGGER.debug(CORE, "Loading coremod transformers");
-        return new ArrayList<>(FMLLoader.getCoreModProvider().getCoreModTransformers());
+        return List.of();
     }
 }

fmlloader/src/main/java/net/minecraftforge/fml/loading/ImmediateWindowHandler.java

@@ -51,8 +51,8 @@ public class ImmediateWindowHandler {
         earlyProgress.label("Bootstrapping Minecraft");
     }
 
-    public static long setupMinecraftWindow(final IntSupplier width, final IntSupplier height, final Supplier<String> title, final LongSupplier monitor) {
-        return provider.setupMinecraftWindow(width, height, title, monitor);
+    public static long setupMinecraftWindow(final int width, final int height, final String title, final long monitor, final Supplier<Object> backend) {
+        return provider.setupMinecraftWindow(width, height, title, monitor, backend);
     }
 
     public static boolean positionWindow(Optional<Object> monitor,IntConsumer widthSetter, IntConsumer heightSetter, IntConsumer xSetter, IntConsumer ySetter) {
@@ -104,9 +104,9 @@ public class ImmediateWindowHandler {
         }
 
         @Override
-        public long setupMinecraftWindow(final IntSupplier width, final IntSupplier height, final Supplier<String> title, final LongSupplier monitor) {
+        public long setupMinecraftWindow(final int width, final int height, final String title, final long monitor, final Supplier<Object> backend) {
             try {
-                var longsupplier = (LongSupplier)NV_HANDOFF.invoke(null, width, height, title, monitor);
+                var longsupplier = (LongSupplier)NV_HANDOFF.invoke(null, width, height, title, monitor, backend);
                 return longsupplier.getAsLong();
             } catch (Throwable e) {
                 throw new IllegalStateException("How did you get here?", e);

fmlloader/src/main/java/net/minecraftforge/fml/loading/ImmediateWindowProvider.java

@@ -8,8 +8,6 @@ package net.minecraftforge.fml.loading;
 import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.IntConsumer;
-import java.util.function.IntSupplier;
-import java.util.function.LongSupplier;
 import java.util.function.Supplier;
 
 /**
@@ -66,7 +64,7 @@ public interface ImmediateWindowProvider {
      * @param monitor This is the monitor it should appear on.
      * @return The window id
      */
-    long setupMinecraftWindow(final IntSupplier width, final IntSupplier height, final Supplier<String> title, final LongSupplier monitor);
+    long setupMinecraftWindow(final int width, final int height, final String title, final long monitor, final Supplier<Object> backend);
 
     /**
      * This is called after window handoff to allow us to tell Mojang about our window's position. This might give a

fmlloader/src/main/java/net/minecraftforge/fml/loading/LanguageLoadingProvider.java

@@ -18,7 +18,6 @@ import org.slf4j.Logger;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.ServiceConfigurationError;
 import java.util.ServiceLoader;
 import java.util.function.Consumer;
@@ -28,43 +27,36 @@ import java.util.stream.Stream;
 import static net.minecraftforge.fml.loading.LogMarkers.CORE;
 import static net.minecraftforge.fml.loading.LogMarkers.LOADING;
 
-public class LanguageLoadingProvider {
-    public void forEach(Consumer<IModLanguageProvider> consumer) {
+public final class LanguageLoadingProvider {
+    public static void forEach(Consumer<IModLanguageProvider> consumer) {
         providers.forEach(consumer);
     }
 
-    public <T> Stream<T> applyForEach(Function<IModLanguageProvider, T> function) {
+    public static <T> Stream<T> applyForEach(Function<IModLanguageProvider, T> function) {
         return providers.stream().map(function);
     }
 
-    public void reload() {
+    public static void reload() {
         loadLanguageProviders();
     }
 
-    /** This doesn't actually do anything with the argument, so just call reload(). Not sure when cpw broke that. */
-    @Deprecated(forRemoval = true, since = "1.20.2")
-    public void addAdditionalLanguages(List<ModFile> modFiles) {
-        reload();
-    }
-
     /*==========================================================================*
-     *                        INTERNAL SHIT                                     *
+     *                        INTERNAL                                          *
      *==========================================================================*/
     private static final Logger LOGGER = LogUtils.getLogger();
-    private final ServiceLoader<IModLanguageProvider> serviceLoader;
-    private final List<IModLanguageProvider> providers = new ArrayList<>();
-    private final Map<String, Wrapper> providersByName = new HashMap<>();
+    private static final ServiceLoader<IModLanguageProvider> serviceLoader;
+    private static final ArrayList<IModLanguageProvider> providers = new ArrayList<>();
+    private static final HashMap<String, Wrapper> providersByName = new HashMap<>();
     private static final DefaultArtifactVersion IN_DEV = new DefaultArtifactVersion("0.0-dev");
 
     private record Wrapper(ArtifactVersion version, IModLanguageProvider service) {}
 
-    LanguageLoadingProvider() {
+    static {
         var sl = Launcher.INSTANCE.environment().findModuleLayerManager().flatMap(lm -> lm.getLayer(Layer.PLUGIN)).orElseThrow();
         serviceLoader = ServiceLoader.load(sl, IModLanguageProvider.class);
-        loadLanguageProviders();
     }
 
-    private void loadLanguageProviders() {
+    private static void loadLanguageProviders() {
         providers.clear();
         providersByName.clear();
 
@@ -97,7 +89,7 @@ public class LanguageLoadingProvider {
         }
     }
 
-    public IModLanguageProvider findLanguage(ModFile mod, String language, VersionRange versionRange) {
+    public static IModLanguageProvider findLanguage(ModFile mod, String language, VersionRange versionRange) {
         var consumer = mod.getFileName();
         var wrapper = providersByName.get(language);
 

fmlloader/src/main/java/net/minecraftforge/fml/loading/LoadingModList.java

@@ -5,113 +5,46 @@
 
 package net.minecraftforge.fml.loading;
 
-import net.minecraftforge.fml.loading.moddiscovery.BackgroundScanHandler;
-import net.minecraftforge.fml.loading.moddiscovery.ModFile;
 import net.minecraftforge.fml.loading.moddiscovery.ModFileInfo;
 import net.minecraftforge.fml.loading.moddiscovery.ModInfo;
 import net.minecraftforge.forgespi.locating.IModFile;
+import org.jetbrains.annotations.Nullable;
 
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Collection;
 import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
 
-/**
- * Master list of all mods <em>in the loading context. This class cannot refer outside the
- * loading package</em>
- */
-public class LoadingModList {
-    private static LoadingModList INSTANCE;
-    private final List<ModFileInfo> modFiles;
-    private final List<ModInfo> sortedList;
-    private final Map<String, ModFileInfo> fileById;
-    private final List<EarlyLoadingException> preLoadErrors;
-    private List<IModFile> brokenFiles;
-
-    private LoadingModList(final List<ModFile> modFiles, final List<ModInfo> sortedList) {
-        this.modFiles = modFiles.stream()
-                .map(ModFile::getModFileInfo)
-                .map(ModFileInfo.class::cast)
-                .toList();
-        this.sortedList = sortedList.stream()
-                .map(ModInfo.class::cast)
-                .toList();
-        this.fileById = this.modFiles.stream()
-                .map(ModFileInfo::getMods)
-                .flatMap(Collection::stream)
-                .map(ModInfo.class::cast)
-                .collect(Collectors.toMap(ModInfo::getModId, ModInfo::getOwningFile));
-        this.preLoadErrors = new ArrayList<>();
+/// Master list of all mods in the loading context
+public sealed interface LoadingModList permits LoadingModListImpl {
+    static ModFileInfo getModFileById(String modId) {
+        return get().fileById().get(modId);
     }
 
-    public static LoadingModList of(List<ModFile> modFiles, List<ModInfo> sortedList, final EarlyLoadingException earlyLoadingException) {
-        INSTANCE = new LoadingModList(modFiles, sortedList);
-        if (earlyLoadingException != null)
-            INSTANCE.preLoadErrors.add(earlyLoadingException);
-        return INSTANCE;
+    static List<ModFileInfo> getModFiles() {
+        return get().getModFiles();
     }
 
-    public static LoadingModList get() {
-        return INSTANCE;
+    static List<ModInfo> getMods() {
+        return get().getMods();
     }
 
-    public void addCoreMods() {
-        modFiles.stream()
-                .map(ModFileInfo::getFile)
-                .map(ModFile::getCoreMods)
-                .flatMap(List::stream)
-                .forEach(FMLLoader.getCoreModProvider()::addCoreMod);
-    }
-
-    public void addAccessTransformers() {
-        for (ModFileInfo modFile : modFiles) {
-            ModFile mod = modFile.getFile();
-            var at = mod.getAccessTransformer().orElse(null);
-            if (at != null) {
-                FMLLoader.addAccessTransformer(at, mod);
-            }
-        }
-    }
-
-    public void addForScanning(BackgroundScanHandler backgroundScanHandler) {
-        backgroundScanHandler.setLoadingModList(this);
-        modFiles.stream()
-                .map(ModFileInfo::getFile)
-                .forEach(backgroundScanHandler::submitForScanning);
-    }
-
-    public List<ModFileInfo> getModFiles() {
-        return modFiles;
-    }
-
-    public Path findResource(final String className) {
-        for (ModFileInfo mf : modFiles) {
-            final Path resource = mf.getFile().findResource(className);
+    static @Nullable Path findResource(String className) {
+        for (ModFileInfo modFileInfo : get().getModFiles()) {
+            Path resource = modFileInfo.getFile().findResource(className);
             if (Files.exists(resource)) return resource;
         }
         return null;
     }
 
-    public ModFileInfo getModFileById(String modid) {
-        return this.fileById.get(modid);
+    static List<EarlyLoadingException> getErrors() {
+        return get().getErrors();
     }
 
-    public List<ModInfo> getMods() {
-        return this.sortedList;
+    static List<IModFile> getBrokenFiles() {
+        return get().getBrokenFiles();
     }
 
-    public List<EarlyLoadingException> getErrors() {
-        return preLoadErrors;
-    }
-
-    public void setBrokenFiles(final List<IModFile> brokenFiles) {
-        this.brokenFiles = brokenFiles;
-    }
-
-    public List<IModFile> getBrokenFiles() {
-        return this.brokenFiles;
+    private static LoadingModListImpl get() {
+        return LoadingModListImpl.get();
     }
 }

fmlloader/src/main/java/net/minecraftforge/fml/loading/LoadingModListImpl.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) Forge Development LLC and contributors
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+package net.minecraftforge.fml.loading;
+
+import net.minecraftforge.fml.loading.EarlyLoadingException.ExceptionData;
+import net.minecraftforge.fml.loading.moddiscovery.ModFile;
+import net.minecraftforge.fml.loading.moddiscovery.ModFileInfo;
+import net.minecraftforge.fml.loading.moddiscovery.ModInfo;
+import net.minecraftforge.forgespi.locating.IModFile;
+
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.slf4j.Logger;
+
+import com.mojang.logging.LogUtils;
+
+/**
+ * Master list of all mods <em>in the loading context. This class cannot refer outside the
+ * loading package</em>
+ */
+record LoadingModListImpl(
+        List<ModFileInfo> getModFiles,
+        List<ModInfo> getMods,
+        Map<String, ModFileInfo> fileById,
+        ArrayList<EarlyLoadingException> getErrors,
+        ArrayList<IModFile> getBrokenFiles
+) implements LoadingModList {
+    private static final Logger LOGGER = LogUtils.getLogger();
+    private static ModSorter.State temp;
+
+    LoadingModListImpl(List<ModFile> modFiles, List<ModInfo> sortedList) {
+        var modFileInfos = modFiles.stream()
+                .map(ModFile::getModFileInfo)
+                .map(ModFileInfo.class::cast)
+                .toList();
+        sortedList = sortedList.stream().toList();
+        var fileById = modFileInfos.stream()
+                .map(ModFileInfo::getMods)
+                .flatMap(Collection::stream)
+                .map(ModInfo.class::cast)
+                .collect(Collectors.toUnmodifiableMap(ModInfo::getModId, ModInfo::getOwningFile));
+        this(modFileInfos, sortedList, fileById, new ArrayList<>(), new ArrayList<>());
+    }
+
+    static LoadingModListImpl init(ModSorter.State modSorterState, EarlyLoadingException earlyLoadingException) {
+        temp = modSorterState;
+        var instance = get();
+        if (earlyLoadingException != null)
+            instance.getErrors.add(earlyLoadingException);
+        temp = null;
+        instance.addAccessTransformers();
+        return instance;
+    }
+
+    static LoadingModListImpl get() {
+        final class LazyInit {
+            private LazyInit() {}
+            private static final LoadingModListImpl INSTANCE
+                    = new LoadingModListImpl(LoadingModListImpl.temp.files(), LoadingModListImpl.temp.mods());
+        }
+        return LazyInit.INSTANCE;
+    }
+
+    private void addAccessTransformers() {
+        var errors = new ArrayList<ExceptionData>();
+
+        for (ModFileInfo modFile : getModFiles) {
+            ModFile mod = modFile.getFile();
+            for (var at : mod.getAccessTransformers()) {
+                if (!Files.exists(at)) {
+                    var message = "Invalid mod file: " + modFile.getFile().getFileName() + ". Missing Access Transformer: " + at;
+                    errors.add(new ExceptionData(message));
+                    LOGGER.error(message);
+                } else
+                    FMLLoader.addAccessTransformer(at, mod);
+            }
+        }
+
+        if (!errors.isEmpty())
+            getErrors.add(new EarlyLoadingException("Invalid Access Transformers", null, errors));
+    }
+}

fmlloader/src/main/java/net/minecraftforge/fml/loading/ModDirTransformerDiscoverer.java

@@ -7,8 +7,10 @@ package net.minecraftforge.fml.loading;
 
 import com.mojang.logging.LogUtils;
 import cpw.mods.jarhandling.SecureJar;
+import cpw.mods.modlauncher.Launcher;
 import cpw.mods.modlauncher.api.LamdbaExceptionUtils;
 import cpw.mods.modlauncher.api.NamedPath;
+import cpw.mods.modlauncher.api.TypesafeMap;
 import cpw.mods.modlauncher.serviceapi.ITransformerDiscoveryService;
 
 import org.jetbrains.annotations.ApiStatus;
@@ -40,6 +42,17 @@ public class ModDirTransformerDiscoverer implements ITransformerDiscoveryService
 
     @Override
     public void earlyInitialization(final String launchTarget, final String[] arguments) {
+        boolean isMixinEnabledInDev = false;
+        for (String arg : arguments) {
+            if (arg.startsWith("-mixin") || arg.startsWith("--mixin")) {
+                isMixinEnabledInDev = true;
+                break;
+            }
+        }
+        Launcher.INSTANCE.blackboard().putIfAbsent(
+            TypesafeMap.Key.getOrCreate(Launcher.INSTANCE.blackboard(), "isMixinEnabledInDev", Boolean.class),
+            isMixinEnabledInDev
+        );
         ImmediateWindowHandler.load(launchTarget, arguments);
     }
 

fmlloader/src/main/java/net/minecraftforge/fml/loading/ModSorter.java

@@ -33,10 +33,10 @@ import java.util.stream.Stream;
 
 import static net.minecraftforge.fml.loading.LogMarkers.LOADING;
 
-public class ModSorter {
+public final class ModSorter {
     private static final Logger LOGGER = LogUtils.getLogger();
 
-    private record State(List<ModFile> files, List<ModInfo> mods) {}
+    record State(List<ModFile> files, List<ModInfo> mods) {}
 
     private ModSorter() {}
 
@@ -46,13 +46,13 @@ public class ModSorter {
         List<ModFile> modFiles;
 
         try {
-            modFiles = new UniqueModListBuilder(mods).buildUniqueList().modFiles();
+            modFiles = UniqueModListBuilder.buildUniqueList(mods).modFiles();
         } catch (EarlyLoadingException e) {
             // We cannot build any list with duped mods. We have to abort immediately and report it
             // Note this will never actually throw an error because the duplicate checks are done in ModDiscovererer before we get to this phase
             // So all this is really doing is wasting time.
             // But i'm leaving it here until I rewrite all of cpw's mod loading code because its such a clusterfuck.
-            return LoadingModList.of(systemMods.files(), systemMods.mods(), e);
+            return LoadingModListImpl.init(systemMods, e);
         }
 
         var named = new HashMap<String, ModInfo>();
@@ -66,15 +66,15 @@ public class ModSorter {
 
         // if we miss one or the other, we abort now
         if (!failedList.isEmpty()) {
-            return LoadingModList.of(systemMods.files(), systemMods.mods(), new EarlyLoadingException("failure to validate mod list", null, failedList));
+            return LoadingModListImpl.init(systemMods, new EarlyLoadingException("failure to validate mod list", null, failedList));
         } else {
             // Otherwise, lets try and sort the modlist and proceed
             try {
                 var sorted = sort(modFiles, named);
-                return LoadingModList.of(sorted.files(), sorted.mods(), null);
+                return LoadingModListImpl.init(sorted, null);
             } catch (EarlyLoadingException e) {
                 // The only exception that can happen here is a cyclic exception, but fall back to system mods so we can display the nice screen.
-                return LoadingModList.of(systemMods.files(), systemMods.mods(), e);
+                return LoadingModListImpl.init(systemMods, e);
             }
         }
     }

fmlloader/src/main/java/net/minecraftforge/fml/loading/RuntimeDistCleaner.java

@@ -27,13 +27,12 @@ import org.slf4j.Logger;
 import org.slf4j.Marker;
 import org.slf4j.MarkerFactory;
 
-public class RuntimeDistCleaner implements ILaunchPluginService {
+public final class RuntimeDistCleaner implements ILaunchPluginService {
     private static final Logger LOGGER = LogUtils.getLogger();
     private static final Marker DISTXFORM = MarkerFactory.getMarker("DISTXFORM");
     private static String DIST;
     private static final String ONLYIN = Type.getDescriptor(OnlyIn.class);
     private static final String ONLYINS = Type.getDescriptor(OnlyIns.class);
-    private static final String MOD = "Lnet/minecraftforge/fml/common/Mod;";
 
     @Override
     public String name() {
@@ -49,10 +48,21 @@ public class RuntimeDistCleaner implements ILaunchPluginService {
             return NAY;
 
         String internalName = classType.getInternalName();
+
+        // Only apply to MC classes when on a dedicated server in a production environment
+        if (FMLEnvironment.production)
+            return FMLEnvironment.dist.isDedicatedServer() && isMinecraftClass(internalName) ? YAY : NAY;
+
+        // For dev time it's a bit trickier so that we can throw exceptions when someone uses @OnlyIn in their mod code,
+        // so that it's more obvious that the behaviour they're expecting won't work in production anymore
         if (internalName.startsWith("net/minecraftforge/"))
             return NAY;
 
-        return YAY;
+        // No Vanilla classes use @OnlyIn(Dist.SERVER), so we can skip them entirely when we're running on a client
+        if (FMLEnvironment.dist.isClient() && isMinecraftClass(internalName))
+            return NAY;
+
+        return YAY; // mod classes might have @OnlyIn, so parse them in dev to find out and throw if they do
     }
 
     @Override
@@ -60,16 +70,15 @@ public class RuntimeDistCleaner implements ILaunchPluginService {
         var changed = false;
 
         var annotations = unpack(classNode.visibleAnnotations);
+        var isNonMinecraftClass = !isMinecraftClass(classNode.name);
 
         if (remove(annotations, DIST)) {
             LOGGER.error(DISTXFORM, "Attempted to load class {} for invalid dist {}", classNode.name, DIST);
-            throw new RuntimeException("Attempted to load class "+ classNode.name  + " for invalid dist "+ DIST);
+            throw new RuntimeException("Attempted to load class " + classNode.name  + " for invalid dist " + DIST);
         }
 
-        if (!FMLEnvironment.production && !annotations.isEmpty() && hasModAnnotation(classNode.visibleAnnotations)) {
-            LOGGER.error(DISTXFORM, "Attempted to load class {} with @Mod and @OnlyIn/@OnlyIns annotations", classNode.name);
-            throw new RuntimeException("Found @OnlyIn on @Mod class "+ classNode.name  + " - this is not allowed as it causes crashes. Remove the OnlyIn and consider setting clientSideOnly=true in the root of your mods.toml instead");
-        }
+        if (isNonMinecraftClass && !annotations.isEmpty())
+            throw new UnsupportedOperationException("Mod class " + classNode.name + " is annotated with @OnlyIn, this is no longer supported as it slowed down startup times");
 
         if (classNode.interfaces != null && !classNode.interfaces.isEmpty()) {
             for (var ann : annotations) {
@@ -77,7 +86,7 @@ public class RuntimeDistCleaner implements ILaunchPluginService {
                     continue;
 
                 if (classNode.interfaces.remove(ann.intf)) {
-                    LOGGER.debug(DISTXFORM,"Removing Interface: {} implements {}", classNode.name, ann.intf);
+                    LOGGER.debug(DISTXFORM, "Removing Interface: {} implements {}", classNode.name, ann.intf);
                     changed = true;
                 }
             }
@@ -101,6 +110,9 @@ public class RuntimeDistCleaner implements ILaunchPluginService {
                 LOGGER.debug(DISTXFORM, "Removing field: {}.{}", classNode.name, field.name);
                 itr.remove();
                 changed = true;
+
+                if (isNonMinecraftClass)
+                    throw new UnsupportedOperationException("Field " + field.name + " in mod class " + classNode.name + " is annotated with @OnlyIn, this is no longer supported as it slowed down startup times");
             }
         }
 
@@ -112,6 +124,9 @@ public class RuntimeDistCleaner implements ILaunchPluginService {
                 itr.remove();
                 lambdaGatherer.accept(method);
                 changed = true;
+
+                if (isNonMinecraftClass)
+                    throw new UnsupportedOperationException("Method " + method.name + " in mod class " + classNode.name + " is annotated with @OnlyIn, this is no longer supported as it slowed down startup times");
             }
         }
 
@@ -138,7 +153,7 @@ public class RuntimeDistCleaner implements ILaunchPluginService {
         return changed ? ComputeFlags.SIMPLE_REWRITE : ComputeFlags.NO_REWRITE;
     }
 
-    private static record Target(String side, String intf) {
+    private record Target(String side, String intf) {
         static Target from(final AnnotationNode node) {
             var idx = node.values.indexOf("value");
             var value = (String[])node.values.get(idx + 1); // Enums are stored as [Type, Value]
@@ -192,16 +207,8 @@ public class RuntimeDistCleaner implements ILaunchPluginService {
         return false;
     }
 
-    private static boolean hasModAnnotation(final List<AnnotationNode> anns) {
-        if (anns == null || anns.isEmpty())
-            return false;
-
-        for (var ann : anns) {
-            if (ann.desc.equals(MOD))
-                return true;
-        }
-
-        return false;
+    private static boolean isMinecraftClass(final String internalName) {
+        return internalName.startsWith("net/minecraft/") || internalName.startsWith("com/mojang/");
     }
 
     @SuppressWarnings("unchecked")
@@ -213,7 +220,7 @@ public class RuntimeDistCleaner implements ILaunchPluginService {
         };
     }
 
-    private static class LambdaGatherer extends MethodVisitor {
+    private static final class LambdaGatherer extends MethodVisitor {
         private static final Handle META_FACTORY = new Handle(Opcodes.H_INVOKESTATIC,
                 "java/lang/invoke/LambdaMetafactory", "metafactory",
                 "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;",

fmlloader/src/main/java/net/minecraftforge/fml/loading/StringSubstitutor.java

@@ -12,6 +12,7 @@ import java.util.Map;
 import org.apache.commons.lang3.text.StrLookup;
 import org.apache.commons.lang3.text.StrSubstitutor;
 
+// TODO: [FML] Remove this
 @SuppressWarnings("deprecation")
 public class StringSubstitutor {
     private static final Map<String, String> GLOBALS = Map.of(

fmlloader/src/main/java/net/minecraftforge/fml/loading/UniqueModListBuilder.java

@@ -17,8 +17,6 @@ import java.util.Collection;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
-import java.util.function.Function;
-import java.util.stream.Collectors;
 
 import static java.util.stream.Collectors.groupingBy;
 import static java.util.stream.Collectors.joining;
@@ -26,19 +24,12 @@ import static net.minecraftforge.fml.loading.LogMarkers.LOADING;
 
 @ApiStatus.Internal
 @Deprecated(since = "1.21.3", forRemoval = true) // TODO: [FML][Loading] Convert to package private in 1.22
-public class UniqueModListBuilder {
-    private final static Logger LOGGER = LogUtils.getLogger();
+public final class UniqueModListBuilder {
+    private UniqueModListBuilder() {}
 
-    private final List<ModFile> modFiles;
-
-    public UniqueModListBuilder(final List<ModFile> modFiles) {
-        this.modFiles = modFiles;
-    }
-
-    public UniqueModListData buildUniqueList() {
-        List<ModFile> uniqueModList;
-        List<ModFile> uniqueLibListWithVersion;
+    private static final Logger LOGGER = LogUtils.getLogger();
 
+    public static UniqueModListData buildUniqueList(List<ModFile> modFiles) {
         // Collect mod files by module name. This will be used for deduping purposes
         final Map<String, List<ModFile>> modFilesByFirstId = modFiles.stream()
                 .filter(mf -> mf.getModFileInfo() != null)
@@ -49,12 +40,12 @@ public class UniqueModListBuilder {
                 .collect(groupingBy(UniqueModListBuilder::getModId));
 
         // Select the newest by artifact version sorting of non-unique files thus identified
-        uniqueModList = modFilesByFirstId.entrySet().stream()
+        final List<ModFile> uniqueModList = modFilesByFirstId.entrySet().stream()
                 .map(UniqueModListBuilder::selectNewestModInfo)
                 .toList();
 
         // Select the newest by artifact version sorting of non-unique files thus identified
-        uniqueLibListWithVersion = libFilesWithVersionByModuleName.entrySet().stream()
+        final List<ModFile> uniqueLibListWithVersion = libFilesWithVersionByModuleName.entrySet().stream()
                 .map(UniqueModListBuilder::selectNewestModInfo)
                 .toList();
 
@@ -66,12 +57,10 @@ public class UniqueModListBuilder {
                 .collect(groupingBy(IModInfo::getModId));
 
         // Transform to the full lib id list
-        final Map<String, List<ModFile>> versionedLibIds = uniqueLibListWithVersion.stream()
+        final List<List<ModFile>> versionedLibs = uniqueLibListWithVersion.stream()
                 .map(UniqueModListBuilder::getModId)
-                .collect(Collectors.toMap(
-                    Function.identity(),
-                    libFilesWithVersionByModuleName::get
-                ));
+                .map(libFilesWithVersionByModuleName::get)
+                .toList();
 
         // Its theoretically possible that some mod has somehow moved an id to a secondary place, thus causing a dupe.
         // We can't handle this
@@ -84,24 +73,24 @@ public class UniqueModListBuilder {
                 )).toList();
 
         if (!dupedModErrors.isEmpty()) {
-            LOGGER.error(LOADING, "Found duplicate mods:\n{}", dupedModErrors.stream().collect(joining("\n")));
+            LOGGER.error(LOADING, "Found duplicate mods:\n{}", String.join("\n", dupedModErrors));
             throw new EarlyLoadingException("Duplicate mods found", null, dupedModErrors.stream()
-                    .map(s -> new EarlyLoadingException.ExceptionData(s))
+                    .map(EarlyLoadingException.ExceptionData::new)
                     .toList());
         }
 
 
-        final List<String> dupedLibErrors = versionedLibIds.values().stream()
-                .filter(modFiles -> modFiles.size() > 1)
+        final List<String> dupedLibErrors = versionedLibs.stream()
+                .filter(libModFiles -> libModFiles.size() > 1)
                 .map(mods -> String.format("\tLibrary: '%s' from files: %s",
                         getModId(mods.getFirst()),
                         mods.stream().map(ModFile::getFileName).collect(joining(", "))
                 )).toList();
 
         if (!dupedLibErrors.isEmpty()) {
-            LOGGER.error(LOADING, "Found duplicate plugins or libraries:\n{}", dupedLibErrors.stream().collect(joining("\n")));
+            LOGGER.error(LOADING, "Found duplicate plugins or libraries:\n{}", String.join("\n", dupedLibErrors));
             throw new EarlyLoadingException("Duplicate plugins or libraries found", null, dupedLibErrors.stream()
-                    .map(s -> new EarlyLoadingException.ExceptionData(s))
+                    .map(EarlyLoadingException.ExceptionData::new)
                     .toList());
         }
 
@@ -122,23 +111,26 @@ public class UniqueModListBuilder {
             modInfoList.sort(Comparator.comparing(UniqueModListBuilder::getVersion).reversed());
             LOGGER.debug("Selected file {} for modid {} with version {}", modInfoList.getFirst().getFileName(), fullList.getKey(), getVersion(modInfoList.getFirst()));
         }
-        return modInfoList.get(0);
+        return modInfoList.getFirst();
     }
 
     private static ArtifactVersion getVersion(final ModFile mf) {
-        if (mf.getModFileInfo() == null || mf.getModInfos() == null || mf.getModInfos().isEmpty()) {
+        List<IModInfo> modInfos;
+        if (mf.getModFileInfo() == null || (modInfos = mf.getModInfos()) == null || modInfos.isEmpty()) {
             return mf.getJarVersion();
         }
 
-        return mf.getModInfos().get(0).getVersion();
+        return modInfos.getFirst().getVersion();
     }
 
     private static String getModId(ModFile modFile) {
-        if (modFile.getModFileInfo() == null || modFile.getModFileInfo().getMods().isEmpty()) {
+        var modFileInfo = modFile.getModFileInfo();
+        List<IModInfo> mods;
+        if (modFileInfo == null || (mods = modFileInfo.getMods()).isEmpty()) {
             return modFile.getSecureJar().name();
         }
 
-        return modFile.getModFileInfo().getMods().get(0).getModId();
+        return mods.getFirst().getModId();
     }
 
     public record UniqueModListData(List<ModFile> modFiles, Map<String, List<ModFile>> modFilesByFirstId) {}

fmlloader/src/main/java/net/minecraftforge/fml/loading/VersionSupportMatrix.java

@@ -32,15 +32,6 @@ public class VersionSupportMatrix {
         }
     }
 
-    /**
-     * @deprecated Use {@link #testVersionSupportMatrix(VersionRange, String, String)} instead, unwrapping your BiPredicate.
-     */
-    @Deprecated(forRemoval = true, since = "1.21.1")
-    public static boolean testVersionSupportMatrix(VersionRange declaredRange, String lookupId, String type, BiPredicate<String, VersionRange> standardLookup) {
-        if (standardLookup.test(lookupId, declaredRange)) return true;
-        return testVersionSupportMatrix(declaredRange, lookupId, type);
-    }
-
     public static boolean testVersionSupportMatrix(VersionRange declaredRange, String lookupId, String type) {
         if (OVERRIDE_VERSIONS.isEmpty()) return false;
         List<ArtifactVersion> custom = OVERRIDE_VERSIONS.get(type + "." + lookupId);

fmlloader/src/main/java/net/minecraftforge/fml/loading/moddiscovery/AbstractModProvider.java

@@ -54,12 +54,16 @@ public abstract class AbstractModProvider implements IModProvider {
 
     @Nullable
     protected IModLocator.ModFileOrException createMod(Path path, boolean ignoreUnknown, String defaultType) {
+        var debug = path.toString();
+        if (debug.equals("/"))
+            debug = path.toUri().toString();
+
         var mjm = new ModJarMetadata();
         SecureJar sj = null;
         try {
             sj = SecureJar.from(jar -> loadMetaFromJar(jar, mjm), path);
         } catch (Throwable t) {
-            return new IModLocator.ModFileOrException(null, new ModFileLoadingException("Failed to create secure jar for \"" + path + "\" - " + t.getMessage()));
+            return new IModLocator.ModFileOrException(null, new ModFileLoadingException("Failed to create secure jar for \"" + debug + "\" - " + t.getMessage()));
         }
 
         IModFile mod;
@@ -68,7 +72,7 @@ public abstract class AbstractModProvider implements IModProvider {
             type = defaultType;
 
         if (sj.moduleDataProvider().findFile(MODS_TOML).isPresent()) {
-            LOGGER.debug(LogMarkers.SCAN, "Found {} mod of type {}: {}", MODS_TOML, type, path);
+            LOGGER.debug(LogMarkers.SCAN, "Found {} mod of type {}: {}", MODS_TOML, type, debug);
             mod = new ModFile(sj, this, ModFileParser::modsTomlParser);
             // ModJarMetadata is only used when loading mods.toml mods as ModJarMetadata
             mjm.setModFile(mod);
@@ -77,17 +81,17 @@ public abstract class AbstractModProvider implements IModProvider {
                 return new IModLocator.ModFileOrException(null, new ModFileLoadingException("File \"%s\" is not a Forge mod and cannot be loaded. Look for a Forge version of this mod or consider alternative mods.".formatted(mod.getFileName())));
             }
         } else if (type != null) {
-            LOGGER.debug(LogMarkers.SCAN, "Found {} mod of type {}: {}", JarFile.MANIFEST_NAME, type, path);
+            LOGGER.debug(LogMarkers.SCAN, "Found {} mod of type {}: {}", JarFile.MANIFEST_NAME, type, debug);
             mod = new ModFile(sj, this, this::manifestParser, type);
         } else if (ignoreUnknown) {
             return null;
         } else
-            return new IModLocator.ModFileOrException(null, new ModFileLoadingException("Invalid mod file found " + path));
+            return new IModLocator.ModFileOrException(null, new ModFileLoadingException("Invalid mod file found " + debug));
 
         return new IModLocator.ModFileOrException(mod, null);
     }
 
-    private static JarMetadata loadMetaFromJar(SecureJar jar, ModJarMetadata mjm) {
+    protected static JarMetadata loadMetaFromJar(SecureJar jar, ModJarMetadata mjm) {
         var info = jar.moduleDataProvider().open(MODULE_INFO).orElse(null);
         if (info != null) {
             try {
@@ -145,6 +149,12 @@ public abstract class AbstractModProvider implements IModProvider {
             public <T> Optional<T> getConfigElement(String... key) {
                 return Optional.empty();
             }
+
+            @Override
+            public List<? extends IConfigurable> getConfigList(String key) {
+                return Collections.emptyList();
+            }
+
             @Override
             public List<? extends IConfigurable> getConfigList(String... key) {
                 return Collections.emptyList();

fmlloader/src/main/java/net/minecraftforge/fml/loading/moddiscovery/BackgroundScanHandler.java

@@ -17,8 +17,7 @@ import java.time.Instant;
 import java.util.List;
 import java.util.concurrent.*;
 
-public class BackgroundScanHandler
-{
+public final class BackgroundScanHandler {
     private enum ScanStatus {
         NOT_STARTED,
         RUNNING,
@@ -33,7 +32,6 @@ public class BackgroundScanHandler
     private final ExecutorService modContentScanner;
     private final List<ModFile> modFiles;
     private ScanStatus status;
-    private LoadingModList loadingModList;
 
     public BackgroundScanHandler(final List<ModFile> modFiles) {
         this.modFiles = modFiles;
@@ -69,16 +67,6 @@ public class BackgroundScanHandler
         }
     }
 
-    public void setLoadingModList(LoadingModList loadingModList)
-    {
-        this.loadingModList = loadingModList;
-    }
-
-    public LoadingModList getLoadingModList()
-    {
-        return loadingModList;
-    }
-
     public void waitForScanToComplete(final Runnable ticker) {
         boolean timeoutActive = System.getProperty("fml.disableScanTimeout") == null;
         Instant deadline = Instant.now().plus(Duration.ofMinutes(10));

fmlloader/src/main/java/net/minecraftforge/fml/loading/moddiscovery/ClasspathLocator.java

@@ -45,7 +45,7 @@ public final class ClasspathLocator extends AbstractModProvider implements IModL
         // Find 'minecraft' during dev time this is also Forge. So skip it.
         // Can return null for dedicated server as Minecraft isn't on the classpath
         // On the client it doesn't matter as it's the vanilla jar so wouldnt have mods.toml in it.
-        var minecraft = getPathFromResource(cl, "net/minecraft/obfuscate/DontObfuscate.class");
+        var minecraft = getPathFromResource(cl, "net/minecraft/world/item/Item.class");
 
         var claimed = new HashSet<Path>();
         var tomls = getUrls(cl, MODS_TOML);
@@ -74,7 +74,8 @@ public final class ClasspathLocator extends AbstractModProvider implements IModL
         var ret = new ArrayList<ModFileOrException>();
         for (var path : claimed) {
             // Filter out anything found by the ServiceLoader
-            if (!ModDirTransformerDiscoverer.isServiceProvider(path))
+            if (!ModDirTransformerDiscoverer.isServiceProvider(path)
+                && !JarInJarDependencyLocator.isOption(path))
                 ret.add(createMod(path));
         }
         return ret;
@@ -107,7 +108,7 @@ public final class ClasspathLocator extends AbstractModProvider implements IModL
         return Path.of(URI.create(str));
     }
 
-    private static Path getPathFromResource(ClassLoader cl, String resource) {
+    static Path getPathFromResource(ClassLoader cl, String resource) {
         var url = cl.getResource(resource);
         if (url == null)
             return null;

fmlloader/src/main/java/net/minecraftforge/fml/loading/moddiscovery/CoreModFile.java

@@ -1,53 +0,0 @@
-/*
- * Copyright (c) Forge Development LLC and contributors
- * SPDX-License-Identifier: LGPL-2.1-only
- */
-
-package net.minecraftforge.fml.loading.moddiscovery;
-
-import net.minecraftforge.forgespi.coremod.ICoreModFile;
-
-import java.io.IOException;
-import java.io.Reader;
-import java.nio.file.Files;
-import java.nio.file.Path;
-
-import org.jetbrains.annotations.ApiStatus;
-
-@ApiStatus.Internal
-public final class CoreModFile implements ICoreModFile {
-    private final Path internalPath;
-    private final ModFile file;
-    private final String name;
-
-    CoreModFile(final String name, final Path path, final ModFile file) {
-        this.name = name;
-        this.internalPath = path;
-        this.file = file;
-    }
-
-    @Override
-    public Reader readCoreMod() throws IOException {
-        return Files.newBufferedReader(this.internalPath);
-    }
-
-    @Override
-    public Path getPath() {
-        return this.internalPath;
-    }
-
-    @Override
-    public Reader getAdditionalFile(final String fileName) throws IOException {
-        return Files.newBufferedReader(file.findResource(fileName));
-    }
-
-    @Override
-    public String getOwnerId() {
-        return this.file.getModInfos().get(0).getModId();
-    }
-
-    @Override
-    public String toString() {
-        return "{Name: " + name + ", Owner: " + getOwnerId() + " @ " + getPath() + "}";
-    }
-}

fmlloader/src/main/java/net/minecraftforge/fml/loading/moddiscovery/JarInJarDependencyLocator.java

@@ -5,22 +5,39 @@
 
 package net.minecraftforge.fml.loading.moddiscovery;
 
-import com.google.common.collect.ImmutableMap;
+import com.electronwill.nightconfig.core.UnmodifiableConfig;
+import com.electronwill.nightconfig.core.file.FileConfig;
 import com.mojang.logging.LogUtils;
+
+import cpw.mods.modlauncher.Launcher;
+import cpw.mods.modlauncher.api.TypesafeMap;
 import net.minecraftforge.fml.loading.EarlyLoadingException;
+import net.minecraftforge.fml.loading.EarlyLoadingException.ExceptionData;
+import net.minecraftforge.fml.loading.FMLEnvironment;
 import net.minecraftforge.forgespi.language.IModInfo;
 import net.minecraftforge.forgespi.locating.IDependencyLocator;
 import net.minecraftforge.forgespi.locating.IModFile;
-import net.minecraftforge.forgespi.locating.ModFileLoadingException;
+import net.minecraftforge.forgespi.locating.IModFile.Type;
+import net.minecraftforge.jarjar.metadata.ContainedJarIdentifier;
+import net.minecraftforge.jarjar.metadata.ContainedJarMetadata;
+import net.minecraftforge.jarjar.metadata.ContainedVersion;
+import net.minecraftforge.jarjar.metadata.MetadataIOHandler;
 import net.minecraftforge.jarjar.selection.JarSelector;
-import org.apache.maven.artifact.versioning.ArtifactVersion;
+
+import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
 import org.apache.maven.artifact.versioning.VersionRange;
 import org.jetbrains.annotations.ApiStatus;
-import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
+import org.slf4j.Marker;
+import org.slf4j.MarkerFactory;
 
+import java.io.IOException;
 import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.lang.module.ModuleDescriptor;
 import java.net.URI;
+import java.net.URISyntaxException;
 import java.nio.file.FileSystem;
 import java.nio.file.FileSystems;
 import java.nio.file.Files;
@@ -28,14 +45,20 @@ import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
+import java.util.StringJoiner;
+import java.util.TreeMap;
+import java.util.jar.Attributes;
+import java.util.jar.JarFile;
+import java.util.jar.Manifest;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 @ApiStatus.Internal
 public class JarInJarDependencyLocator extends AbstractModProvider implements IDependencyLocator {
+    private static final String ROIMFS = "roimfs";
     private static final String COLOR_CODE = "\u00a7";
     private static final String RESET  = COLOR_CODE + "r";
     private static final String YELLOW = COLOR_CODE + "e";
@@ -43,32 +66,238 @@ public class JarInJarDependencyLocator extends AbstractModProvider implements ID
     private static final String GREEN  = COLOR_CODE + "2";
 
     private static final Logger LOGGER = LogUtils.getLogger();
+    private static final Marker MARKER = MarkerFactory.getMarker("JAR-JAR"); // LogMarkers.SCAN;
+
+    private static final Map<Path, Option> OPTIONS = new HashMap<>();
+    private static volatile boolean optionsLoaded = false;
+
+    private static final Attributes.Name MIXIN_CONFIGS_ATTR = new Attributes.Name("MixinConfigs");
+    private static final Attributes.Name MIXIN_CONNECTOR_ATTR = new Attributes.Name("MixinConnector");
+    private static final ContainedJarMetadata MIXIN_EXTRAS_DEPENDENCY = makeMixinExtraDependency();
+
+    private static ContainedJarMetadata makeMixinExtraDependency() {
+        VersionRange range = null;
+        try {
+            range = VersionRange.createFromVersionSpec("[0,)");
+        } catch (InvalidVersionSpecificationException e) {
+            throw new RuntimeException("Failed to create version range for mixinextras-forge dependency", e);
+        }
+
+        return new ContainedJarMetadata(
+            new ContainedJarIdentifier("io.github.llamalad7", "mixinextras-forge"),
+            new ContainedVersion(range, null),
+            null, false
+        );
+    }
 
     @Override
     public String name() {
         return "JarInJar";
     }
 
+    private int fsID = 0;
+    private synchronized int nextId() {
+        return fsID++;
+    }
+
     @Override
     public List<IModFile> scanMods(Iterable<IModFile> loadedMods) {
-        final List<IModFile> sources = new ArrayList<>();
-        loadedMods.forEach(sources::add);
+        var mods = new ArrayList<IModFile>();
+        loadedMods.forEach(mods::add);
 
-        var dependenciesToLoad = JarSelector.detectAndSelect(
-            sources,
-            this::loadResourceFromModFile,
-            this::loadModFileFrom,
-            this::identifyMod,
-            this::exception
-        );
+        var selector = new Selector(mods);
 
-        if (dependenciesToLoad.isEmpty()) {
+        // Add a synthetic Mixin-Extras dependency if we detect anyone using Mixin
+        if (anyMixinsLoaded(mods)) {
+            if (!selector.isRequired(MIXIN_EXTRAS_DEPENDENCY.identifier()))
+                selector.addRequirement(MIXIN_EXTRAS_DEPENDENCY);
+        } else if (selector.entries.size() == mods.size()) {
             LOGGER.info("No dependencies to load found. Skipping!");
             return Collections.emptyList();
         }
 
-        LOGGER.info("Found {} dependencies adding them to mods collection", dependenciesToLoad.size());
-        return dependenciesToLoad;
+        loadOptions();
+
+        // Ideally, the json would be in order so we only have to loop once. But its written this way just in case.
+        var seen = new HashSet<Option>();
+        var added = false;
+        do {
+            added = false;
+            for (var entry : OPTIONS.values()) {
+                if (seen.contains(entry) || !selector.isRequired(entry.meta.identifier()))
+                    continue;
+
+                seen.add(entry);
+
+                entry.addTo(selector);
+
+                if (entry.deps != null && !entry.deps.isEmpty()) {
+                    added = true;
+                    for (var dep : entry.deps)
+                        selector.addRequirement(dep);
+                }
+            }
+        } while (added);
+
+        var selected = selector.select();
+
+        if (LOGGER.isDebugEnabled()) {
+            var ids = new TreeMap<String, List<Entry>>();
+            for (var entry : selector.entries.values()) {
+                if (entry != FAILED && entry.coord != null)
+                    ids.computeIfAbsent(entry.coord, id -> new ArrayList<>()).add(entry);
+            }
+
+            for (var entry : ids.entrySet()) {
+                LOGGER.info(MARKER, "JarJar Candidated for {}", entry.getKey());
+                Collections.sort(entry.getValue());
+                for (var option : entry.getValue())
+                    LOGGER.info(MARKER, "\t{}{}", selected.contains(option) ? '*' : ' ', option);
+            }
+        }
+
+        if (selected.isEmpty()) {
+            LOGGER.info("No dependencies to load found. Skipping!");
+            return Collections.emptyList();
+        }
+
+        /* Since Java 11, the JRE decompresses all zip files to memory when getting a ByteChannel for them.
+         * JarJar only targets Minecraft 1.18+ which is Java17+ Which means we can exploit the fact that
+         * these are Disjointed file systems, and close all unselected libraries.
+         *
+         * https://github.com/openjdk/jdk11u/blob/25a9b9e5594e88c9e1e66f95c7ca45d5a9da8854/src/jdk.zipfs/share/classes/jdk/nio/zipfs/ZipFileSystem.java#L703
+         *
+         * Combined with the fact that the JarJarFileSystem has always simply called into FileSystems.newFileSystem for its wrapped targets.
+         * https://github.com/MinecraftForge/JarJar/blame/b39b2051439c81519d826d38898778bf3081356f/src/main/java/net/minecraftforge/jarjar/nio/pathfs/PathFileSystem.java#L38
+         *
+         * This effectively means that JarJar has ALWAYS been a wrapper around in-memory copies of every jar it scans.
+         *
+         * It also never closes these FileSystems, which potentially means they are leaked if the GC can't inherently GC them.
+         *
+         * Ideally we would extract these contained jars to a temp folder, so that we can use the nice optimizations Java has for ZipFile/JarFile.
+         * But in order to do that we would need to write the file to a place that could potentially have conflicts.
+         * To resolve those conflicts we should take a hint out of maven/gradle/minecraft's book and key the filepath based on a hash of the file being extracted.
+         * However, because that hash is no available in existing metadata we would need to re-calculate it.
+         *
+         * To do it in an efficient way we I needed to be able to share the single opened FileSystem with both the SecureJar implementation, and with our recursive search.
+         * So I use my new ReadOnlyInMemoryFileSystem which is specifically designed to use the same backing array for the JarInJar search as it does with the resulting dependency
+         * selected SecureJars.
+         *
+         * This means that if we wanted to we could rather efficiently calculate a hash for extracting the file. However, it also means that we don't have to extract to file to
+         * support ZipFileSystem caching properly. So as long as we are okay with not using the JRE's optimized ZipFile implementation, or we want to support legacy JarInJar metadata,
+         * using this efficient in memory file system is the best option performance wise. Extracting the files during launch without an efficient caching/unique identifier system
+         * would incur a lot of Disc IO which can be super slow depending on your setup.
+         *
+         * So, it is a stated goal of our future re-write to extract files into a cache directory to gain the benefits of JRE optimizations, using a FileSystem much simpler then
+         * the existing JarInJarFileSystem is good enough.
+         */
+
+        // Lets close all unselected FileSystems
+        var wasSelected = new HashSet<>(selected);
+        for (var entry : selector.entries.values())
+            entry.cleanup(wasSelected.contains(entry));
+
+        LOGGER.info(MARKER, "Found {} dependencies adding them to mods collection", selected.size());
+        var ret = new ArrayList<IModFile>(selected.size());
+
+        // Now lets build the actual mod files
+        for (var entry : selected) {
+            try {
+                var root = entry.getFinalPath();
+                var mod = createMod(root, false, entry.type.name());
+
+                if (mod.ex() != null)
+                    throw fail("Failed to load JarInJar file " + entry, mod.ex());
+
+                ret.add(mod.file());
+            } catch (EarlyLoadingException e) {
+                throw e;
+            } catch (Throwable e) {
+                throw fail("Failed to load JarInJar file " + entry, e);
+            }
+        }
+
+        return ret;
+    }
+
+    private static Boolean anyMixinsLoaded = null;
+    private static boolean anyMixinsLoaded(List<IModFile> mods) {
+        var ret = anyMixinsLoaded;
+        if (ret != null) return ret;
+
+        if (!FMLEnvironment.production
+                && Launcher.INSTANCE.blackboard().get(TypesafeMap.Key.getOrCreate(Launcher.INSTANCE.blackboard(), "isMixinEnabledInDev", Boolean.class)).orElse(false)) {
+            anyMixinsLoaded = true;
+            return true;
+        }
+
+        for (var mod : mods) {
+            var attributes = mod.getSecureJar().moduleDataProvider().getManifest().getMainAttributes();
+            if (attributes.getValue(MIXIN_CONFIGS_ATTR) != null || attributes.getValue(MIXIN_CONNECTOR_ATTR) != null) {
+                anyMixinsLoaded = true;
+                return true;
+            }
+        }
+
+        anyMixinsLoaded = false;
+        return false;
+    }
+
+    private record Options(List<OptionMetadata> options) {}
+    private record OptionMetadata(String resource, Type layer, String id, List<ContainedJarMetadata> deps, ContainedJarMetadata meta, boolean nested) {}
+
+    private static void loadOptions() {
+        if (optionsLoaded)
+            return;
+
+        synchronized (OPTIONS) {
+            if (optionsLoaded)
+                return;
+
+            optionsLoaded = true;
+
+            var self = JarInJarDependencyLocator.class;
+
+            try (var stream = self.getModule().getResourceAsStream("/jarjar_options.json")) {
+                if (stream == null) {
+                    LOGGER.error(MARKER, "Failed to find jarjar_options.json");
+                    return;
+                }
+
+                var meta = MetadataIOHandler.getGson().fromJson(new InputStreamReader(stream), Options.class);
+                //var meta = MetadataIOHandler.fromStream(stream).orElse(null);
+                if (meta == null) {
+                    LOGGER.error(MARKER, "Corrupted jarjar_options.json");
+                    return;
+                }
+
+                for (var jar : meta.options()) {
+                    Path path = ClasspathLocator.getPathFromResource(self.getClassLoader(), jar.resource());
+                    if (path == null) {
+                        LOGGER.error(MARKER, "Failed to find JarJar option for {}", jar.resource());
+                        continue;
+                    }
+
+                    LOGGER.debug(MARKER, "Found JarJar Option: {}", path.toAbsolutePath());
+                    if (jar.nested())
+                        OPTIONS.put(path, new NestedOption(jar.id(), path, jar.layer(), jar.meta(), jar.deps()));
+                    else
+                        OPTIONS.put(path, new Option(jar.id(), path, jar.layer(), jar.meta(), jar.deps()));
+                }
+            } catch (Throwable e) {
+                LOGGER.error(MARKER, "Failed to read JarJar Options file", e);
+            }
+        }
+    }
+
+    static boolean isOption(Path path) {
+        loadOptions();
+        return OPTIONS.containsKey(path);
+    }
+
+    private static EarlyLoadingException fail(String message, @Nullable Throwable cause) {
+        LOGGER.error(MARKER, message);
+        return new EarlyLoadingException(message, cause, Collections.emptyList());
     }
 
     @Override
@@ -76,89 +305,7 @@ public class JarInJarDependencyLocator extends AbstractModProvider implements ID
         return IModFile.Type.GAMELIBRARY.name();
     }
 
-    protected Optional<IModFile> loadModFileFrom(IModFile file, Path path) {
-        try {
-            final Path pathInModFile = file.findResource(path.toString());
-            final URI filePathUri = new URI("jij:" + (pathInModFile.toAbsolutePath().toUri().getRawSchemeSpecificPart())).normalize();
-            final Map<String, ?> outerFsArgs = ImmutableMap.of("packagePath", pathInModFile);
-            final FileSystem zipFS = FileSystems.newFileSystem(filePathUri, outerFsArgs);
-            final Path pathInFS = zipFS.getPath("/");
-            final IModFile.Type parentType = file.getType();
-            final String modType;
-            if (parentType == IModFile.Type.LIBRARY || parentType == IModFile.Type.LANGPROVIDER) {
-                modType = IModFile.Type.LIBRARY.name();
-            } else {
-                modType = IModFile.Type.GAMELIBRARY.name();
-            }
-            return Optional.of(createMod(pathInFS, false, modType).file());
-        } catch (Exception e) {
-            LOGGER.error("Failed to load mod file {} from {}", path, file.getFileName());
-            final RuntimeException exception = new ModFileLoadingException("Failed to load mod file " + file.getFileName());
-            exception.initCause(e);
-            throw exception;
-        }
-    }
-
-    protected EarlyLoadingException exception(Collection<JarSelector.ResolutionFailureInformation<IModFile>> failedDependencies) {
-        final List<EarlyLoadingException.ExceptionData> errors = failedDependencies.stream()
-               .filter(entry -> !entry.sources().isEmpty()) //Should never be the case, but just to be sure
-               .map(JarInJarDependencyLocator::buildExceptionData)
-               .toList();
-
-        return new EarlyLoadingException(failedDependencies.size() + " Dependency restrictions were not met.", null, errors);
-    }
-
-    @NotNull
-    private static EarlyLoadingException.ExceptionData buildExceptionData(JarSelector.ResolutionFailureInformation<IModFile> entry) {
-        return new EarlyLoadingException.ExceptionData(
-                getErrorTranslationKey(entry),
-                entry.identifier().group() + ":" + entry.identifier().artifact(),
-                entry.sources()
-                     .stream()
-                     .flatMap(JarInJarDependencyLocator::getModWithVersionRangeStream)
-                     .map(JarInJarDependencyLocator::formatError)
-                     .collect(Collectors.joining(", "))
-        );
-    }
-
-    @NotNull
-    private static String getErrorTranslationKey(JarSelector.ResolutionFailureInformation<IModFile> entry) {
-        return entry.failureReason() == JarSelector.FailureReason.VERSION_RESOLUTION_FAILED ?
-                       "fml.dependencyloading.conflictingdependencies" :
-                       "fml.dependencyloading.mismatchedcontaineddependencies";
-    }
-
-    @NotNull
-    private static Stream<ModWithVersionRange> getModWithVersionRangeStream(JarSelector.SourceWithRequestedVersionRange<IModFile> file) {
-        return file.sources()
-                   .stream()
-                   .map(IModFile::getModFileInfo)
-                   .flatMap(modFileInfo -> modFileInfo.getMods().stream())
-                   .map(modInfo -> new ModWithVersionRange(modInfo, file.requestedVersionRange(), file.includedVersion()));
-    }
-
-    protected Optional<InputStream> loadResourceFromModFile(IModFile modFile, Path path) {
-        try {
-            var pathInModFile = modFile.findResource(path.toString());
-            if (!Files.exists(pathInModFile)) {
-                LOGGER.debug("Failed to load resource {} from {}, it does not contain dependency information.", path, modFile.getFileName());
-                return Optional.empty();
-            }
-            return Optional.of(Files.newInputStream(pathInModFile));
-        } catch (Exception e) {
-            LOGGER.error("Failed to load resource {} from mod {}, cause {}", path, modFile.getFileName(), e);
-            return Optional.empty();
-        }
-    }
-
-    @NotNull
-    private static String formatError(ModWithVersionRange modWithVersionRange){
-        return YELLOW + modWithVersionRange.modInfo().getModId() + RESET + " - " +
-               RED + modWithVersionRange.versionRange().toString() + RESET + " - " +
-               GREEN + modWithVersionRange.artifactVersion().toString() + RESET;
-    }
-
-    protected String identifyMod(IModFile modFile) {
+    protected static String identifyMod(IModFile modFile) {
         if (modFile.getModFileInfo() != null && !modFile.getModInfos().isEmpty())
             return modFile.getModInfos().stream().map(IModInfo::getModId).collect(Collectors.joining());
 
@@ -169,5 +316,377 @@ public class JarInJarDependencyLocator extends AbstractModProvider implements ID
         return modFile.getFileName();
     }
 
-    private record ModWithVersionRange(IModInfo modInfo, VersionRange versionRange, ArtifactVersion artifactVersion) {}
+    private static final Entry FAILED = new Entry("FAILED ENTRY", Path.of(""), Type.LIBRARY, null);
+    private static sealed class Entry implements Comparable<Entry> {
+        final String id;
+        final Path path;
+        final Type type;
+        final @Nullable String coord;
+
+        private Entry(String id, Path path, Type type, @Nullable String coord) {
+            this.id = id;
+            this.path = path;
+            this.type = type;
+            this.coord = coord;
+        }
+
+        Path getFinalPath() {
+            return path;
+        }
+
+        void cleanup(boolean selected) {
+        }
+
+        @Override
+        public String toString() {
+            if (path.getFileName() == null)
+                return path.toUri().toString();
+            return path.getFileName().toString();
+        }
+
+        @Nullable
+        Path getResource(String path) {
+            return null;
+        }
+
+        @Override
+        public int compareTo(Entry o) {
+            return o.toString().compareTo(toString());
+        }
+    }
+
+    private static final class ModEntry extends Entry {
+        private final IModFile mod;
+
+        ModEntry(IModFile mod) {
+            super(identifyMod(mod), mod.getFilePath(), mod.getType(), null);
+            this.mod = mod;
+        }
+
+        @Override
+        @Nullable
+        Path getResource(String path) {
+            return mod.findResource(path);
+        }
+    }
+
+    private static sealed class Option extends Entry {
+        final ContainedJarMetadata meta;
+        final List<ContainedJarMetadata> deps;
+
+        private Option(String id, Path path, Type type, ContainedJarMetadata meta, List<ContainedJarMetadata> deps) {
+            super(id, path, type, meta.identifier().group() + ':' + meta.identifier().artifact());
+            this.meta = meta;
+            this.deps = deps;
+        }
+
+        public void addTo(Selector selector) {
+            selector.option(this, meta);
+        }
+    }
+
+    private static final class NestedOption extends Option {
+        private FileSystem zip;
+        private Path root;
+
+        private NestedOption(String id, Path path, Type type, ContainedJarMetadata meta, List<ContainedJarMetadata> deps) {
+            super(id, path, type, meta, deps);
+        }
+
+        @Override
+        public void addTo(Selector selector) {
+            super.addTo(selector);
+            selector.add(this);
+        }
+
+        @Override
+        void cleanup(boolean selected) {
+            if (this.zip != null) {
+                try {
+                    zip.close();
+                } catch (IOException e) {
+                    LOGGER.error(MARKER, "Failed to close unselected FileSystem {}", this, e);
+                }
+            }
+        }
+
+        @Nullable
+        Path getResource(String path) {
+            if (zip == null) {
+                try {
+                    this.zip = FileSystems.newFileSystem(this.path);
+                    this.root = zip.getRootDirectories().iterator().next();
+                } catch (IOException e) {
+                    LOGGER.error(MARKER, "Failed to open FileSystem for option root {}", this, e);
+                    return null;
+                }
+            }
+
+            var target = root.resolve(path);
+            if (Files.exists(target))
+                return target;
+
+            return null;
+        }
+    }
+
+
+    private static final class Nested extends Entry {
+        private final Entry parent;
+        private final String nestedPath;
+        private final Path zipPath;
+
+        Nested(String id, Path path, Type type, String coords, Entry parent, String nestedPath, Path zipPath) {
+            super(id, path, type, coords);
+            this.parent = parent;
+            this.nestedPath = nestedPath;
+            this.zipPath = zipPath;
+        }
+
+        /*
+         * Due to a bug in Mixin, anything that is not on the DefaultFileSystem MUST be a directory.
+         * Or else it can't resolve resources correctly. So for anything we put on the roimfs we need
+         * to return the nested zip file system.
+         *
+         * This will be an annoying to backport, but we can cross that bridge when we come to it.
+         *
+         * See: https://github.com/SpongePowered/Mixin/blob/4053421aa10aaac6127d969028a29c94fe3054f6/src/main/java/org/spongepowered/asm/launch/platform/MainAttributes.java#L102
+         */
+        @Override
+        public Path getFinalPath() {
+            return zipPath;
+        }
+
+        @Override
+        void cleanup(boolean selected) {
+            if (selected)
+                return;
+
+            LOGGER.info(MARKER, "Closeing unselected FileSystem {}", this);
+            try {
+                zipPath.getFileSystem().close();
+                path.getFileSystem().close();
+            } catch (IOException e) {
+                LOGGER.error(MARKER, "Failed to close unselected FileSystem {}", this, e);
+            }
+        }
+
+        @Override
+        @Nullable
+        Path getResource(String path) {
+            return zipPath.resolve(path);
+        }
+
+        @Override
+        public String toString() {
+            return parent + "!/" + nestedPath;
+        }
+    }
+
+    private record Key(Entry parent, String path) {}
+
+    private final class Selector extends JarSelector<Entry> {
+        private final HashMap<Key, Entry> entries = new HashMap<>();
+        private final HashMap<Entry, HashMap<String, String>> children = new HashMap<>();
+
+        private Selector(Iterable<IModFile> mods) {
+            for (var mod : mods)
+                this.force(new ModEntry(mod));
+        }
+
+        @Override
+        public void force(Entry entry) {
+            super.force(entry);
+            entries.put(new Key(entry, ""), entry);
+        }
+
+        @Override
+        public void option(Entry entry, ContainedJarMetadata meta) {
+            super.option(entry, meta);
+            entries.put(new Key(entry, ""), entry);
+        }
+
+        @Override
+        public void add(Entry entry) {
+            super.add(entry);
+            entries.put(new Key(entry, ""), entry);
+        }
+
+        @Override
+        @Nullable
+        protected InputStream getResource(Entry source, String path) {
+            try {
+                Path target = source.getResource(path);
+                if (target == null || !Files.exists(target)) {
+                    LOGGER.debug(MARKER, "Failed to load resource {} from {}, it does not contain dependency information.", path, source);
+                    return null;
+                }
+
+                // Read the metadata file and store identifiers so we can group them later.
+                if (JarSelector.CONTAINED_JARS_METADATA_PATH.equals(path)) {
+                    try (var is = Files.newInputStream(target)) {
+                        var meta = MetadataIOHandler.fromStream(is).orElse(null);
+                        if (meta == null)
+                            return Files.newInputStream(target);
+                        var children = new HashMap<String, String>();
+                        for (var child : meta.jars())
+                            children.put(child.path().replace('\\', '/'), child.identifier().group() + ':' + child.identifier().artifact());
+                        this.children.put(source, children);
+                    }
+                }
+
+                return Files.newInputStream(target);
+            } catch (Exception e) {
+                LOGGER.error(MARKER, "Failed to load resource {} from {}, cause {}", path, source, e);
+                return null;
+            }
+        }
+
+
+        @Override
+        protected Entry getNested(Entry source, String path) {
+            var cleaned = path.replace('\\', '/');
+            var key = new Key(source, cleaned);
+            var entry = entries.get(key);
+            if (entry == null) {
+                entry = createNested(source, path, cleaned);
+                if (entry == null)
+                    entry = FAILED;
+                entries.put(key, entry);
+            }
+            return entry == FAILED ? null : entry;
+        }
+
+        private Entry createNested(Entry source, String path, String cleaned) {
+            var targetPath = source.getResource(path);
+
+            if (targetPath == null || !Files.isRegularFile(targetPath))
+                return null;
+
+            Path roimfsPath = null;
+            Path zipPath = null;
+            try {
+                // Lets copy the uncompressed file to memory, and then create a ReadOnlyInMemorryFileSystem for it, this allows us to reference it by URI.
+                // Which is needed because a lot of things require navigation via URI.
+                // And ZipFileSystem only caches the FileSystem instance when accessed via URI.
+                byte[] data = Files.readAllBytes(targetPath);
+                String filename = targetPath.getFileName().toString();
+                URI uri = new URI(ROIMFS, "jar-jar-" + nextId() + "/" + filename, null);
+                var roimfs = FileSystems.newFileSystem(uri, Collections.singletonMap("data", data));
+                roimfsPath = roimfs.getPath(filename);
+                var zip = FileSystems.newFileSystem(new URI("jar:" + roimfsPath.toUri()), Collections.emptyMap());
+                zipPath = zip.getRootDirectories().iterator().next(); // Get first root, which on ZipFileSystem is the only root
+            } catch (IOException | URISyntaxException e) {
+                LOGGER.error(MARKER, "Failed to create FileSystem for nested jar {}", source, e);
+                return null;
+            }
+
+            var mf = new Manifest();
+            var mfPath = zipPath.resolve(JarFile.MANIFEST_NAME);
+            if (Files.exists(mfPath)) {
+                try (var is = Files.newInputStream(mfPath)) {
+                    mf = new Manifest(is);
+                } catch (IOException e) {
+                    LOGGER.error(MARKER, "Failed to read manifest from {}", source, e);
+                }
+            }
+
+            IModFile.Type type = null;
+            String id = null;
+            var tomlPath = zipPath.resolve(MODS_TOML);
+            if (Files.exists(tomlPath)) {
+                var cfg = FileConfig.builder(tomlPath).build();
+                cfg.load();
+                cfg.close();
+                if (cfg.getOrElse("mods", null) instanceof Collection collection) {
+                    @SuppressWarnings("unchecked")
+                    var mods = (Collection<UnmodifiableConfig>)collection;
+                    if (!mods.isEmpty()) {
+                        var first = mods.iterator().next();
+                        var modId = first.getOrElse("modId", null);
+                        if (modId instanceof String str)
+                            id = str;
+                    }
+                }
+                var value = mf.getMainAttributes().getValue(ModFile.TYPE);
+                if (value != null)
+                    type = IModFile.Type.valueOf(value);
+                else
+                    type = IModFile.Type.MOD;
+            } else {
+                var value = mf.getMainAttributes().getValue(ModFile.TYPE);
+                if (value != null)
+                    type = IModFile.Type.valueOf(value);
+                else {
+                    // No mods.toml, no entry value, so decide based on the container's type
+                    if (source.type == IModFile.Type.LIBRARY || source.type == IModFile.Type.LANGPROVIDER)
+                        type = IModFile.Type.LIBRARY;
+                    else
+                        type = IModFile.Type.GAMELIBRARY;
+                }
+            }
+
+            if (id == null) {
+                var modulePath = zipPath.resolve(MODULE_INFO);
+                if (Files.exists(modulePath)) {
+                    try (var is = Files.newInputStream(modulePath)) {
+                        var module = ModuleDescriptor.read(is);
+                        id = module.name();
+                    } catch (IOException e) {
+                        LOGGER.error(MARKER, "Failed to read module-info.class from {}", source, e);
+                    }
+                }
+            }
+
+            if (id == null)
+                id = mf.getMainAttributes().getValue("Automatic-Module-Name");
+
+            if (id == null)
+                id = Path.of(path).getFileName().toString();
+
+            String coords = null;
+            var child = this.children.get(source);
+            if (child != null)
+                coords = child.get(cleaned);
+
+            return new Nested(id, roimfsPath, type, coords, source, cleaned, zipPath);
+        }
+
+        @Override
+        protected String getIdentifier(Entry entry) {
+            return entry.id;
+        }
+
+        @Override
+        protected Throwable getFailureException(Collection<ResolutionFailureInformation<Entry>> failures) {
+            var errors = new ArrayList<ExceptionData>();
+            for (var failure : failures) {
+                var message = failure.failureReason() == JarSelector.FailureReason.VERSION_RESOLUTION_FAILED ? "fml.dependencyloading.conflictingdependencies" : "fml.dependencyloading.mismatchedcontaineddependencies";
+                var joiner = new StringJoiner(", ");
+                for (var source : failure.sources()) {
+                    String paths = null;
+                    if (source.sources().size() == 0) {
+                        paths = "[No Sources]";
+                    } else if (source.sources().size() == 1) {
+                        var entry = source.sources().iterator().next();
+                        paths = entry.toString();
+                    } else {
+                        var j = new StringJoiner(", ", "[", "]");
+                        for (var entry : source.sources())
+                            j.add(entry.toString());
+                        paths = j.toString();
+                    }
+
+                    var error = YELLOW + paths + RESET + " - " +
+                                RED + source.requestedVersionRange() + RESET + " - " +
+                                GREEN + source.includedVersion() + RESET;
+                    joiner.add(error);
+                }
+
+                errors.add(new ExceptionData(message, failure.identifier().group() + ":" + failure.identifier().artifact(), joiner.toString()));
+            }
+
+            return new EarlyLoadingException(failures.size() + " Dependency restrictions were not met.", null, errors);
+        }
+    }
 }

fmlloader/src/main/java/net/minecraftforge/fml/loading/moddiscovery/MinecraftLocator.java

@@ -14,6 +14,7 @@ import net.minecraftforge.forgespi.locating.IModLocator;
 import net.minecraftforge.forgespi.locating.ModFileFactory;
 import java.nio.file.Path;
 import java.util.List;
+import java.util.function.Consumer;
 
 import org.jetbrains.annotations.ApiStatus;
 
@@ -57,4 +58,9 @@ public final class MinecraftLocator extends AbstractModProvider implements IModL
     public String name() {
         return "minecraft";
     }
+
+    @Override
+    public void scanFile(IModFile file, Consumer<Path> pathConsumer) {
+        // skip annotation scanning for MC itself
+    }
 }

fmlloader/src/main/java/net/minecraftforge/fml/loading/moddiscovery/ModAnnotation.java

@@ -19,7 +19,7 @@ import org.objectweb.asm.Type;
 import com.google.common.base.MoreObjects;
 
 @ApiStatus.Internal
-class ModAnnotation {
+final class ModAnnotation {
     public static ModFileScanData.AnnotationData fromModAnnotation(Type clazz, ModAnnotation annotation) {
         return new ModFileScanData.AnnotationData(annotation.asmType, annotation.type, clazz, annotation.member, annotation.values);
     }
@@ -84,6 +84,7 @@ class ModAnnotation {
     }
 
     public void endArray() {
+        arrayList.trimToSize();
         values.put(arrayName, arrayList);
         arrayList = null;
     }

fmlloader/src/main/java/net/minecraftforge/fml/loading/moddiscovery/ModClassVisitor.java

@@ -22,7 +22,47 @@ import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 @ApiStatus.Internal
-class ModClassVisitor extends ClassVisitor {
+final class ModClassVisitor extends ClassVisitor {
+    private static final Set<String> ANNOTATION_BLACKLIST;
+
+    private static final Type OBJECT_TYPE = Type.getObjectType("java/lang/Object");
+    private static final Type RECORD_TYPE = Type.getObjectType("java/lang/Record");
+
+    static {
+        var customBlacklist = System.getProperty("forge.annotationScanningBlacklist");
+        if (customBlacklist != null) {
+            ANNOTATION_BLACKLIST = Set.of(customBlacklist.split(","));
+        } else {
+            ANNOTATION_BLACKLIST = Set.of(
+                    "Ljava/lang/Deprecated;",
+                    "Ljava/lang/FunctionalInterface;",
+                    "Ljava/lang/SafeVarargs;",
+
+                    "Ljava/lang/annotation/Retention;",
+                    "Ljava/lang/annotation/Target;",
+
+                    "Ljavax/annotation/Nullable;",
+
+                    "Lorg/jspecify/nullness/NonNull;",
+                    "Lorg/jspecify/nullness/Nullable;",
+                    "Lorg/jspecify/annotations/NullMarked;",
+                    "Lorg/jspecify/annotations/NullUnmarked;",
+
+                    "Lorg/jetbrains/annotations/ApiStatus$Internal;",
+                    "Lorg/jetbrains/annotations/Contract;",
+                    "Lorg/jetbrains/annotations/Nullable;",
+                    "Lorg/jetbrains/annotations/NotNull;",
+                    "Lorg/jetbrains/annotations/VisibleForTesting;",
+
+                    "Lcom/google/common/annotations/VisibleForTesting;",
+
+                    "Lnet/minecraftforge/api/distmarker/OnlyIn", // should not be used by mods
+                    // @Mod.EventBusSubscriber doesn't use scan data for finding @SubscribeEvent annotated methods
+                    "Lnet/minecraftforge/eventbus/api/listener/SubscribeEvent;"
+            );
+        }
+    }
+
     private Type asmType;
     private Type asmSuperType;
     private Set<Type> interfaces;
@@ -35,12 +75,17 @@ class ModClassVisitor extends ClassVisitor {
     @Override
     public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
         this.asmType = Type.getObjectType(name);
-        this.asmSuperType = superName != null && !superName.isEmpty() ? Type.getObjectType(superName) : null;
+        this.asmSuperType = superName != null && !superName.isEmpty() ? switch (superName) {
+            case "java/lang/Object" -> OBJECT_TYPE;
+            case "java/lang/Record" -> RECORD_TYPE;
+            default -> Type.getObjectType(superName);
+        } : null;
         this.interfaces = Stream.of(interfaces).map(Type::getObjectType).collect(Collectors.toSet());
     }
 
     @Override
     public AnnotationVisitor visitAnnotation(final String annotationName, final boolean runtimeVisible) {
+        if (ANNOTATION_BLACKLIST.contains(annotationName)) return null;
         var ann = new ModAnnotation(ElementType.TYPE, Type.getType(annotationName), this.asmType.getClassName());
         annotations.addFirst(ann);
         return new ModAnnotationVisitor(ann);
@@ -51,6 +96,7 @@ class ModClassVisitor extends ClassVisitor {
         return new FieldVisitor(Opcodes.ASM9) {
             @Override
             public AnnotationVisitor visitAnnotation(String annotationName, boolean runtimeVisible) {
+                if (ANNOTATION_BLACKLIST.contains(annotationName)) return null;
                 var ann = new ModAnnotation(ElementType.FIELD, Type.getType(annotationName), name);
                 annotations.addFirst(ann);
                 return new ModAnnotationVisitor(ann);
@@ -63,6 +109,7 @@ class ModClassVisitor extends ClassVisitor {
         return new MethodVisitor(Opcodes.ASM9) {
             @Override
             public AnnotationVisitor visitAnnotation(String annotationName, boolean runtimeVisible) {
+                if (ANNOTATION_BLACKLIST.contains(annotationName)) return null;
                 ModAnnotation ann = new ModAnnotation(ElementType.METHOD, Type.getType(annotationName), name + desc);
                 annotations.addFirst(ann);
                 return new ModAnnotationVisitor(ann);
@@ -78,7 +125,7 @@ class ModClassVisitor extends ClassVisitor {
         }
     }
 
-    private class ModAnnotationVisitor extends AnnotationVisitor {
+    private final class ModAnnotationVisitor extends AnnotationVisitor {
         private final ModAnnotation annotation;
         private boolean array;
         private boolean isSubAnnotation;

fmlloader/src/main/java/net/minecraftforge/fml/loading/moddiscovery/ModDiscoverer.java

@@ -5,7 +5,6 @@
 
 package net.minecraftforge.fml.loading.moddiscovery;
 
-import com.google.common.collect.ImmutableList;
 import com.mojang.logging.LogUtils;
 import cpw.mods.modlauncher.Launcher;
 import cpw.mods.modlauncher.api.IModuleLayerManager;
@@ -35,41 +34,37 @@ import java.util.ServiceLoader;
 import java.util.stream.Collectors;
 
 @ApiStatus.Internal
-public class ModDiscoverer {
-    private static final Logger LOGGER = LogUtils.getLogger();
-    private final ServiceLoader<IModLocator> modLocators;
-    private final ServiceLoader<IDependencyLocator> dependencyLocators;
-    private final List<IModLocator>          modLocatorList;
-    private final List<IDependencyLocator>   dependencyLocatorList;
+public final class ModDiscoverer {
+    private ModDiscoverer() {}
 
-    public ModDiscoverer(Map<String, ?> arguments) {
-        Launcher.INSTANCE.environment().computePropertyIfAbsent(Environment.Keys.MODDIRECTORYFACTORY.get(), v->ModsFolderLocator::new);
-        Launcher.INSTANCE.environment().computePropertyIfAbsent(Environment.Keys.PROGRESSMESSAGE.get(), v-> StartupNotificationManager.locatorConsumer().orElseGet(()-> s->{}));
-        final var moduleLayerManager = Launcher.INSTANCE.environment().findModuleLayerManager().orElseThrow();
-        modLocators = ServiceLoader.load(moduleLayerManager.getLayer(IModuleLayerManager.Layer.SERVICE).orElseThrow(), IModLocator.class);
-        dependencyLocators = ServiceLoader.load(moduleLayerManager.getLayer(IModuleLayerManager.Layer.SERVICE).orElseThrow(), IDependencyLocator.class);
-        modLocatorList = ServiceLoaderUtils.streamServiceLoader(()-> modLocators, sce->LOGGER.error("Failed to load mod locator list", sce)).collect(Collectors.toList());
+    private static final Logger LOGGER = LogUtils.getLogger();
+
+    @SuppressWarnings("removal")
+    public static ModValidator discoverMods(Map<String, ?> arguments) {
+        var env = Launcher.INSTANCE.environment();
+        env.computePropertyIfAbsent(Environment.Keys.MODDIRECTORYFACTORY.get(), _ -> ModsFolderLocator::new);
+        env.computePropertyIfAbsent(Environment.Keys.PROGRESSMESSAGE.get(), _ -> StartupNotificationManager.locatorConsumer().orElse(_ -> {}));
+        final var moduleLayerManager = env.findModuleLayerManager().orElseThrow();
+        ServiceLoader<IModLocator> modLocators = ServiceLoader.load(moduleLayerManager.getLayer(IModuleLayerManager.Layer.SERVICE).orElseThrow(), IModLocator.class);
+        ServiceLoader<IDependencyLocator> dependencyLocators = ServiceLoader.load(moduleLayerManager.getLayer(IModuleLayerManager.Layer.SERVICE).orElseThrow(), IDependencyLocator.class);
+        List<IModLocator> modLocatorList = ServiceLoaderUtils.streamWithErrorHandling(modLocators, sce -> LOGGER.error("Failed to load mod locator list", sce)).toList();
         for (IModLocator iModLocator : modLocatorList) {
             iModLocator.initArguments(arguments);
         }
-        dependencyLocatorList = ServiceLoaderUtils.streamServiceLoader(()-> dependencyLocators, sce->LOGGER.error("Failed to load dependency locator list", sce)).collect(Collectors.toList());
+        List<IDependencyLocator> dependencyLocatorList = ServiceLoaderUtils.streamWithErrorHandling(dependencyLocators, sce -> LOGGER.error("Failed to load dependency locator list", sce)).toList();
         for (IDependencyLocator l : dependencyLocatorList) {
             l.initArguments(arguments);
         }
-        if (LOGGER.isDebugEnabled(LogMarkers.CORE))
-        {
+        if (LOGGER.isDebugEnabled(LogMarkers.CORE)) {
             LOGGER.debug(LogMarkers.CORE, "Found Mod Locators : {}", modLocatorList.stream()
-                                                                       .map(modLocator -> "(%s:%s)".formatted(modLocator.name(),
-                                                                         modLocator.getClass().getPackage().getImplementationVersion())).collect(Collectors.joining(",")));
+                    .map(modLocator -> "(%s:%s)".formatted(modLocator.name(),
+                            modLocator.getClass().getPackage().getImplementationVersion())).collect(Collectors.joining(",")));
 
             LOGGER.debug(LogMarkers.CORE, "Found Dependency Locators : {}", dependencyLocatorList.stream()
-                                                                       .map(dependencyLocator -> "(%s:%s)".formatted(dependencyLocator.name(),
-                                                                         dependencyLocator.getClass().getPackage().getImplementationVersion())).collect(Collectors.joining(",")));
+                    .map(dependencyLocator -> "(%s:%s)".formatted(dependencyLocator.name(),
+                            dependencyLocator.getClass().getPackage().getImplementationVersion())).collect(Collectors.joining(",")));
         }
-    }
 
-    @SuppressWarnings("removal")
-    public ModValidator discoverMods() {
         LOGGER.debug(LogMarkers.SCAN,"Scanning for mods and other resources to load. We know {} ways to find mods", modLocatorList.size());
         List<ModFile> loadedFiles = new ArrayList<>();
         List<EarlyLoadingException.ExceptionData> discoveryErrorData = new ArrayList<>();
@@ -117,7 +112,7 @@ public class ModDiscoverer {
                 }
 
                 LOGGER.debug(LogMarkers.SCAN, "Locator {} found {} valid mod files", locator, locatedFiles.size());
-                handleLocatedFiles(loadedFiles, locatedFiles);
+                handleLocatedFiles(loadedFiles, locatedFiles, locator);
             } catch (InvalidModFileException imfe) {
                 // We don't generally expect this exception, since it should come from the candidates stream above and be handled in the Locator, but just in case.
                 LOGGER.error(LogMarkers.SCAN, "Locator {} found an invalid mod file {}", locator, imfe.getBrokenFile(), imfe);
@@ -131,8 +126,7 @@ public class ModDiscoverer {
         //First processing run of the mod list. Any duplicates will cause resolution failure and dependency loading will be skipped.
         Map<IModFile.Type, List<ModFile>> modFilesMap = new EnumMap<>(IModFile.Type.class);
         try {
-            final UniqueModListBuilder modsUniqueListBuilder = new UniqueModListBuilder(loadedFiles);
-            final UniqueModListBuilder.UniqueModListData uniqueModsData = modsUniqueListBuilder.buildUniqueList();
+            final UniqueModListBuilder.UniqueModListData uniqueModsData = UniqueModListBuilder.buildUniqueList(loadedFiles);
 
             //Grab the temporary results.
             //This allows loading to continue to a base state, in case dependency loading fails.
@@ -152,14 +146,10 @@ public class ModDiscoverer {
             for (IDependencyLocator locator : dependencyLocatorList) {
                 try {
                     LOGGER.debug(LogMarkers.SCAN,"Trying locator {}", locator);
-                    final List<IModFile> locatedMods = ImmutableList.copyOf(loadedFiles);
+                    final List<IModFile> locatedMods = List.copyOf(loadedFiles);
 
                     var locatedFiles = locator.scanMods(locatedMods);
-                    if (locatedFiles.stream().anyMatch(file -> !(file instanceof ModFile))) {
-                        LOGGER.error(LogMarkers.SCAN, "A dependency locator returned a file which is not a ModFile instance!. They will be skipped!");
-                    }
-
-                    handleLocatedFiles(loadedFiles, locatedFiles);
+                    handleLocatedFiles(loadedFiles, locatedFiles, locator);
                 }
                 catch (EarlyLoadingException exception) {
                     LOGGER.error(LogMarkers.SCAN, "Failed to load dependencies with locator {}", locator, exception);
@@ -169,8 +159,7 @@ public class ModDiscoverer {
 
             //Second processing run of the mod list. Any duplicates will cause resolution failure and only the mods list will be loaded.
             try {
-                final UniqueModListBuilder modsAndDependenciesUniqueListBuilder = new UniqueModListBuilder(loadedFiles);
-                final UniqueModListBuilder.UniqueModListData uniqueModsAndDependenciesData = modsAndDependenciesUniqueListBuilder.buildUniqueList();
+                final UniqueModListBuilder.UniqueModListData uniqueModsAndDependenciesData = UniqueModListBuilder.buildUniqueList(loadedFiles);
 
                 //We now only need the mod files map, not the list.
                 modFilesMap = uniqueModsAndDependenciesData.modFiles().stream()
@@ -193,11 +182,14 @@ public class ModDiscoverer {
         return validator;
     }
 
-    private static void handleLocatedFiles(final List<ModFile> loadedFiles, final List<IModFile> locatedFiles) {
-        var locatedModFiles = locatedFiles.stream().filter(ModFile.class::isInstance).map(ModFile.class::cast).toList();
-        for (IModFile mf : locatedModFiles) {
-            LOGGER.info(LogMarkers.SCAN, "Found mod file {} of type {} with provider {}", mf.getFileName(), mf.getType(), mf.getProvider());
+    private static void handleLocatedFiles(final List<ModFile> loadedFiles, final List<IModFile> locatedFiles, final Object locator) {
+        for (IModFile mf : locatedFiles) {
+            if (mf instanceof ModFile modFile) {
+                LOGGER.info(LogMarkers.SCAN, "Found mod file {} of type {} with provider {}", mf.getFileName(), mf.getType(), mf.getProvider());
+                loadedFiles.add(modFile);
+            } else {
+                LOGGER.error(LogMarkers.SCAN, "Skipping mod file {} found by {}, as it was not a ModFile instance!", mf.getFileName(), locator);
+            }
         }
-        loadedFiles.addAll(locatedModFiles);
     }
 }

fmlloader/src/main/java/net/minecraftforge/fml/loading/moddiscovery/ModFile.java

@@ -9,6 +9,7 @@ import com.google.common.collect.ImmutableMap;
 import com.mojang.logging.LogUtils;
 import cpw.mods.jarhandling.SecureJar;
 import net.minecraftforge.fml.loading.FMLLoader;
+import net.minecraftforge.fml.loading.LanguageLoadingProvider;
 import net.minecraftforge.fml.loading.LogMarkers;
 import net.minecraftforge.forgespi.language.IModFileInfo;
 import net.minecraftforge.forgespi.language.IModInfo;
@@ -21,13 +22,13 @@ import org.apache.maven.artifact.versioning.ArtifactVersion;
 import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
 import org.slf4j.Logger;
 
+import java.nio.file.FileSystems;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
@@ -48,8 +49,7 @@ public class ModFile implements IModFile {
     private final IModFileInfo modFileInfo;
     private ModFileScanData fileModFileScanData;
     private CompletableFuture<ModFileScanData> futureScanResult;
-    private List<CoreModFile> coreMods;
-    private Path accessTransformer;
+    private List<Path> accessTransformers = List.of();
 
     static final Attributes.Name TYPE = new Attributes.Name("FMLModType");
     private SecureJar.Status securityStatus;
@@ -92,24 +92,30 @@ public class ModFile implements IModFile {
         return modFileInfo.getMods();
     }
 
-    public Optional<Path> getAccessTransformer() {
-        return Optional.ofNullable(Files.exists(accessTransformer) ? accessTransformer : null);
+    public List<Path> getAccessTransformers() {
+        return this.accessTransformers;
     }
 
     public boolean identifyMods() {
         if (this.modFileInfo == null) return this.getType() != Type.MOD;
-        LOGGER.debug(LogMarkers.LOADING,"Loading mod file {} with languages {}", this.getFilePath(), this.modFileInfo.requiredLanguageLoaders());
-        this.coreMods = ModFileParser.getCoreMods(this);
-        if (!this.coreMods.isEmpty())
-            LOGGER.warn("Mod file {} contains javascript coremods! JS CoreMods are deprecated and will be removed in a future release. Consider using Mixin or ModLauncher transformers.", this.getFileName());
-        for (var mi : this.coreMods)
-            LOGGER.debug(LogMarkers.LOADING, "Found coremod {}", mi.getPath());
-        this.accessTransformer = findResource("META-INF", "accesstransformer.cfg");
-        return true;
-    }
+        LOGGER.debug(LogMarkers.LOADING,"Loading mod file {} with languages {}", this.getFileName(), this.modFileInfo.requiredLanguageLoaders());
+        var cfg = this.modFileInfo.getConfig()
+            .<List<String>>getConfigElement("accessTransformers")
+            .orElse(null);
 
-    public List<CoreModFile> getCoreMods() {
-        return coreMods;
+        if (cfg == null) {
+            var path = findResource("META-INF", "accesstransformer.cfg");
+            if (Files.exists(path)) {
+                this.accessTransformers = List.of(path);
+            }
+        } else if (!cfg.isEmpty()) {
+            var paths = new ArrayList<Path>(cfg.size());
+            for (var path : cfg)
+                paths.add(getSecureJar().getPath(path.replace('\\', '/')));
+            this.accessTransformers = List.copyOf(paths);
+        }
+
+        return true;
     }
 
     /**
@@ -169,22 +175,37 @@ public class ModFile implements IModFile {
 
     public void identifyLanguage() {
         var lst = new ArrayList<IModLanguageProvider>(this.modFileInfo.requiredLanguageLoaders().size());
-        var services = FMLLoader.getLanguageLoadingProvider();
         for (var spec : this.modFileInfo.requiredLanguageLoaders()) {
-            var service = services.findLanguage(this, spec.languageName(), spec.acceptedVersions());
+            var service = LanguageLoadingProvider.findLanguage(this, spec.languageName(), spec.acceptedVersions());
             lst.add(service);
         }
-        this.loaders = Collections.unmodifiableList(lst);
+        this.loaders = List.copyOf(lst);
     }
 
     @Override
     public String toString() {
-        return "Mod File: " + Objects.toString(this.jar.getPrimaryPath());
+        var path = getFilePath();
+        return "Mod File: " + path == null ? "null" : path.toUri().toString();
     }
 
     @Override
     public String getFileName() {
-        return getFilePath().getFileName().toString();
+        // This is only used for debugging, so lets try and make it a useful debug
+        var path = getFilePath();
+        var filename = path.getFileName();
+
+        // ZipFileSystem toString will return the outer file path
+        var ret = filename == null ? path.getFileSystem().toString() : filename.toString();
+
+        // If it's a directory on the default file system, return the full path
+        if (Files.isDirectory(path) && path.getFileSystem() == FileSystems.getDefault())
+            ret = path.toAbsolutePath().toString();
+
+        // If we are in a FileSystem 'root' like UnionFS, return the full uri
+        if (ret.isEmpty() || ret.equals("/"))
+            ret = path.toUri().toString();
+
+        return ret;
     }
 
     @Override

fmlloader/src/main/java/net/minecraftforge/fml/loading/moddiscovery/ModFileInfo.java

@@ -264,7 +264,7 @@ public class ModFileInfo implements IModFileInfo, IConfigurable {
 
     @Override
     public String versionString()  {
-        return getMods().get(0).getVersion().toString();
+        return getMods().getFirst().getVersion().toString();
     }
 
     @Override

fmlloader/src/main/java/net/minecraftforge/fml/loading/moddiscovery/ModFileParser.java

@@ -6,23 +6,18 @@
 package net.minecraftforge.fml.loading.moddiscovery;
 
 import com.electronwill.nightconfig.core.file.FileConfig;
-import com.google.gson.Gson;
-import com.google.gson.reflect.TypeToken;
+import com.electronwill.nightconfig.core.io.ParsingException;
 import com.mojang.logging.LogUtils;
 import net.minecraftforge.fml.loading.LogMarkers;
 import net.minecraftforge.forgespi.language.IModFileInfo;
 import net.minecraftforge.forgespi.locating.IModFile;
 import net.minecraftforge.forgespi.locating.ModFileFactory;
+import net.minecraftforge.forgespi.locating.ModFileLoadingException;
 import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 
-import java.io.IOException;
-import java.lang.reflect.Type;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
 
 public class ModFileParser {
     private static final Logger LOGGER = LogUtils.getLogger();
@@ -31,6 +26,7 @@ public class ModFileParser {
         return parser.build(modFile);
     }
 
+    // Note: Although @Nullable, several other places in FML assume ModFileInfo is not null. Keep this in mind
     public static @Nullable IModFileInfo modsTomlParser(final IModFile imodFile) {
         ModFile modFile = (ModFile) imodFile;
         LOGGER.debug(LogMarkers.LOADING,"Considering mod file candidate {}", modFile.getFilePath());
@@ -41,30 +37,15 @@ public class ModFileParser {
         }
 
         final FileConfig fileConfig = FileConfig.builder(modsjson).build();
-        fileConfig.load();
-        fileConfig.close();
-        final NightConfigWrapper configWrapper = new NightConfigWrapper(fileConfig);
-        return new ModFileInfo(modFile, configWrapper, configWrapper::setFile);
-    }
-
-    protected static List<CoreModFile> getCoreMods(final ModFile modFile) {
-        Map<String,String> coreModPaths;
         try {
-            final Path coremodsjson = modFile.findResource("META-INF", "coremods.json");
-            if (!Files.exists(coremodsjson)) {
-                return Collections.emptyList();
-            }
-            final Type type = new TypeToken<Map<String, String>>() {}.getType();
-            final Gson gson = new Gson();
-            coreModPaths = gson.fromJson(Files.newBufferedReader(coremodsjson), type);
-        } catch (IOException e) {
-            LOGGER.debug(LogMarkers.LOADING,"Failed to read coremod list coremods.json", e);
-            return Collections.emptyList();
+            fileConfig.load();
+            fileConfig.close();
+            final NightConfigWrapper configWrapper = new NightConfigWrapper(fileConfig);
+            return new ModFileInfo(modFile, configWrapper, configWrapper::setFile);
+        } catch (ParsingException e) {
+            LOGGER.error("Mod candidate {} contains a corrupt or misconfigured toml.", modFile.getFileName());
+            throw new ModFileLoadingException("Mod candidate " + modFile.getFileName() + " contains a corrupt or misconfigured toml.");
         }
 
-        return coreModPaths.entrySet().stream()
-                .peek(e-> LOGGER.debug(LogMarkers.LOADING,"Found coremod {} with Javascript path {}", e.getKey(), e.getValue()))
-                .map(e -> new CoreModFile(e.getKey(), modFile.findResource(e.getValue()),modFile))
-                .toList();
     }
 }

fmlloader/src/main/java/net/minecraftforge/fml/loading/moddiscovery/ModValidator.java

@@ -31,10 +31,8 @@ public class ModValidator {
     private final List<ModFile> candidatePlugins;
     private final List<ModFile> candidateMods;
     private final List<ModFile> gameLibraries;
-    private LoadingModList loadingModList;
     private final List<IModFile> brokenFiles = new ArrayList<>();
     private final List<EarlyLoadingException.ExceptionData> discoveryErrorData;
-    private final List<ModFileLoadingException> modFileLoadingExceptions;
 
     public ModValidator(Map<IModFile.Type, List<ModFile>> modFiles, List<IModFileInfo> brokenFiles, List<EarlyLoadingException.ExceptionData> discoveryErrorData, List<ModFileLoadingException> modFileLoadingExceptions) {
         this.candidateMods = lst(modFiles.get(IModFile.Type.MOD));
@@ -44,7 +42,6 @@ public class ModValidator {
         this.candidatePlugins.addAll(lst(modFiles.get(IModFile.Type.LIBRARY)));
         this.discoveryErrorData = discoveryErrorData;
         this.brokenFiles.addAll(brokenFiles.stream().map(IModFileInfo::getFile).toList());
-        this.modFileLoadingExceptions = modFileLoadingExceptions;
     }
 
     public ModValidator(Map<IModFile.Type, List<ModFile>> modFiles, List<IModFileInfo> brokenFiles, List<EarlyLoadingException.ExceptionData> discoveryErrorData) {
@@ -52,7 +49,9 @@ public class ModValidator {
     }
 
     private static List<ModFile> lst(List<ModFile> files) {
-        return files == null ? new ArrayList<>() : new ArrayList<>(files);
+        if (files == null) return new ArrayList<>();
+        if (files instanceof ArrayList) return files;
+        return new ArrayList<>(files);
     }
 
     public void stage1Validation() {
@@ -60,7 +59,7 @@ public class ModValidator {
         if (LOGGER.isDebugEnabled(LogMarkers.SCAN)) {
             LOGGER.debug(LogMarkers.SCAN, "Found {} mod files with {} mods", candidateMods.size(), candidateMods.stream().mapToInt(mf -> mf.getModInfos().size()).sum());
         }
-        ImmediateWindowHandler.updateProgress("Found "+candidateMods.size()+" mod candidates");
+        ImmediateWindowHandler.updateProgress("Found " + candidateMods.size() + " mod candidates");
     }
 
     @NotNull
@@ -87,7 +86,7 @@ public class ModValidator {
         // If any detectable error happens during the sorting process {missing deps, duplicates,
         // This helps prevent coremods/mixins from screwing up us displaying the error screens that the sorting/validation is trying to display.
         // This won't fix them all as they are still loaded and will still apply but it might help
-        for (var info : this.loadingModList.getModFiles())
+        for (var info : LoadingModList.getModFiles())
             mods.add(info.getFile().getSecureJar());
 
         // Add any game libraries, this *may* be duplicates, depending on the state of the sorting. But until I get around to re-writing
@@ -124,12 +123,12 @@ public class ModValidator {
         var allErrors = new ArrayList<>(errors);
         allErrors.addAll(this.discoveryErrorData);
 
-        loadingModList = ModSorter.sort(candidateMods, allErrors);
-        loadingModList.addCoreMods();
-        loadingModList.addAccessTransformers();
-        loadingModList.setBrokenFiles(brokenFiles);
-        BackgroundScanHandler backgroundScanHandler = new BackgroundScanHandler(candidateMods);
-        loadingModList.addForScanning(backgroundScanHandler);
+        ModSorter.sort(candidateMods, allErrors);
+        LoadingModList.getBrokenFiles().addAll(brokenFiles);
+        var backgroundScanHandler = new BackgroundScanHandler(candidateMods);
+        LoadingModList.getModFiles().stream()
+                .map(ModFileInfo::getFile)
+                .forEach(backgroundScanHandler::submitForScanning);
         return backgroundScanHandler;
     }
 }

fmlloader/src/main/java/net/minecraftforge/fml/loading/targets/CommonDevLaunchHandler.java

@@ -156,7 +156,6 @@ abstract class CommonDevLaunchHandler extends CommonLaunchHandler {
         return new String[] {
             "net/minecraftforge/",
             "META-INF/services/",
-            "META-INF/coremods.json",
             "META-INF/mods.toml"
         };
     }

fmlloader/src/main/java/net/minecraftforge/fml/loading/targets/ForgeProdLaunchHandler.java

@@ -25,7 +25,9 @@ sealed abstract class ForgeProdLaunchHandler extends CommonLaunchHandler {
 
         @Override
         public List<Path> getMinecraftPaths() {
-            return List.of(getPathFromResource("net/minecraft/client/Minecraft.class"));
+            // We use a marker because 3rd party launcher don't build their class paths correctly
+            // https://github.com/MinecraftForge/MinecraftForge/issues/10797
+            return List.of(getPathFromResource(".forge_patched_minecraft"));
         }
     }
 

fmlloader/src/main/resources/jarjar_options.json

@@ -0,0 +1,35 @@
+{
+  "options": [
+    {
+      "resource": "com/llamalad7/mixinextras/platform/forge/MixinExtrasConfigPlugin.class",
+      "layer": "GAMELIBRARY",
+      "id": "mixinextras",
+      "deps": [
+        {
+          "identifier": {
+            "group": "com.github.LlamaLad7",
+            "artifact": "MixinExtras"
+          },
+          "version": {
+            "range": "[0.5.4,)",
+            "artifactVersion": "0.5.4"
+          },
+          "path": "",
+          "isObfuscated": false
+        }
+      ],
+      "meta": {
+        "identifier": {
+          "group": "io.github.llamalad7",
+          "artifact": "mixinextras-forge"
+        },
+        "version": {
+          "artifactVersion": "0.5.4"
+        },
+        "path": "",
+        "isObfuscated": false
+      },
+      "nested": true
+    }
+  ]
+}

forge-transformers/build.gradle

@@ -1,73 +1,78 @@
-import net.minecraftforge.gradleutils.PomUtils
-
 plugins {
     id 'java-library'
     id 'maven-publish'
-    id 'net.minecraftforge.licenser'
-    id 'net.minecraftforge.gradleutils'
-    alias(libs.plugins.apt)
+    alias libs.plugins.licenser
+    alias libs.plugins.gradleutils
+    alias libs.plugins.gitversion
+    alias libs.plugins.changelog
+    id 'net.minecraftforge.forge.build.convention'
 }
 
-apply from: rootProject.file('build_shared.gradle')
-
-configurations.forEach{ it.transitive = false }
-
-dependencies {
-    compileOnly(libs.jetbrains.annotations)
-
-    implementation(libs.bundles.asm) // Needed by all the black magic
-    implementation(libs.log4j.api)
-    implementation(libs.gson)
-    implementation(libs.modlauncher)
-    implementation(libs.coremods) // Used for ASMAPI (for now)
-
-    testCompileOnly(libs.jetbrains.annotations)
-}
+gradleutils.displayName = 'Forge Transformers'
+final vendor = 'Forge Development LLC'
+description = 'Forge-specific transformers unrelated to the FML project.'
 
 java {
-    toolchain.languageVersion = JavaLanguageVersion.of(JAVA_VERSION)
+    toolchain.languageVersion = JavaLanguageVersion.of(javaVersion)
     withSourcesJar()
 }
 
-tasks.named('jar', Jar) {
-    manifest {
-        attributes([
-            'Automatic-Module-Name': 'net.minecraftforge.forge.transformers',
-            'Forge-Module-Layer':    'boot'
-        ] as LinkedHashMap)
-        attributes([
-            'Specification-Title':   'Forge Transformers',
-            'Specification-Vendor':  'Forge Development LLC',
-            'Specification-Version': '1',
-            'Implementation-Title':  'Forge Transformers',
-            'Implementation-Vendor': 'Forge Development LLC',
-            'Implementation-Version': FORGE_VERSION
-        ] as LinkedHashMap, 'net/minecraftforge/forge/transformers/')
-    }
-}
-
-tasks.withType(JavaCompile).configureEach {
-    options.compilerArgs << '-Xlint:unchecked'
-}
-
 license {
     header = rootProject.file('LICENSE-header.txt')
 }
 
-publishing {
-    publications.register('mavenJava', MavenPublication) {
-        from components.java
-        artifactId = 'forge-transformers'
-        pom {
-            name = project.name
-            description = 'Forge-specific transformers unrelated to the FML project.'
-            url = 'https://github.com/MinecraftForge/MinecraftForge'
-            PomUtils.setGitHubDetails(pom, 'MinecraftForge')
-            license PomUtils.Licenses.LGPLv2_1
-        }
-    }
+changelog {
+    from changelogBase
+}
 
+dependencies {
+    compileOnly(libs.jetbrains.annotations)
+
+    implementation(libs.bundles.asm ){ transitive = false } // Needed by all the black magic
+    implementation(libs.log4j.api   ){ transitive = false }
+    implementation(libs.gson        ){ transitive = false }
+    implementation(libs.modlauncher ){ transitive = false }
+    implementation(libs.coremods.api){ transitive = false }
+
+    testCompileOnly(libs.jetbrains.annotations)
+}
+
+tasks.named('jar', Jar) {
+    manifest {
+        attributes([
+                'Automatic-Module-Name': 'net.minecraftforge.forge.transformers',
+                'Forge-Module-Layer'   : 'boot'
+        ])
+        attributes([
+                'Specification-Title'   : gradleutils.displayName.get(),
+                'Specification-Vendor'  : vendor,
+                'Specification-Version' : '1',
+                'Implementation-Title'  : gradleutils.displayName.get(),
+                'Implementation-Vendor' : vendor,
+                'Implementation-Version': forgeVersion
+        ], 'net/minecraftforge/forge/transformers/')
+    }
+}
+
+publishing {
     repositories {
         maven gradleutils.publishingForgeMaven
     }
+
+    publications.register('mavenJava', MavenPublication) {
+        changelog.publish(it)
+        gradleutils.promote(it)
+
+        from components.java
+
+        pom { pom ->
+            description = project.description
+
+            gradleutils.pom.addRemoteDetails(pom)
+
+            licenses {
+                license gradleutils.pom.licenses.LGPLv2_1
+            }
+        }
+    }
 }

forge-transformers/src/main/java/net/minecraftforge/forge/transformers/FieldToMethodTransformer.java

@@ -8,16 +8,27 @@ package net.minecraftforge.forge.transformers;
 import cpw.mods.modlauncher.api.ITransformer;
 import cpw.mods.modlauncher.api.ITransformerVotingContext;
 import cpw.mods.modlauncher.api.TransformerVoteResult;
-import net.minecraftforge.coremod.api.ASMAPI;
-import org.jetbrains.annotations.NotNull;
-import org.objectweb.asm.tree.ClassNode;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.FieldInsnNode;
+import org.objectweb.asm.tree.FieldNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+
+import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 record FieldToMethodTransformer(String className, Map<String, String> fields) implements ITransformer<ClassNode> {
+    private static final Logger LOGGER = LogManager.getLogger();
+
     // TODO [Forge][Transformer] Make this properly data driven or configurable.
     //      It was hard-coded like this before when using JS CoreMods, though.
     static final Map<String, Map<String, String>> TARGETS = Map.of(
@@ -60,7 +71,7 @@ record FieldToMethodTransformer(String className, Map<String, String> fields) im
     @Override
     public @NotNull ClassNode transform(ClassNode input, ITransformerVotingContext context) {
         for (var entry : this.fields.entrySet()) {
-            ASMAPI.redirectFieldToMethod(input, entry.getKey(), entry.getValue());
+            redirectFieldToMethod(input, entry.getKey(), entry.getValue());
         }
 
         return input;
@@ -75,4 +86,73 @@ record FieldToMethodTransformer(String className, Map<String, String> fields) im
     public @NotNull Set<Target> targets() {
         return Set.of(Target.targetClass(this.className));
     }
+
+    private static final @Nullable FieldNode findField(final ClassNode classNode, final String name) {
+        FieldNode ret = null;
+        for (var fieldNode : classNode.fields) {
+            if (name.equals(fieldNode.name)) {
+                if (ret != null)
+                    throw new IllegalStateException("Found multiple fields with name " + name);
+                ret = fieldNode;
+            }
+        }
+        return ret;
+    }
+
+    private static final @Nullable MethodNode findMethod(final ClassNode classNode, final String name, final String desc) {
+        for (var methodNode : classNode.methods) {
+            if (name.equals(methodNode.name) && desc.equals(methodNode.desc))
+                return methodNode;
+        }
+        return null;
+    }
+
+    /**
+     * Rewrites accesses to a specific field in the given class to a method-call.
+     * <p>
+     * The field specified by fieldName must be private and non-static. The method-call the field-access is redirected
+     * to does not take any parameters and returns an object of the same type as the field. If no methodName is passed,
+     * any method matching the described signature will be used as callable method.
+     *
+     * @param classNode  the class to rewrite the accesses in
+     * @param fieldName  the field accesses should be redirected to
+     * @param methodName the name of the method to redirect accesses through
+     * @apiNote This method was written as a special use case for Forge. It is not recommended to use this method
+     *     unless you know what you are doing.
+     */
+    private static void redirectFieldToMethod(final ClassNode classNode, final String fieldName, final String methodName) {
+        var foundField = findField(classNode, fieldName);
+        if (foundField == null)
+            throw new IllegalStateException("No field with name " + fieldName + " found");
+
+        if (!Modifier.isPrivate(foundField.access) || Modifier.isStatic(foundField.access))
+            throw new IllegalStateException("Field " + fieldName + " is not private and an instance field");
+
+        var methodSignature = "()" + foundField.desc;
+        var foundMethod = findMethod(classNode, methodName, methodSignature);
+        if (foundMethod == null)
+            throw new IllegalStateException("Unable to find method " + methodName + methodSignature);
+
+        for (MethodNode methodNode : classNode.methods) {
+            // skip the found getter method
+            if (methodNode == foundMethod) continue;
+
+            // Why is this filtered? UI twas added in the beginning but would it matter?
+            if (methodSignature.equals(foundMethod)) {
+                LOGGER.debug("FieldToMethodTransformer " + classNode.name + " skipping " + methodNode.name + methodNode.hashCode());
+                continue;
+            }
+
+            for (var insn : methodNode.instructions) {
+                if (insn.getOpcode() != Opcodes.GETFIELD)
+                    continue;
+
+                var fieldInsnNode = (FieldInsnNode)insn;
+                if (fieldName.equals(fieldInsnNode.name)) {
+                    var replace = new MethodInsnNode(Opcodes.INVOKEVIRTUAL, classNode.name, foundMethod.name, foundMethod.desc, false);
+                    methodNode.instructions.set(insn, replace);
+                }
+            }
+        }
+    }
 }