build.gradle

import java.io.DataInputStream
import java.nio.charset.StandardCharsets
import java.security.MessageDigest
import java.util.HexFormat
import java.util.Locale
import java.util.Properties
import java.util.jar.JarFile
import java.util.regex.Matcher
import org.gradle.api.tasks.WriteProperties

plugins {
    id "java"
    id "com.gradleup.shadow" version "${shadowVer}"
}

group = "com.github.kaspiandev.antipopup"
def semanticVersion = providers.gradleProperty("pluginVersion").get()
def buildNumber = providers.gradleProperty("pluginBuild").get()
if (!(semanticVersion ==~ /\d+\.\d+\.\d+/)) {
    throw new GradleException("pluginVersion must be a semantic version")
}
if (!(buildNumber ==~ /\d{3}/)) {
    throw new GradleException("pluginBuild must contain exactly three digits")
}
def releaseVersion = "${semanticVersion}-${buildNumber}"
version = releaseVersion
def expectedPaperTarget = providers.gradleProperty("paperTarget").get()
def expectedPaperApi = providers.gradleProperty("paperApiVersion").get()
def expectedPaperBuild = providers.gradleProperty("paperBuild").get()
def expectedPaperChannel = providers.gradleProperty("paperChannel").get()
def expectedPaperJarName = providers.gradleProperty("paperJarName").get()
def expectedPaperJarSha256 = providers.gradleProperty("paperJarSha256").get()
def javaTarget = providers.gradleProperty("javaTarget").get().toInteger()
def buildJdkVersion = providers.gradleProperty("buildJdkVersion").get()
def runtimeJdk25Version = providers.gradleProperty("runtimeJdk25Version").get()
def runtimeJdk26Version = providers.gradleProperty("runtimeJdk26Version").get()
def expectedPaperApiFromRelease =
        "${expectedPaperTarget}.build.${expectedPaperBuild}-${expectedPaperChannel.toLowerCase(Locale.ROOT)}"
if (expectedPaperApi != expectedPaperApiFromRelease) {
    throw new GradleException(
            "paperApiVersion must match release metadata: ${expectedPaperApiFromRelease}")
}
if (expectedPaperChannel != "STABLE") {
    throw new GradleException("Certified releases must use the STABLE Paper channel")
}
if (expectedPaperJarName != "Paper-${expectedPaperTarget}.jar") {
    throw new GradleException("paperJarName must use Paper-{version}.jar")
}
if (!(expectedPaperJarSha256 ==~ /[0-9a-f]{64}/)) {
    throw new GradleException("paperJarSha256 must be a lowercase SHA-256")
}
if (javaTarget != 25) {
    throw new GradleException("AntiPopup must continue to emit Java 25 bytecode")
}
def expectedArchiveName =
        "1MB-AntiPopup-v${version}-j${javaTarget}-${expectedPaperTarget}.jar"
def expectedClassMajor = javaTarget + 44
def releaseFacts = [
        artifactName       : expectedArchiveName,
        buildJdkVersion    : buildJdkVersion,
        buildNumber        : buildNumber,
        javaTarget         : javaTarget.toString(),
        paperApiVersion    : expectedPaperApi,
        paperBuild         : expectedPaperBuild,
        paperChannel       : expectedPaperChannel,
        paperJarName       : expectedPaperJarName,
        paperJarSha256     : expectedPaperJarSha256,
        paperTarget        : expectedPaperTarget,
        runtimeJdk25Version: runtimeJdk25Version,
        runtimeJdk26Version: runtimeJdk26Version,
        semanticVersion    : semanticVersion,
        version            : releaseVersion
]

repositories {
    mavenCentral()
    maven {
        name = "paper"
        url = "https://repo.papermc.io/repository/maven-public/"
    }
    maven {
        name = "codemcReleases"
        url = "https://repo.codemc.io/repository/maven-releases/"
    }
}

dependencies {
    compileOnly("io.papermc.paper:paper-api:${paperApiVersion}") {
        exclude group: "org.apache.logging.log4j"
    }

    implementation("com.github.retrooper:packetevents-spigot:${packetEventsVersion}") {
        // Paper supplies Adventure. PacketEvents 2.13 supports Paper's Adventure 5.
        exclude group: "net.kyori"
    }
    // Paper exposes Adventure API 5 (including BinaryTagHolder), but not the
    // implementation NBT module. Bundle the matching module without relocating
    // its public package so PacketEvents and Paper share one Adventure type system.
    implementation("net.kyori:adventure-nbt:${adventureNbtVersion}") {
        transitive = false
    }
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(javaTarget)
    }
}

