Add support for jar merging

8 files changed, 754 insertions, 1 deletions

diff --git a/plugin/src/main/kotlin/moe/nea/archenemy/mojang/AbstractTransformerRepository.kt b/plugin/src/main/kotlin/moe/nea/archenemy/mojang/AbstractTransformerRepository.kt
new file mode 100644
index 0000000..601cb19
--- /dev/null
+++ b/plugin/src/main/kotlin/moe/nea/archenemy/mojang/AbstractTransformerRepository.kt
@@ -0,0 +1,69 @@
+package moe.nea.archenemy.mojang
+
+import moe.nea.archenemy.util.DownloadUtils
+import moe.nea.archenemy.util.getNullsafeIdentifier
+import net.minecraftforge.artifactural.api.artifact.Artifact
+import net.minecraftforge.artifactural.api.artifact.ArtifactIdentifier
+import net.minecraftforge.artifactural.api.artifact.Streamable
+import net.minecraftforge.artifactural.api.repository.Repository
+import org.gradle.api.artifacts.Dependency
+import java.io.File
+import java.security.MessageDigest
+
+abstract class AbstractTransformerRepository<T : CHashable>(
+    val repoIdentifier: String,
+    val extension: ArchenemyMojangExtension,
+) : Repository {
+    init {
+        require(!repoIdentifier.contains("."))
+    }
+
+    data class HashContainer<T : CHashable>(val t: T) {
+        val transformerHash = kotlin.run {
+            val digest = MessageDigest.getInstance("SHA-256")
+            t.updateHash(digest)
+            DownloadUtils.bytesToHex(digest.digest())
+        }
+    }
+
+    fun resolveDirect(vararg dependency: Dependency): Set<File> {
+        return extension.project.configurations.detachedConfiguration(*dependency).also { it.isTransitive = false }
+            .resolve()
+    }
+
+    fun lazyTransform(file: File, function: (file: File) -> Unit): Streamable {
+        return Streamable {
+            if (!file.exists()) function(file)
+            file.inputStream()
+        }
+    }
+
+    private val providers: MutableMap<String, HashContainer<T>> = mutableMapOf()
+    val baseDirectory = extension.getLocalCacheDirectory().resolve("precache-$repoIdentifier")
+    fun getCoordinate(t: T): String {
+        val container = HashContainer(t)
+        providers[container.transformerHash] = container
+        val c = getClassifier(t)
+        return "archenemy.$repoIdentifier.${container.transformerHash}:${getName(t)}:${getVersion(t)}" + if (c != null) ":$c" else ""
+    }
+
+    protected abstract fun getName(t: T): String
+    protected abstract fun getVersion(t: T): String
+    protected open fun getClassifier(t: T): String? = null
+    override fun getArtifact(identifier: ArtifactIdentifier?): Artifact {
+        if (identifier == null) return Artifact.none()
+        if (!identifier.group.startsWith("archenemy.${this.repoIdentifier}.")) return Artifact.none()
+        val hash = identifier.group.split(".")[2]
+        val provider = providers[hash] ?: error("Unregistered archenemy ${this.repoIdentifier} dependeny")
+        val coordinate = getCoordinate(provider.t)
+        require(coordinate.startsWith(identifier.group + ":" + identifier.name + ":" + identifier.version))
+        if (identifier.extension == "pom") return Artifact.none()
+        return getArtifact(
+            getNullsafeIdentifier(identifier),
+            provider.t,
+            baseDirectory.resolve("$hash-${identifier.classifier}.${identifier.extension}")
+        ) ?: Artifact.none()
+    }
+
+    protected abstract fun getArtifact(identifier: ArtifactIdentifier, value: T, file: File): Artifact?
+}
\ No newline at end of file
diff --git a/plugin/src/main/kotlin/moe/nea/archenemy/mojang/ArchenemyMojangExtension.kt b/plugin/src/main/kotlin/moe/nea/archenemy/mojang/ArchenemyMojangExtension.kt
index 8125900..e1a8bfe 100644
--- a/plugin/src/main/kotlin/moe/nea/archenemy/mojang/ArchenemyMojangExtension.kt
+++ b/plugin/src/main/kotlin/moe/nea/archenemy/mojang/ArchenemyMojangExtension.kt
@@ -21,9 +21,15 @@ abstract class ArchenemyMojangExtension(val project: Project) {
         GradleRepositoryAdapter.add(
             project.repositories,
             "Minecraft Mapped Provider",
-            getLocalCacheDirectory().resolve("minecraft-transformation-provider"),
+            getLocalCacheDirectory().resolve("minecraft-mapped-provider"),
             mappedRepositoryProvider
         )
+        GradleRepositoryAdapter.add(
+            project.repositories,
+            "Minecraft Merged Provider",
+            getLocalCacheDirectory().resolve("minecraft-merged-provider"),
+            mergedRepositoryProvider
+        )
         project.repositories.maven {
             it.name = "Minecraft Libraries"
             it.url = URI("https://libraries.minecraft.net/")
@@ -31,6 +37,7 @@ abstract class ArchenemyMojangExtension(val project: Project) {
     }
 
     private val mappedRepositoryProvider = MappedRepositoryProvider(this)
+    private val mergedRepositoryProvider = MergedRepositoryProvider(this)
 
     fun yarnMappings(dependency: Dependency): MappingDependency {
         dependency as ModuleDependency
@@ -56,6 +63,20 @@ abstract class ArchenemyMojangExtension(val project: Project) {
         return yarnMappings(project.dependencies.create("net.fabricmc:intermediary:$version:v2"))
     }
 
+    fun mergeJar(
+        base: Dependency,
+        overlay: Dependency,
+    ): Dependency {
+        base as ModuleDependency
+        overlay as ModuleDependency
+        _registerMinecraftProvider
+        return project.dependencies.create(
+            mergedRepositoryProvider.getCoordinate(
+                MergedRepositoryProvider.Coordinate(base, overlay)
+            )
+        )
+    }
+
     fun mapJar(
         dependency: Dependency,
         mappings: MappingDependency,
diff --git a/plugin/src/main/kotlin/moe/nea/archenemy/mojang/CHashable.kt b/plugin/src/main/kotlin/moe/nea/archenemy/mojang/CHashable.kt
new file mode 100644
index 0000000..bfac9c7
--- /dev/null
+++ b/plugin/src/main/kotlin/moe/nea/archenemy/mojang/CHashable.kt
@@ -0,0 +1,7 @@
+package moe.nea.archenemy.mojang
+
+import java.security.MessageDigest
+
+interface CHashable {
+    fun updateHash(digest: MessageDigest)
+}
diff --git a/plugin/src/main/kotlin/moe/nea/archenemy/mojang/ClassMerger.kt b/plugin/src/main/kotlin/moe/nea/archenemy/mojang/ClassMerger.kt
new file mode 100644
index 0000000..655cf85
--- /dev/null
+++ b/plugin/src/main/kotlin/moe/nea/archenemy/mojang/ClassMerger.kt
@@ -0,0 +1,508 @@
+package moe.nea.archenemy.mojang
+
+import moe.nea.archenemy.util.EnvType
+import org.objectweb.asm.Attribute
+import org.objectweb.asm.Opcodes
+import org.objectweb.asm.tree.*
+
+// One to one copied from unimined. Definitely needs improvement to be better suited to my needs, but for now this will do and is much better than writing a barebones thing myself.
+class ClassMerger(
+    val toMergedClass: (ClassNode, EnvType) -> Unit = { _, _ -> },
+    val toMergedFields: (FieldNode, EnvType) -> Unit = { _, _ -> },
+    val toMergedMethods: (MethodNode, EnvType) -> Unit = { _, _ -> }
+) {
+    fun accept(client: ClassNode?, server: ClassNode?): ClassNode {
+        if (client == null) {
+            if (server!!.access and Opcodes.ACC_INTERFACE == 0) {
+                toMergedClass(server, EnvType.SERVER)
+                return server
+            } else {
+                // make interface methods & fields sided
+                server.methods?.forEach { toMergedMethods(it, EnvType.SERVER) }
+                server.fields?.forEach { toMergedFields(it, EnvType.SERVER) }
+                return server
+            }
+        }
+        if (server == null) {
+            if (client.access and Opcodes.ACC_INTERFACE == 0) {
+                toMergedClass(client, EnvType.CLIENT)
+                return client
+            } else {
+                // make interface methods & fields sided
+                client.methods?.forEach { toMergedMethods(it, EnvType.CLIENT) }
+                client.fields?.forEach { toMergedFields(it, EnvType.CLIENT) }
+                return client
+            }
+        }
+        if (!areClassMetadataEqual(client, server)) {
+            throw IllegalArgumentException("Class metadata is not equal!")
+        }
+        // weaker access
+        val merged = ClassNode()
+        merged.version = client.version.coerceAtLeast(server.version)
+        merged.access = selectWeakerAccess(client.access, server.access)
+        merged.name = client.name
+        merged.signature = client.signature
+        merged.superName = client.superName
+        merged.interfaces = client.interfaces?.toMutableSet()?.apply { addAll(server.interfaces ?: setOf()) }?.toList()
+            ?: server.interfaces
+        merged.sourceFile = client.sourceFile
+        merged.sourceDebug = client.sourceDebug
+        merged.module = client.module
+        merged.outerClass = client.outerClass
+        merged.outerMethod = client.outerMethod
+        merged.outerMethodDesc = client.outerMethodDesc
+        // merge client and server annotations
+        merged.visibleAnnotations = client.visibleAnnotations?.toMutableList()?.apply {
+            for (a in server.visibleAnnotations ?: listOf()) {
+                if (!any { areAnnotationNodesEqual(it, a) }) {
+                    add(a)
+                }
+            }
+        } ?: server.visibleAnnotations
+        merged.invisibleAnnotations = client.invisibleAnnotations?.toMutableList()?.apply {
+            for (a in server.invisibleAnnotations ?: listOf()) {
+                if (!any { areAnnotationNodesEqual(it, a) }) {
+                    add(a)
+                }
+            }
+        } ?: server.invisibleAnnotations
+        merged.visibleTypeAnnotations = client.visibleTypeAnnotations?.toMutableList()?.apply {
+            for (a in server.visibleTypeAnnotations ?: listOf()) {
+                if (!any { areAnnotationNodesEqual(it, a) }) {
+                    add(a)
+                }
+            }
+        } ?: server.visibleTypeAnnotations
+        merged.invisibleTypeAnnotations = client.invisibleTypeAnnotations?.toMutableList()?.apply {
+            for (a in server.invisibleTypeAnnotations ?: listOf()) {
+                if (!any { areAnnotationNodesEqual(it, a) }) {
+                    add(a)
+                }
+            }
+        } ?: server.invisibleTypeAnnotations
+        merged.attrs = client.attrs?.toMutableList()?.apply {
+            for (a in server.attrs ?: listOf()) {
+                if (!any { areAttributesEqual(it, a) }) {
+                    add(a)
+                }
+            }
+        } ?: server.attrs
+        // merge inner classes
+        merged.innerClasses = client.innerClasses?.toMutableList()?.apply {
+            for (a in server.innerClasses ?: listOf()) {
+                if (!any { areInnerClassNodesEqual(it, a) }) {
+                    add(a)
+                }
+            }
+        } ?: server.innerClasses
+        merged.nestHostClass = client.nestHostClass
+        merged.nestMembers = client.nestMembers?.toMutableSet()
+            ?.apply { addAll(server.nestMembers ?: setOf()) }
+            ?.toList() ?: server.nestMembers
+        merged.permittedSubclasses = client.permittedSubclasses?.toMutableSet()
+            ?.apply { addAll(server.permittedSubclasses ?: setOf()) }
+            ?.toList() ?: server.permittedSubclasses
+        // merge record components
+        merged.recordComponents = client.recordComponents?.toMutableList()?.apply {
+            for (a in server.recordComponents ?: listOf()) {
+                if (!any { areRecordComponentNodesEqual(it, a) }) {
+                    add(a)
+                }
+            }
+        } ?: server.recordComponents
+
+        // merge fields
+        val fields = client.fields.map { it to EnvType.CLIENT }.toMutableList()
+        outer@ for (field in server.fields) {
+            for (f in fields) {
+                if (areFieldNodesEqual(f.first, field)) {
+                    fields.remove(f)
+                    field.access = selectWeakerAccess(f.first.access, field.access)
+                    fields.add(field to EnvType.COMBINED)
+                    continue@outer
+                }
+            }
+            fields.add(field to EnvType.SERVER)
+        }
+        fields.forEach { toMergedFields(it.first, it.second) }
+        merged.fields = mutableListOf()
+        for (f in fields) {
+            merged.fields.add(f.first)
+        }
+
+        // merge methods
+        val methods = client.methods.map { it to EnvType.CLIENT }.toMutableList()
+        outer@ for (method in server.methods) {
+            for (m in methods) {
+                if (areMethodNodesEqual(m.first, method)) {
+                    methods.remove(m)
+                    method.access = selectWeakerAccess(m.first.access, method.access)
+                    methods.add(method to EnvType.COMBINED)
+                    continue@outer
+                }
+            }
+            methods.add(method to EnvType.SERVER)
+        }
+        methods.forEach { toMergedMethods(it.first, it.second) }
+        merged.methods = mutableListOf()
+        for (m in methods) {
+            merged.methods.add(m.first)
+        }
+        toMergedClass(merged, EnvType.COMBINED)
+        return merged
+    }
+
+    companion object {
+        fun areFieldNodesEqual(a: FieldNode, b: FieldNode): Boolean {
+            if (a.name != b.name) return false
+            if (a.desc != b.desc) return false
+            if (a.value != b.value) return false
+            // check static part of access
+            if (a.access and Opcodes.ACC_STATIC != b.access and Opcodes.ACC_STATIC) return false
+            val aVisibleAnnotations = a.visibleAnnotations?.toMutableList() ?: mutableListOf()
+            val bVisibleAnnotations = b.visibleAnnotations?.toMutableList() ?: mutableListOf()
+            if (aVisibleAnnotations.size != bVisibleAnnotations.size) return false
+            aVisibleAnnotations.removeIf {
+                bVisibleAnnotations.any { it2 ->
+                    if (areAnnotationNodesEqual(it, it2)) {
+                        bVisibleAnnotations.remove(it2)
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
+            if (aVisibleAnnotations.isNotEmpty()) return false
+            if (bVisibleAnnotations.isNotEmpty()) return false
+            val aInvisibleAnnotations = a.invisibleAnnotations?.toMutableList() ?: mutableListOf()
+            val bInvisibleAnnotations = b.invisibleAnnotations?.toMutableList() ?: mutableListOf()
+            if (aInvisibleAnnotations.size != bInvisibleAnnotations.size) return false
+            aInvisibleAnnotations.removeIf {
+                bInvisibleAnnotations.any { it2 ->
+                    if (areAnnotationNodesEqual(it, it2)) {
+                        bInvisibleAnnotations.remove(it2)
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
+            if (aInvisibleAnnotations.isNotEmpty()) return false
+            if (bInvisibleAnnotations.isNotEmpty()) return false
+            val aVisibleTypeAnnotations = a.visibleTypeAnnotations?.toMutableList() ?: mutableListOf()
+            val bVisibleTypeAnnotations = b.visibleTypeAnnotations?.toMutableList() ?: mutableListOf()
+            if (aVisibleTypeAnnotations.size != bVisibleTypeAnnotations.size) return false
+            aVisibleTypeAnnotations.removeIf {
+                bVisibleTypeAnnotations.any { it2 ->
+                    if (areAnnotationNodesEqual(it, it2)) {
+                        bVisibleTypeAnnotations.remove(it2)
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
+            if (aVisibleTypeAnnotations.isNotEmpty()) return false
+            if (bVisibleTypeAnnotations.isNotEmpty()) return false
+            val aInvisibleTypeAnnotations = a.invisibleTypeAnnotations?.toMutableList() ?: mutableListOf()
+            val bInvisibleTypeAnnotations = b.invisibleTypeAnnotations?.toMutableList() ?: mutableListOf()
+            if (aInvisibleTypeAnnotations.size != bInvisibleTypeAnnotations.size) return false
+            aInvisibleTypeAnnotations.removeIf {
+                bInvisibleTypeAnnotations.any { it2 ->
+                    if (areAnnotationNodesEqual(it, it2)) {
+                        bInvisibleTypeAnnotations.remove(it2)
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
+            if (aInvisibleTypeAnnotations.isNotEmpty()) return false
+            if (bInvisibleTypeAnnotations.isNotEmpty()) return false
+            val aAttributes = a.attrs?.toMutableList() ?: mutableListOf()
+            val bAttributes = b.attrs?.toMutableList() ?: mutableListOf()
+            if (aAttributes.size != bAttributes.size) return false
+            aAttributes.removeIf {
+                bAttributes.any { it2 ->
+                    if (areAttributesEqual(it, it2)) {
+                        bAttributes.remove(it2)
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
+            if (aAttributes.isNotEmpty()) return false
+            if (bAttributes.isNotEmpty()) return false
+            return true
+        }
+
+        fun areMethodNodesEqual(a: MethodNode, b: MethodNode): Boolean {
+            if (a.name != b.name) return false
+            if (a.desc != b.desc) return false
+            // check static part of access
+            if (a.access and Opcodes.ACC_STATIC != b.access and Opcodes.ACC_STATIC) return false
+//            val aParameters = a.parameters?.toMutableList() ?: mutableListOf()
+//            val bParameters = b.parameters?.toMutableList() ?: mutableListOf()
+//            if (aParameters.size != bParameters.size) return false
+//            aParameters.removeIf {
+//                bParameters.any { it2 ->
+//                    areParamsEqual(it, it2)
+//                }
+//            }
+//            if (aParameters.isNotEmpty()) return false
+            val aVisibleAnnotations = a.visibleAnnotations?.toMutableList() ?: mutableListOf()
+            val bVisibleAnnotations = b.visibleAnnotations?.toMutableList() ?: mutableListOf()
+            if (aVisibleAnnotations.size != bVisibleAnnotations.size) return false
+            aVisibleAnnotations.removeIf {
+                bVisibleAnnotations.any { it2 ->
+                    if (areAnnotationNodesEqual(it, it2)) {
+                        bVisibleAnnotations.remove(it2)
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
+            if (aVisibleAnnotations.isNotEmpty()) return false
+            if (bVisibleAnnotations.isNotEmpty()) return false
+            val aInvisibleAnnotations = a.invisibleAnnotations?.toMutableList() ?: mutableListOf()
+            val bInvisibleAnnotations = b.invisibleAnnotations?.toMutableList() ?: mutableListOf()
+            if (aInvisibleAnnotations.size != bInvisibleAnnotations.size) return false
+            aInvisibleAnnotations.removeIf {
+                bInvisibleAnnotations.any { it2 ->
+                    if (areAnnotationNodesEqual(it, it2)) {
+                        bInvisibleAnnotations.remove(it2)
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
+            if (aInvisibleAnnotations.isNotEmpty()) return false
+            if (bInvisibleAnnotations.isNotEmpty()) return false
+            val aVisibleTypeAnnotations = a.visibleTypeAnnotations?.toMutableList() ?: mutableListOf()
+            val bVisibleTypeAnnotations = b.visibleTypeAnnotations?.toMutableList() ?: mutableListOf()
+            if (aVisibleTypeAnnotations.size != bVisibleTypeAnnotations.size) return false
+            aVisibleTypeAnnotations.removeIf {
+                bVisibleTypeAnnotations.any { it2 ->
+                    if (areAnnotationNodesEqual(it, it2)) {
+                        bVisibleTypeAnnotations.remove(it2)
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
+            if (aVisibleTypeAnnotations.isNotEmpty()) return false
+            if (bVisibleTypeAnnotations.isNotEmpty()) return false
+            val aInvisibleTypeAnnotations = a.invisibleTypeAnnotations?.toMutableList() ?: mutableListOf()
+            val bInvisibleTypeAnnotations = b.invisibleTypeAnnotations?.toMutableList() ?: mutableListOf()
+            if (aInvisibleTypeAnnotations.size != bInvisibleTypeAnnotations.size) return false
+            aInvisibleTypeAnnotations.removeIf {
+                bInvisibleTypeAnnotations.any { it2 ->
+                    if (areAnnotationNodesEqual(it, it2)) {
+                        bInvisibleTypeAnnotations.remove(it2)
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
+            if (aInvisibleTypeAnnotations.isNotEmpty()) return false
+            if (bInvisibleTypeAnnotations.isNotEmpty()) return false
+            val aAttributes = a.attrs?.toMutableList() ?: mutableListOf()
+            val bAttributes = b.attrs?.toMutableList() ?: mutableListOf()
+            if (aAttributes.size != bAttributes.size) return false
+            aAttributes.removeIf {
+                bAttributes.any { it2 ->
+                    if (areAttributesEqual(it, it2)) {
+                        bAttributes.remove(it2)
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
+            if (aAttributes.isNotEmpty()) return false
+            if (bAttributes.isNotEmpty()) return false
+
+            // check content
+            if (a.instructions.size() != b.instructions.size()) return false
+            val aInstructions = a.instructions
+            val bInstructions = b.instructions
+            for (i in 0 until aInstructions.size()) {
+                if (!areInstructionsEqual(
+                        aInstructions[i],
+                        bInstructions[i]
+                    )
+                ) throw IllegalStateException("Instructions are not equal: ${aInstructions[i]} != ${bInstructions[i]} at index $i in ${a.name} ${a.desc} (${a.instructions.size()} instructions) and ${b.name} ${b.desc} (${b.instructions.size()} instructions)")
+            }
+
+            return true
+        }
+
+        fun areAnnotationNodesEqual(a: AnnotationNode, b: AnnotationNode): Boolean {
+            return a.desc == b.desc // TODO: check values, maybe?
+        }
+
+        fun areAttributesEqual(a: Attribute, b: Attribute): Boolean {
+            return a.type == b.type // TODO: check values, maybe?
+        }
+
+        fun areInstructionsEqual(a: AbstractInsnNode, b: AbstractInsnNode): Boolean {
+            if (a.opcode != b.opcode) return false
+            if (a.type != b.type) return false
+            return true // TODO: contents of instructions
+        }
+
+        fun selectWeakerAccess(a: Int, b: Int): Int {
+            if (a == b) return a
+            // should be final
+            var access = a and Opcodes.ACC_FINAL.inv()
+            if (a and Opcodes.ACC_FINAL != 0 && b and Opcodes.ACC_FINAL != 0) {
+                access = access or Opcodes.ACC_FINAL
+            }
+
+            val aAccess = Access.from(a)
+            val bAccess = Access.from(b)
+            access = access and (Opcodes.ACC_PUBLIC or Opcodes.ACC_PROTECTED or Opcodes.ACC_PRIVATE).inv()
+            access = access or Access.max(aAccess, bAccess).value
+
+            // all other flags must be the same
+            val other = (Opcodes.ACC_FINAL or Opcodes.ACC_PUBLIC or Opcodes.ACC_PROTECTED or Opcodes.ACC_PRIVATE).inv()
+            if ((a and other) != (b and other)) {
+                throw IllegalStateException("Other access is not the same: ${a.toString(16)} != ${b.toString(16)}")
+            }
+            return access
+        }
+
+        fun areClassMetadataEqual(a: ClassNode, b: ClassNode): Boolean {
+            // require equal static
+            if (a.access and Opcodes.ACC_STATIC != b.access and Opcodes.ACC_STATIC) return false
+            if (a.name != b.name) return false
+            if (a.superName != b.superName) return false
+            if (a.outerClass != b.outerClass) return false
+            if (a.outerMethod != b.outerMethod) return false
+            if (a.outerMethodDesc != b.outerMethodDesc) return false
+            if (a.nestHostClass != b.nestHostClass) return false
+            return true
+        }
+
+        fun areInnerClassNodesEqual(a: InnerClassNode, b: InnerClassNode): Boolean {
+            if (a.name != b.name) return false
+            if (a.outerName != b.outerName) return false
+            if (a.innerName != b.innerName) return false
+            if (a.access != b.access) return false
+            return true
+        }
+
+        fun areRecordComponentNodesEqual(a: RecordComponentNode, b: RecordComponentNode): Boolean {
+            if (a.name != b.name) return false
+            if (a.descriptor != b.descriptor) return false
+            val aVisibleAnnotations = a.visibleAnnotations?.toMutableList() ?: mutableListOf()
+            val bVisibleAnnotations = b.visibleAnnotations?.toMutableList() ?: mutableListOf()
+            if (aVisibleAnnotations.size != bVisibleAnnotations.size) return false
+            aVisibleAnnotations.removeIf {
+                bVisibleAnnotations.any { it2 ->
+                    if (areAnnotationNodesEqual(it, it2)) {
+                        bVisibleAnnotations.remove(it2)
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
+            if (aVisibleAnnotations.isNotEmpty()) return false
+            if (bVisibleAnnotations.isNotEmpty()) return false
+            val aInvisibleAnnotations = a.invisibleAnnotations?.toMutableList() ?: mutableListOf()
+            val bInvisibleAnnotations = b.invisibleAnnotations?.toMutableList() ?: mutableListOf()
+            if (aInvisibleAnnotations.size != bInvisibleAnnotations.size) return false
+            aInvisibleAnnotations.removeIf {
+                bInvisibleAnnotations.any { it2 ->
+                    if (areAnnotationNodesEqual(it, it2)) {
+                        bInvisibleAnnotations.remove(it2)
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
+            if (aInvisibleAnnotations.isNotEmpty()) return false
+            if (bInvisibleAnnotations.isNotEmpty()) return false
+            val aVisibleTypeAnnotations = a.visibleTypeAnnotations?.toMutableList() ?: mutableListOf()
+            val bVisibleTypeAnnotations = b.visibleTypeAnnotations?.toMutableList() ?: mutableListOf()
+            if (aVisibleTypeAnnotations.size != bVisibleTypeAnnotations.size) return false
+            aVisibleTypeAnnotations.removeIf {
+                bVisibleTypeAnnotations.any { it2 ->
+                    if (areAnnotationNodesEqual(it, it2)) {
+                        bVisibleTypeAnnotations.remove(it2)
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
+            if (aVisibleTypeAnnotations.isNotEmpty()) return false
+            if (bVisibleTypeAnnotations.isNotEmpty()) return false
+            val aInvisibleTypeAnnotations = a.invisibleTypeAnnotations?.toMutableList() ?: mutableListOf()
+            val bInvisibleTypeAnnotations = b.invisibleTypeAnnotations?.toMutableList() ?: mutableListOf()
+            if (aInvisibleTypeAnnotations.size != bInvisibleTypeAnnotations.size) return false
+            aInvisibleTypeAnnotations.removeIf {
+                bInvisibleTypeAnnotations.any { it2 ->
+                    if (areAnnotationNodesEqual(it, it2)) {
+                        bInvisibleTypeAnnotations.remove(it2)
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
+            if (aInvisibleTypeAnnotations.isNotEmpty()) return false
+            if (bInvisibleTypeAnnotations.isNotEmpty()) return false
+            val aAttributes = a.attrs?.toMutableList() ?: mutableListOf()
+            val bAttributes = b.attrs?.toMutableList() ?: mutableListOf()
+            if (aAttributes.size != bAttributes.size) return false
+            aAttributes.removeIf {
+                bAttributes.any { it2 ->
+                    if (areAttributesEqual(it, it2)) {
+                        bAttributes.remove(it2)
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
+            if (aAttributes.isNotEmpty()) return false
+            if (bAttributes.isNotEmpty()) return false
+            return true
+        }
+    }
+
+
+    private enum class Access(val value: Int) {
+        PRIVATE(Opcodes.ACC_PRIVATE),
+        PACKAGE_PRIVATE(0),
+        PROTECTED(Opcodes.ACC_PROTECTED),
+        PUBLIC(Opcodes.ACC_PUBLIC),
+        ;
+
+        companion object {
+            fun from(access: Int): Access {
+                return when (access and (Opcodes.ACC_PRIVATE or Opcodes.ACC_PROTECTED or Opcodes.ACC_PUBLIC)) {
+                    Opcodes.ACC_PRIVATE -> PRIVATE
+                    Opcodes.ACC_PROTECTED -> PROTECTED
+                    Opcodes.ACC_PUBLIC -> PUBLIC
+                    else -> PACKAGE_PRIVATE
+                }
+            }
+
+            fun max(a: Access, b: Access): Access {
+                return values().last { it == a || it == b }
+            }
+        }
+
+    }
+
+}
diff --git a/plugin/src/main/kotlin/moe/nea/archenemy/mojang/MergedRepositoryProvider.kt b/plugin/src/main/kotlin/moe/nea/archenemy/mojang/MergedRepositoryProvider.kt
new file mode 100644
index 0000000..e1c1b65
--- /dev/null
+++ b/plugin/src/main/kotlin/moe/nea/archenemy/mojang/MergedRepositoryProvider.kt
@@ -0,0 +1,98 @@
+package moe.nea.archenemy.mojang
+
+import moe.nea.archenemy.util.readZipFs
+import moe.nea.archenemy.util.update
+import moe.nea.archenemy.util.updateGMV
+import moe.nea.archenemy.util.zipFs
+import net.minecraftforge.artifactural.api.artifact.Artifact
+import net.minecraftforge.artifactural.api.artifact.ArtifactIdentifier
+import net.minecraftforge.artifactural.api.artifact.ArtifactType
+import net.minecraftforge.artifactural.base.artifact.StreamableArtifact
+import org.gradle.api.artifacts.ModuleDependency
+import org.objectweb.asm.ClassReader
+import org.objectweb.asm.ClassWriter
+import org.objectweb.asm.tree.ClassNode
+import java.io.ByteArrayInputStream
+import java.io.File
+import java.io.InputStream
+import java.nio.file.Path
+import java.security.MessageDigest
+import kotlin.io.path.createDirectories
+import kotlin.io.path.outputStream
+
+class MergedRepositoryProvider(archenemyMojangExtension: ArchenemyMojangExtension) :
+    AbstractTransformerRepository<MergedRepositoryProvider.Coordinate>("merged", archenemyMojangExtension) {
+    data class Coordinate(val base: ModuleDependency, val overlay: ModuleDependency) : CHashable {
+        override fun updateHash(digest: MessageDigest) {
+            digest.update("merged")
+            digest.updateGMV("base", base)
+            digest.updateGMV("overlay", overlay)
+        }
+    }
+
+    override fun getName(t: Coordinate): String {
+        return t.base.name
+    }
+
+    override fun getVersion(t: Coordinate): String {
+        return t.base.version!!
+    }
+
+    override fun getArtifact(identifier: ArtifactIdentifier, value: Coordinate, file: File): Artifact? {
+        if (!identifier.classifier.isNullOrBlank())
+            return null
+        if (identifier.extension != "jar") return null
+        val baseJar = resolveDirect(value.base).singleOrNull() ?: return null
+        val overlayJar = resolveDirect(value.overlay).singleOrNull() ?: return null
+        return StreamableArtifact.ofStreamable(
+            identifier,
+            ArtifactType.BINARY,
+            lazyTransform(file) { mergeJar(baseJar, overlayJar, it) })
+    }
+
+    private fun readClasses(
+        path: Path,
+        readClassFile: (String, ClassNode) -> Unit,
+        readResource: (String, InputStream) -> Unit
+    ) {
+        path.readZipFs { path, inputStream ->
+            if (path.startsWith("META-INF/")) return@readZipFs
+            if (path.endsWith(".class")) {
+                val classReader = ClassReader(inputStream)
+                val classNode = ClassNode()
+                classReader.accept(classNode, 0)
+                readClassFile(path, classNode)
+            } else {
+                readResource(path, inputStream)
+            }
+        }
+    }
+
+    fun mergeClass(base: ClassNode, overlay: ClassNode): ClassNode {
+        return ClassMerger().accept(base, overlay)
+    }
+
+    private fun mergeJar(baseJar: File, overlayJar: File, target: File) {
+        target.toPath().zipFs().use { fs ->
+            val classNodes = mutableMapOf<String, ClassNode>()
+            fun readResource(path: String, inputStream: InputStream) {
+                val p = fs.getPath(path)
+                p.parent?.createDirectories()
+                p.outputStream().use { outputStream ->
+                    inputStream.copyTo(outputStream)
+                }
+            }
+
+            fun readClass(path: String, classNode: ClassNode) {
+                classNodes.merge(path, classNode, ::mergeClass)
+            }
+            readClasses(baseJar.toPath(), ::readClass, ::readResource)
+            readClasses(overlayJar.toPath(), ::readClass, ::readResource)
+            classNodes.forEach { (path, node) ->
+                val writer = ClassWriter(0)
+                node.accept(writer)
+                readResource(path, ByteArrayInputStream(writer.toByteArray()))
+            }
+        }
+    }
+}
diff --git a/plugin/src/main/kotlin/moe/nea/archenemy/util/DigestUtils.kt b/plugin/src/main/kotlin/moe/nea/archenemy/util/DigestUtils.kt
index 4f50000..d2de936 100644
--- a/plugin/src/main/kotlin/moe/nea/archenemy/util/DigestUtils.kt
+++ b/plugin/src/main/kotlin/moe/nea/archenemy/util/DigestUtils.kt
@@ -1,5 +1,6 @@
 package moe.nea.archenemy.util
 
+import org.gradle.api.artifacts.ModuleDependency
 import java.security.MessageDigest
 
 fun MessageDigest.updateField(text: String, value: String) {
@@ -11,4 +12,11 @@ fun MessageDigest.updateField(text: String, value: String) {
 
 fun MessageDigest.update(text: String) {
     this.update(text.encodeToByteArray())
+}
+
+fun MessageDigest.updateGMV(name: String, moduleDependency: ModuleDependency) {
+    this.updateField(
+        name,
+        (moduleDependency.group ?: "") + ":" + moduleDependency.name + ":" + (moduleDependency.version ?: "")
+    )
 }
\ No newline at end of file
diff --git a/plugin/src/main/kotlin/moe/nea/archenemy/util/EnvType.kt b/plugin/src/main/kotlin/moe/nea/archenemy/util/EnvType.kt
new file mode 100644
index 0000000..72d18b6
--- /dev/null
+++ b/plugin/src/main/kotlin/moe/nea/archenemy/util/EnvType.kt
@@ -0,0 +1,9 @@
+package moe.nea.archenemy.util
+
+enum class EnvType(val classifier: String?, val mcp: Int) {
+    CLIENT("client", 0),
+    SERVER("server", 1),
+    COMBINED(null, 2),
+    DATAGEN("server", 1)
+    ;
+}
\ No newline at end of file
diff --git a/plugin/src/main/kotlin/moe/nea/archenemy/util/FSUtil.kt b/plugin/src/main/kotlin/moe/nea/archenemy/util/FSUtil.kt
new file mode 100644
index 0000000..0b2f70e
--- /dev/null
+++ b/plugin/src/main/kotlin/moe/nea/archenemy/util/FSUtil.kt
@@ -0,0 +1,33 @@
+package moe.nea.archenemy.util
+
+import java.io.InputStream
+import java.net.URI
+import java.nio.file.FileSystem
+import java.nio.file.FileSystems
+import java.nio.file.Path
+import java.util.zip.ZipInputStream
+import java.util.zip.ZipOutputStream
+import kotlin.io.path.createDirectories
+import kotlin.io.path.exists
+import kotlin.io.path.inputStream
+import kotlin.io.path.outputStream
+
+// TODO: Figure out license shit with unimined cause i copied some of these utils?
+fun Path.zipFs(): FileSystem {
+    if (!exists()) {
+        parent.createDirectories()
+        ZipOutputStream(this.outputStream()).use { }
+    }
+    return FileSystems.newFileSystem(URI.create("jar:${toUri()}"), mapOf("create" to true), null)
+}
+
+fun Path.readZipFs(reader: (String, InputStream) -> Unit) {
+    ZipInputStream(this.inputStream()).use { stream ->
+        for (entry in generateSequence { stream.nextEntry }) {
+            if (entry.isDirectory) {
+                continue
+            }
+            reader(entry.name, stream)
+        }
+    }
+}