def buildCompiler = javaToolchains.compilerFor(java.toolchain)
def verifyBuildJdk = tasks.register("verifyBuildJdk") {
    group = "verification"
    description = "Verifies the selected compiler matches the recorded release JDK."
    inputs.property("expectedVersion", buildJdkVersion)
    inputs.property("compilerVersion", buildCompiler.map { it.metadata.javaRuntimeVersion })

    doLast {
        String actualVersion = inputs.properties.compilerVersion
        String expectedVersion = inputs.properties.expectedVersion
        if (Runtime.Version.parse(actualVersion).version()
                != Runtime.Version.parse(expectedVersion).version()) {
            throw new GradleException(
                    "Build requires JDK ${expectedVersion}; selected ${actualVersion}. "
                            + "Set JAVA_HOME and prepend JAVA_HOME/bin to PATH.")
        }
        println("Verified build compiler: ${actualVersion}")
    }
}

tasks.withType(JavaCompile).configureEach {
    dependsOn verifyBuildJdk
    options.release = javaTarget
    options.encoding = "UTF-8"
    options.compilerArgs.addAll(["-Xlint:deprecation", "-Xlint:removal", "-Werror"])
}

processResources {
    def props = [version: releaseVersion, paperTarget: expectedPaperTarget]
    inputs.properties(props)
    filteringCharset = "UTF-8"
    filesMatching("plugin.yml") {
        expand(props)
    }
}

def generatedReleaseMetadataDir = layout.buildDirectory.dir("generated/releaseMetadata")
def generateReleaseMetadata = tasks.register("generateReleaseMetadata", WriteProperties) {
    group = "build"
    description = "Generates the release facts embedded in the deployable JAR."
    destinationFile = generatedReleaseMetadataDir.map {
        it.file("META-INF/antipopup-release.properties")
    }
    comment = "Generated from gradle.properties; do not edit."
    releaseFacts.each { key, value -> property(key, value) }
}

sourceSets.main.resources.srcDir(generatedReleaseMetadataDir)
tasks.named("processResources") {
    dependsOn generateReleaseMetadata
}

jar {
    enabled = false
}

shadowJar {
    archiveFileName = expectedArchiveName
    archiveClassifier = ""
    mergeServiceFiles()

    // PacketEvents 2.13 unconditionally constructs its bundled bStats service.
    // Rewrite only those three linkage types to inert local shims, then omit the
    // complete telemetry implementation from the standalone artifact.
    relocate "io.github.retrooper.packetevents.bstats.bukkit.Metrics", "com.github.kaspiandev.antipopup.paper.compat.packetevents.NoOpMetrics"
    relocate "io.github.retrooper.packetevents.bstats.charts.CustomChart", "com.github.kaspiandev.antipopup.paper.compat.packetevents.NoOpChart"
    relocate "io.github.retrooper.packetevents.bstats.charts.SimplePie", "com.github.kaspiandev.antipopup.paper.compat.packetevents.NoOpSimplePie"
    relocate "io.github.retrooper.packetevents", "com.github.kaspiandev.antipopup.libs.packetevents.impl"
    relocate "com.github.retrooper.packetevents", "com.github.kaspiandev.antipopup.libs.packetevents.api"
    exclude "io/github/retrooper/packetevents/bstats/**"
    exclude "META-INF/*.SF", "META-INF/*.DSA", "META-INF/*.RSA"

    manifest {
        attributes(
                "Implementation-Title": "1MB AntiPopup",
                "Implementation-Version": releaseVersion,
                "Artifact-Name": expectedArchiveName,
                "Built-For-Paper": expectedPaperTarget,
                "Compiled-Paper-API": expectedPaperApi,
                "Paper-Build": expectedPaperBuild,
                "Paper-Channel": expectedPaperChannel,
                "Build-Java": javaTarget.toString()
        )
    }
}

assemble {
    dependsOn shadowJar
}

def shadowArchive = tasks.named("shadowJar").flatMap { it.archiveFile }

tasks.register("verifyArtifact") {
    group = "verification"
    description = "Checks the deployable jar's target, bytecode, and removed-feature exclusions."
    dependsOn shadowJar
    inputs.file(shadowArchive)

    doLast {
        File archive = inputs.files.singleFile
        if (archive.name != expectedArchiveName) {
            throw new GradleException(
                    "Expected artifact ${expectedArchiveName}, found ${archive.name}")
        }
        new JarFile(archive).withCloseable { jar ->
            Set<String> names = jar.entries().collect { it.name } as Set
            List<String> forbiddenPrefixes = [
                    "com/github/kaspiandev/antipopup/velocity/",
                    "com/github/kaspiandev/antipopup/spigot/",
                    "com/github/kaspiandev/antipopup/nms/",
                    "net/md_5/bungee/"
            ]

            forbiddenPrefixes.each { prefix ->
                if (names.any { it.startsWith(prefix) }) {
                    throw new GradleException("Legacy content found in deployable jar: ${prefix}")
                }
            }

            if (names.any { it.contains("/bstats/") }) {
                throw new GradleException("bStats implementation found in deployable jar")
            }
            String forbiddenLog4jPrefix = "org/apache/logging/log4j/"
            if (names.any { it.startsWith(forbiddenLog4jPrefix) }) {
                throw new GradleException("Log4j implementation found in deployable jar")
            }
            List<String> metricsShims = [
                    "com/github/kaspiandev/antipopup/paper/compat/packetevents/NoOpMetrics.class",
                    "com/github/kaspiandev/antipopup/paper/compat/packetevents/NoOpChart.class",
                    "com/github/kaspiandev/antipopup/paper/compat/packetevents/NoOpSimplePie.class"
            ]
            if (!names.containsAll(metricsShims)) {
                throw new GradleException("PacketEvents metrics suppression shims are missing")
            }
            String paperPluginPrefix =
                    "com/github/kaspiandev/antipopup/paper/"
            Set<String> expectedPaperClasses = ([
                    "com/github/kaspiandev/antipopup/paper/AntiPopup.class",
                    "com/github/kaspiandev/antipopup/paper/listener/PacketEventsListener.class"
            ] + metricsShims) as Set
            Set<String> actualPaperClasses = names.findAll {
                it.startsWith(paperPluginPrefix) && it.endsWith(".class")
            } as Set
            if (actualPaperClasses != expectedPaperClasses) {
                Set<String> missing = expectedPaperClasses.findAll {
                    !actualPaperClasses.contains(it)
                } as Set
                Set<String> unexpected = actualPaperClasses.findAll {
                    !expectedPaperClasses.contains(it)
                } as Set
                throw new GradleException(
                        "Unexpected AntiPopup class surface; missing=${missing}, unexpected=${unexpected}")
            }
            String packetEventsBuilder =
                    "com/github/kaspiandev/antipopup/libs/packetevents/impl/factory/spigot/SpigotPacketEventsBuilder\$1.class"
            def packetEventsBuilderEntry = jar.getJarEntry(packetEventsBuilder)
            if (packetEventsBuilderEntry == null) {
                throw new GradleException("The embedded PacketEvents builder is missing")
            }
            String packetEventsBuilderBytes = new String(
                    jar.getInputStream(packetEventsBuilderEntry).readAllBytes(),
                    StandardCharsets.ISO_8859_1)
            metricsShims.each { shim ->
                String internalName = shim.substring(0, shim.length() - ".class".length())
                if (!packetEventsBuilderBytes.contains(internalName)) {
                    throw new GradleException(
                            "PacketEvents metrics linkage was not redirected to ${internalName}")
                }
            }

            if (!names.contains("net/kyori/adventure/nbt/CompoundBinaryTag.class")) {
                throw new GradleException("The Paper-aligned Adventure NBT module is missing")
            }
            if (names.contains("net/kyori/adventure/nbt/api/BinaryTagHolder.class")
                    || names.contains("net/kyori/adventure/text/Component.class")) {
                throw new GradleException("The deployable jar must use Paper's Adventure API")
            }

            String brokenAdventurePrefix =
                    "com/github/kaspiandev/antipopup/libs/adventure/"
            List<String> forbiddenOwnMarkers = [
                    "org/bukkit/command/",
                    "org/bukkit/configuration/",
                    "getCommand",
                    "getConfig",
                    "reloadConfig",
                    "saveDefaultConfig",
                    "server.properties",
                    "enforce-secure-profile",
                    "ServerPropertiesService",
                    "CommandRegister",
                    "APConfig",
                    "PluginSettings"
            ]
            names.findAll { it.endsWith(".class") }.each { name ->
                String classFile = new String(
                        jar.getInputStream(jar.getJarEntry(name)).readAllBytes(),
                        StandardCharsets.ISO_8859_1)
                if (classFile.contains(brokenAdventurePrefix)) {
                    throw new GradleException(
                            "Found an incompletely relocated Adventure reference in ${name}")
                }
                if (classFile.contains(forbiddenLog4jPrefix)) {
                    throw new GradleException(
                            "Found a Log4j linkage in ${name}")
                }
                if (name.startsWith(paperPluginPrefix)) {
                    forbiddenOwnMarkers.each { marker ->
                        if (classFile.contains(marker)) {
                            throw new GradleException(
                                    "Found removed command/config/setup linkage in ${name}: ${marker}")
                        }
                    }
                }
            }

            if (names.contains("config.yml")) {
                throw new GradleException("Removed config.yml found in deployable jar")
            }

            String listenerClass =
                    "com/github/kaspiandev/antipopup/paper/listener/PacketEventsListener.class"
            String listenerClassBytes = new String(
                    jar.getInputStream(jar.getJarEntry(listenerClass)).readAllBytes(),
                    StandardCharsets.ISO_8859_1)
            List<String> requiredListenerMarkers = [
                    "JOIN_GAME",
                    "isCancelled",
                    "WrapperPlayServerJoinGame",
                    "setEnforcesSecureChat"
            ]
            requiredListenerMarkers.each { marker ->
                if (!listenerClassBytes.contains(marker)) {
                    throw new GradleException(
                            "Popup-only listener behavior is missing: ${marker}")
                }
            }
            List<String> forbiddenListenerMarkers = [
                    "SERVER_DATA",
                    "WrapperPlayServerServerData",
                    "ClientVersion",
                    "PluginSettings",
                    "settingsSupplier",
                    "CHAT_SESSION_UPDATE",
                    "CHAT_MESSAGE",
                    "WrapperPlayServerDisguisedChat",
                    "onPacketReceive"
            ]
            forbiddenListenerMarkers.each { marker ->
                if (listenerClassBytes.contains(marker)) {
                    throw new GradleException(
                            "Removed listener behavior found in artifact: ${marker}")
                }
            }

            String mainClass = "com/github/kaspiandev/antipopup/paper/AntiPopup.class"
            def mainEntry = jar.getJarEntry(mainClass)
            if (mainEntry == null) {
                throw new GradleException("Paper main class is missing from deployable jar")
            }
            String mainClassBytes = new String(
                    jar.getInputStream(mainEntry).readAllBytes(),
                    StandardCharsets.ISO_8859_1)
            List<String> requiredLifecycleMarkers = [
                    "SpigotPacketEventsBuilder",
                    "registerListener",
                    "PacketListenerPriority",
                    "META-INF/antipopup-release.properties",
                    "getPluginMeta",
                    "load",
                    "init",
                    "terminate"
            ]
            requiredLifecycleMarkers.each { marker ->
                if (!mainClassBytes.contains(marker)) {
                    throw new GradleException(
                            "Embedded PacketEvents lifecycle is missing: ${marker}")
                }
            }

            jar.getInputStream(mainEntry).withCloseable { stream ->
                DataInputStream input = new DataInputStream(stream)
                input.skipNBytes(6)
                int major = input.readUnsignedShort()
                if (major != expectedClassMajor) {
                    throw new GradleException(
                            "Expected Java ${javaTarget} class major ${expectedClassMajor}, found ${major}")
                }
            }

            String descriptor = jar.getInputStream(jar.getJarEntry("plugin.yml"))
                    .getText("UTF-8")
            if (!descriptor.contains("api-version: '${expectedPaperTarget}'")
                    || !descriptor.contains("version: '${releaseVersion}'")
                    || !descriptor.contains("main: com.github.kaspiandev.antipopup.paper.AntiPopup")) {
                throw new GradleException(
                        "plugin.yml is not the expected Paper ${expectedPaperTarget} descriptor")
            }
            ["commands", "permissions", "softdepend", "depend", "loadbefore"].each { key ->
                if (descriptor.readLines().any {
                    it == "${key}:" || it.startsWith("${key}: ")
                }) {
                    throw new GradleException(
                            "Removed plugin.yml section found in deployable jar: ${key}")
                }
            }

            def metadataEntry = jar.getJarEntry("META-INF/antipopup-release.properties")
            if (metadataEntry == null) {
                throw new GradleException("Generated release metadata is missing")
            }
            Properties embeddedReleaseFacts = new Properties()
            jar.getInputStream(metadataEntry).withCloseable {
                embeddedReleaseFacts.load(it)
            }
            releaseFacts.each { key, value ->
                if (embeddedReleaseFacts.getProperty(key) != value.toString()) {
                    throw new GradleException(
                            "Embedded release metadata drift for ${key}: "
                                    + "${embeddedReleaseFacts.getProperty(key)} != ${value}")
                }
            }

            def manifestAttributes = jar.manifest.mainAttributes
            Map<String, String> expectedManifest = [
                    "Implementation-Title"  : "1MB AntiPopup",
                    "Implementation-Version": releaseVersion,
                    "Artifact-Name"         : expectedArchiveName,
                    "Built-For-Paper"       : expectedPaperTarget,
                    "Compiled-Paper-API"    : expectedPaperApi,
                    "Paper-Build"           : expectedPaperBuild,
                    "Paper-Channel"         : expectedPaperChannel,
                    "Build-Java"            : javaTarget.toString()
            ]
            expectedManifest.each { key, value ->
                if (manifestAttributes.getValue(key) != value) {
                    throw new GradleException(
                            "Manifest release metadata drift for ${key}: "
                                    + "${manifestAttributes.getValue(key)} != ${value}")
                }
            }
        }
    }
}

def releaseDocBlocks = [
        "README.md": """<!-- release-metadata:start -->
| Component | Certified release |
| --- | --- |
| Server | Paper `${expectedPaperTarget}` build `${expectedPaperBuild}` (`${expectedPaperChannel}`) |
| Paper API | `${expectedPaperApi}` |
| Java bytecode | Java `${javaTarget}` (class version `${expectedClassMajor}`) |
| Build JDK | Oracle JDK `${buildJdkVersion}` |
| Verified runtime JDKs | Oracle JDK `${runtimeJdk25Version}` and `${runtimeJdk26Version}` |
| Plugin version | `${releaseVersion}` |
| Artifact | `${expectedArchiveName}` |
<!-- release-metadata:end -->""",
        "docs/installation.md": """<!-- release-metadata:start -->
| Release fact | Value |
| --- | --- |
| Plugin | `${releaseVersion}` |
| Artifact | `${expectedArchiveName}` |
| Paper runtime | `${expectedPaperTarget}` build `${expectedPaperBuild}` (`${expectedPaperChannel}`) |
| Compiled Paper API | `${expectedPaperApi}` |
| Java bytecode | `${javaTarget}` |
| Verified runtimes | Oracle JDK `${runtimeJdk25Version}` and `${runtimeJdk26Version}` |
<!-- release-metadata:end -->""",
        "docs/troubleshooting.md": """<!-- release-metadata:start -->
Current release: `${releaseVersion}` in `${expectedArchiveName}`, compiled for
Paper API `${expectedPaperApi}` and Java `${javaTarget}`. Certified server:
Paper `${expectedPaperTarget}` build `${expectedPaperBuild}` (`${expectedPaperChannel}`).
<!-- release-metadata:end -->"""
]
def releaseMarkerPattern = /(?s)<!-- release-metadata:start -->.*?<!-- release-metadata:end -->/
def releaseDocFiles = releaseDocBlocks.keySet().collectEntries { path ->
    [(path): layout.projectDirectory.file(path).asFile]
}
def releaseMarkdownFiles = ([
        layout.projectDirectory.file("README.md").asFile
] + fileTree(layout.projectDirectory.dir("docs")) {
    include "**/*.md"
}.files).sort { it.path }
def dependencyLockFile = layout.projectDirectory.file("gradle.lockfile").asFile

tasks.register("syncReleaseDocs") {
    group = "documentation"
    description = "Rewrites only marker-bounded current release facts from gradle.properties."
    inputs.properties(releaseFacts)
    inputs.files(releaseDocFiles.values())
    outputs.files(releaseDocFiles.values())

    doLast {
        releaseDocBlocks.each { path, expectedBlock ->
            File doc = releaseDocFiles[path]
            String text = doc.getText("UTF-8")
            if (!(text =~ releaseMarkerPattern).find()) {
                throw new GradleException("Missing release metadata markers in ${path}")
            }
            doc.setText(
                    text.replaceFirst(releaseMarkerPattern, Matcher.quoteReplacement(expectedBlock)),
                    "UTF-8")
        }
    }
}

tasks.register("verifyReleaseDocs") {
    group = "verification"
    description = "Fails when current docs or locked Paper API drift from release properties."
    inputs.properties(releaseFacts)
    inputs.files(releaseMarkdownFiles)
    inputs.file(dependencyLockFile)

    doLast {
        releaseDocBlocks.each { path, expectedBlock ->
            String text = releaseDocFiles[path].getText("UTF-8")
            if (!text.contains(expectedBlock)) {
                throw new GradleException(
                        "Release documentation drift in ${path}; run ./gradlew syncReleaseDocs")
            }
        }

        def artifactPattern = ~/1MB-AntiPopup-v\d+\.\d+\.\d+-\d{3}-j\d+-\d+\.\d+\.jar/
        def paperApiPattern = ~/\d+\.\d+\.build\.\d+-(?:alpha|beta|stable)/
        releaseMarkdownFiles.each { doc ->
            String text = doc.getText("UTF-8")
            text.findAll(artifactPattern).each { artifact ->
                if (artifact != expectedArchiveName) {
                    throw new GradleException(
                            "Stale artifact example in ${doc}: ${artifact}")
                }
            }
            text.findAll(paperApiPattern).each { api ->
                if (api != expectedPaperApi) {
                    throw new GradleException("Stale Paper API in ${doc}: ${api}")
                }
            }
        }

        String expectedLock =
                "io.papermc.paper:paper-api:${expectedPaperApi}=compileClasspath"
        if (!dependencyLockFile.getText("UTF-8").contains(expectedLock)) {
            throw new GradleException(
                    "Paper API lock drift; expected ${expectedLock}")
        }
    }
}

tasks.register("printReleaseMetadata") {
    group = "help"
    description = "Prints canonical release facts for CI and release automation."
    doLast {
        releaseFacts.keySet().sort().each { key ->
            println("${key}=${releaseFacts[key]}")
        }
    }
}

def maintainedPaperJarPath = providers.gradleProperty("paperJarPath").orElse("")
tasks.register("verifyMaintainedPaperJar") {
    group = "verification"
    description = "Hashes a maintained Paper server JAR against the canonical release metadata."
    inputs.property("paperJarPath", maintainedPaperJarPath)
    inputs.property("expectedPaperJarName", expectedPaperJarName)
    inputs.property("expectedPaperJarSha256", expectedPaperJarSha256)

    doLast {
        String configuredPath = maintainedPaperJarPath.get()
        if (configuredPath.isBlank()) {
            throw new GradleException(
                    "Pass -PpaperJarPath=/absolute/path/${expectedPaperJarName}")
        }

        File paperJar = new File(configuredPath)
        if (!paperJar.isFile()) {
            throw new GradleException("Paper JAR does not exist: ${paperJar}")
        }
        if (paperJar.name != expectedPaperJarName) {
            throw new GradleException(
                    "Expected Paper JAR name ${expectedPaperJarName}, found ${paperJar.name}")
        }

        MessageDigest digest = MessageDigest.getInstance("SHA-256")
        paperJar.withInputStream { input ->
            byte[] buffer = new byte[64 * 1024]
            for (int read = input.read(buffer); read != -1; read = input.read(buffer)) {
                digest.update(buffer, 0, read)
            }
        }
        String actualSha256 = HexFormat.of().formatHex(digest.digest())
        if (actualSha256 != expectedPaperJarSha256) {
            throw new GradleException(
                    "Paper JAR SHA-256 mismatch: ${actualSha256} != ${expectedPaperJarSha256}")
        }
        println("Verified ${paperJar}: ${actualSha256}")
    }
}

check {
    dependsOn tasks.named("verifyArtifact")
    dependsOn tasks.named("verifyReleaseDocs")
}

dependencyLocking {
    lockAllConfigurations()
}