Upgrade Minestom dependency to 2026.05.17-1.21.11 (#2)

* Update to Minecraft 1.21.11

* Add shared module for Fabric, NeoForge and Forge

* Fix shared module context keys (LuckPerms#4206)

* Add UUID mismatch warning suppression setting (LuckPerms#4194)

* Hytale (LuckPerms#4213)

* Improve Hytale PermissionProvider compatibility

* Add Hytale with-deps Gradle buildscript

* Fix yaml dependency issue in Hytale jar (LuckPerms#4229)

* Relocate guava and gson in Hytale jar

* Refactor PermissionProcessors

* Attempt to fix slf4j classloading issue on Hytale

* Add inheritance origin metadata for Hytale virtual groups

* Fix duplicate readNode call in SqlStorage

* Remove Hytale chat formatter and update deps

* Improve debug logging for Hytale login handling

* Add rate limit for verbose chat output

* Update bytebin/bytesocks custom config settings

* Add support for NATS token authentication (LuckPerms#4238)

* Update Gradle to v9.4

* Update Hytale to target 2026.03.26-89796e57b

* Update to Minecraft 26.1

* Fix Fabric shadowJar config

* Add index to time column in SQL Messenger (LuckPerms#4255)

* Add context argument to group listmembers command (LuckPerms#4252)

* Add Redis Sentinel support for messaging (LuckPerms#4244)

* build: target latest Minestom (2026.05.17-1.21.11) and publish snapshot from deployment branch

Bumps the Minestom compileOnly dependency in the minestom and
minestom:loader modules from 2025.08.29-1.21.8 to the current Maven
Central release so the OneLiteFeather LuckPerms fork builds against the
Minestom version Titan deploys with. Adds the deployment branch to the
CI publish trigger so net.luckperms:*:5.6-SNAPSHOT is deployed to the
OneLiteFeather repository for downstream Butterfly/Titan builds.

https://claude.ai/code/session_01S76fk9ma5Szkf9r1W44RVP

* build: compile Minestom modules on Java 25 toolchain

Minestom 2026.05.17-1.21.11 requires a JVM 25+ runtime, so the
relocation-free minestom and minestom:loader modules can no longer be
built against Java 21 (':minestom:compileJava' failed to resolve the
dependency). Switch both modules to a Java 25 toolchain and install
JDK 25 alongside 21 in CI; JDK 21 stays the default JAVA_HOME so the
Forge/Fabric/NeoForge platform builds are unaffected and only the
Minestom modules use the 25 toolchain.

https://claude.ai/code/session_01S76fk9ma5Szkf9r1W44RVP

* ci: build entire project on JDK 25

The 21/25 split did not work: Gradle's toolchain auto-detection does not
pick up the JDK 25 that setup-java installs as a secondary version, so
':minestom:compileJava' still could not resolve the Java 25 Minestom
dependency. Run the whole build on JDK 25, consistent with the Titan,
Butterfly and shared OneLiteFeather workflows.

https://claude.ai/code/session_01S76fk9ma5Szkf9r1W44RVP

* ci: run Gradle on JDK 21, expose JDK 25 toolchain via env

Gradle 8.14.3 cannot run on JDK 25 ('Unsupported class file major
version 69'), so the full-JDK-25 runtime broke the build script
compilation. Keep the Gradle runtime on JDK 21 (last entry, so it is
the default JAVA_HOME) and additionally install JDK 25, exposing it to
Gradle toolchain detection via org.gradle.java.installations.fromEnv so
only the Java 25 Minestom modules use it.

https://claude.ai/code/session_01S76fk9ma5Szkf9r1W44RVP

* build: use Java 25 toolchain for minestom:app (Gradle 9)

Gradle 9 removed project-level sourceCompatibility/targetCompatibility,
which broke ':minestom:app' evaluation after the upstream merge. Replace
them with a Java 25 toolchain, consistent with the minestom and
minestom:loader modules.

https://claude.ai/code/session_01S76fk9ma5Szkf9r1W44RVP

* build: migrate minestom:app to Blossom 2.x DSL

The upstream merge brought net.kyori.blossom 2.2.0, whose DSL replaced
the top-level blossom { replaceTokenIn / replaceToken } block. Use the
sourceSets.main.blossom.javaSources.property form (matching upstream
common/build.gradle) and the {{ version }} placeholder in
LuckPermsApplication.

https://claude.ai/code/session_01S76fk9ma5Szkf9r1W44RVP

* build: override options.release=25 for minestom modules

The root subprojects block forces options.release=11 on every module's
JavaCompile tasks, which set the org.gradle.jvm.version attribute to 11
and made ':minestom:compileJava' reject Minestom 2026.05.17-1.21.11
(requires JVM 25+). Override release to 25 in the three minestom modules
so the Java 25 toolchain compiler targets 25 and the dependency resolves.

https://claude.ai/code/session_01S76fk9ma5Szkf9r1W44RVP

* fix(minestom): adapt to upstream LuckPerms common API

The upstream merge changed the common permission-calculator API.
Port MinestomCalculatorFactory to the new CalculatorFactory.build
signature (QueryOptions, Map<String,Node>, CacheMetadata), pass the
source map to the now-parameterised processors, and return the concrete
PermissionCalculatorMonitored instead of the now-abstract
PermissionCalculator (mirrors StandaloneCalculatorFactory). Add the
slf4j-api compile dependency that common no longer exposes transitively.

https://claude.ai/code/session_01S76fk9ma5Szkf9r1W44RVP

* build: keep project group me.lucko.luckperms, publish as net.luckperms

The fork overrode project.group to net.luckperms, which made upstream's
loader shadowJars (include(dependency('me.lucko.luckperms:.*'))) drop
:common, :api and :loader-utils. That broke the standalone jar-in-jar
(NoClassDefFoundError: common.dependencies.DependencyManager during the
preloadDependencies Docker step) and would affect every upstream
platform loader.

Restore project.group to me.lucko.luckperms (matching root subprojects
so the shadow include filters match again) and set groupId =
net.luckperms explicitly on each MavenPublication, so the published
coordinates (net.luckperms:api/common/loader-utils/minestom/
minestom-app/minestom-loader) consumed by Butterfly and Titan stay
unchanged.

https://claude.ai/code/session_01S76fk9ma5Szkf9r1W44RVP

* build: publish all LuckPerms platform/loader modules to OLF repo

Adds a shared publishing convention so every remaining platform and
loader module (bukkit/bungee/velocity/fabric/forge/neoforge/sponge/
nukkit/standalone/hytale + loaders, common:minecraft) is deployed to the
OneLiteFeather repository as net.luckperms:<dashed-path>, publishing the
shadowJar for loader modules and the java component otherwise. The six
modules with bespoke publications (api, common, loader-utils, minestom,
minestom-app, minestom-loader) are excluded and unchanged.

https://claude.ai/code/session_01S76fk9ma5Szkf9r1W44RVP

* ci: dedupe concurrent push/PR runs to stop Harbor push race

The push and pull_request triggers spawned two concurrent runs for the
same commit, racing on the Harbor image push (build-docker failing with
'blob upload invalid'). Add a concurrency group keyed on the head commit
SHA (shared by both events) with cancel-in-progress, so only one run per
commit executes.

https://claude.ai/code/session_01S76fk9ma5Szkf9r1W44RVP

* ci: drop feature-branch push trigger

Remove the claude/titan-minestom-deployment-XhoNO push trigger; the
pull_request trigger on PR #2 already runs build/test/publish, so the
extra push trigger only added a redundant concurrent run.

https://claude.ai/code/session_01S76fk9ma5Szkf9r1W44RVP

---------

Co-authored-by: lucko <git@lucko.me>
Co-authored-by: Drex <nicknamedrex@gmail.com>
Co-authored-by: John <mcmdev1337@gmail.com>
Co-authored-by: powercas_gamer <cas@mizule.dev>
Co-authored-by: Yannick Schinko <yannick@tedworld.de>
Co-authored-by: Dominik <43303963+0ptk@users.noreply.github.com>
Co-authored-by: masel.io <git@byteexception.eu>
Co-authored-by: claude <claude@anthropic.com>

Author: 9 people

.github/workflows/ci.yml

@@ -14,6 +14,10 @@ env:
   REGISTRY: ghcr.io
   IMAGE_NAME: ${{ github.repository }}
 
+concurrency:
+  group: ci-${{ github.event.pull_request.head.sha || github.sha }}
+  cancel-in-progress: true
+
 jobs:
   build-gradle:
     runs-on: ubuntu-latest
@@ -27,7 +31,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
-          java-version: '21'
+          java-version: '25'
 
       - name: Setup Gradle
         uses: gradle/actions/setup-gradle@v4

api/build.gradle

@@ -1,7 +1,8 @@
-group = 'net.luckperms'
+group = 'me.lucko.luckperms'
 
-sourceCompatibility = 1.8
-targetCompatibility = 1.8
+tasks.withType(JavaCompile).configureEach {
+    options.release = 8
+}
 
 jar {
     manifest {
@@ -65,6 +66,7 @@ publishing {
     publications {
         mavenJava(MavenPublication) {
             artifactId = 'api'
+            groupId = 'net.luckperms'
 
             from components.java
 

api/src/main/java/net/luckperms/api/platform/Platform.java

@@ -79,7 +79,8 @@ enum Type {
         NEOFORGE("NeoForge"),
         FORGE("Forge"),
         MINESTOM("Minestom"),
-        STANDALONE("Standalone");
+        STANDALONE("Standalone"),
+        HYTALE("Hytale");
 
         private final String friendlyName;
 

build.gradle

@@ -1,26 +1,23 @@
 plugins {
     alias(libs.plugins.licenser) apply false
     id 'org.cyclonedx.bom' version '3.0.1'
+    alias(libs.plugins.loom) apply false
 }
 
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat
 import org.gradle.api.tasks.testing.logging.TestLogEvent
 
-defaultTasks 'licenseFormat', 'build'
-
 subprojects {
     apply plugin: 'java'
     apply plugin: 'maven-publish'
-    apply plugin: 'org.cadixdev.licenser'
+    apply plugin: 'dev.yumi.gradle.licenser'
 
     group = 'me.lucko.luckperms'
     version = '5.6-SNAPSHOT'
 
-    sourceCompatibility = 11
-    targetCompatibility = 11
-
     tasks.withType(JavaCompile).configureEach {
         options.encoding = 'UTF-8'
+        options.release = 11
     }
 
     tasks.withType(Test).configureEach {
@@ -38,18 +35,11 @@ subprojects {
     }
 
     def determinePatchVersion = {
-        // get the name of the last tag
-        def tagInfo = new ByteArrayOutputStream()
-        exec {
+        def tagInfo = providers.exec {
             commandLine 'git', 'describe', '--tags'
-            standardOutput = tagInfo
-        }
-        tagInfo = tagInfo.toString()
+        }.standardOutput.asText.get().trim()
 
-        if (!tagInfo.contains('-')) {
-            return 0
-        }
-        return tagInfo.split("-")[1]
+        return tagInfo.contains('-') ? tagInfo.split('-')[1] : 0
     }
 
     project.ext.majorVersion = '5'
@@ -59,9 +49,8 @@ subprojects {
     project.ext.fullVersion = project.ext.apiVersion + '.' + project.ext.patchVersion
 
     license {
-        header = rootProject.file('HEADER.txt')
-        include '**/*.java'
-        newLine = true
+        rule(rootProject.file("HEADER.txt"))
+        exclude '*.xml'
     }
 
     repositories {
@@ -80,3 +69,64 @@ subprojects {
         maven { url 'https://libraries.minecraft.net/' }
     }
 }
+
+// Publish every remaining LuckPerms platform/loader module to the
+// OneLiteFeather repository as net.luckperms:<dashed-path>. The six modules
+// that already define their own publication (api, common, loader-utils,
+// minestom, minestom-app, minestom-loader) are intentionally excluded.
+def olfExtraPublishPaths = [
+        ':bukkit', ':bukkit:loader', ':bukkit-legacy', ':bukkit-legacy:loader',
+        ':bungee', ':bungee:loader', ':velocity',
+        ':fabric', ':forge', ':forge:loader', ':neoforge', ':neoforge:loader',
+        ':sponge', ':sponge:loader', ':sponge:sponge-service', ':sponge:sponge-service-proxy',
+        ':nukkit', ':nukkit:loader',
+        ':standalone', ':standalone:app', ':standalone:loader',
+        ':hytale', ':hytale:loader', ':hytale:loader-with-deps',
+        ':common:minecraft'
+] as Set
+
+subprojects {
+    afterEvaluate { proj ->
+        if (!olfExtraPublishPaths.contains(proj.path)) {
+            return
+        }
+
+        def shadowTask = proj.tasks.findByName('shadowJar')
+        def hasJavaComponent = proj.components.findByName('java') != null
+        if (shadowTask == null && !hasJavaComponent) {
+            return
+        }
+
+        proj.publishing {
+            publications {
+                if (findByName('mavenJava') == null && findByName('maven') == null && findByName('olf') == null) {
+                    olf(MavenPublication) {
+                        groupId = 'net.luckperms'
+                        artifactId = proj.path.substring(1).replace(':', '-')
+                        version = proj.version
+                        if (shadowTask != null) {
+                            artifact(shadowTask)
+                        } else {
+                            from proj.components.java
+                        }
+                    }
+                }
+            }
+            repositories {
+                maven {
+                    name = 'OneLiteFeatherRepository'
+                    def snapshotsRepoUrl = uri('https://repo.onelitefeather.dev/onelitefeather-snapshots')
+                    def releasesRepoUrl = uri('https://repo.onelitefeather.dev/onelitefeather-releases')
+                    url = proj.version.toString().contains('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
+                    credentials(PasswordCredentials) {
+                        username = System.getenv('ONELITEFEATHER_MAVEN_USERNAME')
+                        password = System.getenv('ONELITEFEATHER_MAVEN_PASSWORD')
+                    }
+                    authentication {
+                        basic(BasicAuthentication)
+                    }
+                }
+            }
+        }
+    }
+}

bukkit/src/main/java/me/lucko/luckperms/bukkit/calculator/BukkitCalculatorFactory.java

@@ -30,17 +30,20 @@
 import me.lucko.luckperms.common.cacheddata.CacheMetadata;
 import me.lucko.luckperms.common.calculator.CalculatorFactory;
 import me.lucko.luckperms.common.calculator.PermissionCalculator;
+import me.lucko.luckperms.common.calculator.PermissionCalculatorMonitored;
 import me.lucko.luckperms.common.calculator.processor.DirectProcessor;
 import me.lucko.luckperms.common.calculator.processor.PermissionProcessor;
 import me.lucko.luckperms.common.calculator.processor.RegexProcessor;
 import me.lucko.luckperms.common.calculator.processor.SpongeWildcardProcessor;
 import me.lucko.luckperms.common.calculator.processor.WildcardProcessor;
 import me.lucko.luckperms.common.config.ConfigKeys;
 import me.lucko.luckperms.common.model.HolderType;
+import net.luckperms.api.node.Node;
 import net.luckperms.api.query.QueryOptions;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 public class BukkitCalculatorFactory implements CalculatorFactory {
     private final LPBukkitPlugin plugin;
@@ -50,25 +53,25 @@ public BukkitCalculatorFactory(LPBukkitPlugin plugin) {
     }
 
     @Override
-    public PermissionCalculator build(QueryOptions queryOptions, CacheMetadata metadata) {
+    public PermissionCalculator build(QueryOptions queryOptions, Map<String, Node> sourceMap, CacheMetadata metadata) {
         List<PermissionProcessor> processors = new ArrayList<>(8);
 
-        processors.add(new DirectProcessor());
+        processors.add(new DirectProcessor(sourceMap));
 
         if (this.plugin.getConfiguration().get(ConfigKeys.APPLY_BUKKIT_CHILD_PERMISSIONS)) {
-            processors.add(new ChildProcessor(this.plugin));
+            processors.add(new ChildProcessor(this.plugin, sourceMap));
         }
 
         if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) {
-            processors.add(new RegexProcessor());
+            processors.add(new RegexProcessor(sourceMap));
         }
 
         if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) {
-            processors.add(new WildcardProcessor());
+            processors.add(new WildcardProcessor(sourceMap));
         }
 
         if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS_SPONGE)) {
-            processors.add(new SpongeWildcardProcessor());
+            processors.add(new SpongeWildcardProcessor(sourceMap));
         }
 
         boolean op = queryOptions.option(BukkitContextManager.OP_OPTION).orElse(false);
@@ -82,6 +85,6 @@ public PermissionCalculator build(QueryOptions queryOptions, CacheMetadata metad
             processors.add(OpProcessor.INSTANCE);
         }
 
-        return new PermissionCalculator(this.plugin, metadata, processors);
+        return new PermissionCalculatorMonitored(this.plugin, metadata, processors);
     }
 }

bukkit/src/main/java/me/lucko/luckperms/bukkit/calculator/ChildProcessor.java

@@ -26,28 +26,37 @@
 package me.lucko.luckperms.bukkit.calculator;
 
 import me.lucko.luckperms.bukkit.LPBukkitPlugin;
+import me.lucko.luckperms.bukkit.inject.server.LuckPermsPermissionMap;
 import me.lucko.luckperms.common.cacheddata.result.TristateResult;
-import me.lucko.luckperms.common.calculator.processor.AbstractSourceBasedProcessor;
+import me.lucko.luckperms.common.calculator.processor.AbstractPermissionProcessor;
 import me.lucko.luckperms.common.calculator.processor.PermissionProcessor;
+import net.luckperms.api.node.Node;
 import net.luckperms.api.util.Tristate;
 
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
  * Permission Processor for Bukkits "child" permission system.
  */
-public class ChildProcessor extends AbstractSourceBasedProcessor implements PermissionProcessor {
+public class ChildProcessor extends AbstractPermissionProcessor implements PermissionProcessor {
     private static final TristateResult.Factory RESULT_FACTORY = new TristateResult.Factory(ChildProcessor.class);
 
     private final LPBukkitPlugin plugin;
+    private final Map<String, Node> sourceMap;
+
     private final AtomicBoolean needsRefresh = new AtomicBoolean(false);
-    private Map<String, TristateResult> childPermissions = Collections.emptyMap();
+    private Map<String, TristateResult> childPermissions;
 
-    public ChildProcessor(LPBukkitPlugin plugin) {
+    public ChildProcessor(LPBukkitPlugin plugin, Map<String, Node> sourceMap) {
         this.plugin = plugin;
+        this.sourceMap = sourceMap;
+        refresh();
+    }
+
+    private void refresh() {
+        this.childPermissions = processChildPermissions(this.sourceMap, this.plugin.getPermissionMap());
     }
 
     @Override
@@ -59,20 +68,18 @@ public TristateResult hasPermission(String permission) {
     }
 
     @Override
-    public void refresh() {
+    public void invalidate() {
+        this.needsRefresh.set(true);
+    }
+
+    private static Map<String, TristateResult> processChildPermissions(Map<String, Node> sourceMap, LuckPermsPermissionMap permissionMap) {
         Map<String, TristateResult> childPermissions = new HashMap<>();
-        this.sourceMap.forEach((key, node) -> {
-            Map<String, Boolean> children = this.plugin.getPermissionMap().getChildPermissions(key, node.getValue());
+        sourceMap.forEach((key, node) -> {
+            Map<String, Boolean> children = permissionMap.getChildPermissions(key, node.getValue());
             children.forEach((childKey, childValue) -> {
                 childPermissions.put(childKey, RESULT_FACTORY.resultWithOverride(node, Tristate.of(childValue)));
             });
         });
-        this.childPermissions = childPermissions;
-        this.needsRefresh.set(false);
-    }
-
-    @Override
-    public void invalidate() {
-        this.needsRefresh.set(true);
+        return childPermissions;
     }
 }

bukkit/src/main/resources/config.yml

@@ -268,6 +268,16 @@ redis:
   address: localhost
   username: ''
   password: ''
+  # Settings for Redis Sentinel.
+  # Sentinel provides high availability for Redis by monitoring master/replica instances.
+  # Port 26379 is used by default for sentinel nodes.
+  sentinel:
+    enabled: false
+    master: mymaster
+    addresses:
+      - localhost:26379
+    username: ''
+    password: ''
 
 # Settings for Nats.
 # Port 4222 is used by default; set address to "host:port" if differs
@@ -276,6 +286,7 @@ nats:
   address: localhost
   username: ''
   password: ''
+  token: ''
 
 # Settings for RabbitMQ.
 # Port 5672 is used by default; set address to "host:port" if differs

bukkit/src/main/resources/luckperms.commodore

@@ -543,7 +543,9 @@ luckperms {
 
       editor;
       listmembers {
-        page brigadier:integer;
+        page brigadier:integer {
+          context brigadier:string greedy_phrase;
+        }
       }
       setweight {
         weight brigadier:integer;

bungee/src/main/java/me/lucko/luckperms/bungee/calculator/BungeeCalculatorFactory.java

@@ -29,16 +29,19 @@
 import me.lucko.luckperms.common.cacheddata.CacheMetadata;
 import me.lucko.luckperms.common.calculator.CalculatorFactory;
 import me.lucko.luckperms.common.calculator.PermissionCalculator;
+import me.lucko.luckperms.common.calculator.PermissionCalculatorMonitored;
 import me.lucko.luckperms.common.calculator.processor.DirectProcessor;
 import me.lucko.luckperms.common.calculator.processor.PermissionProcessor;
 import me.lucko.luckperms.common.calculator.processor.RegexProcessor;
 import me.lucko.luckperms.common.calculator.processor.SpongeWildcardProcessor;
 import me.lucko.luckperms.common.calculator.processor.WildcardProcessor;
 import me.lucko.luckperms.common.config.ConfigKeys;
+import net.luckperms.api.node.Node;
 import net.luckperms.api.query.QueryOptions;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 public class BungeeCalculatorFactory implements CalculatorFactory {
     private final LPBungeePlugin plugin;
@@ -48,23 +51,23 @@ public BungeeCalculatorFactory(LPBungeePlugin plugin) {
     }
 
     @Override
-    public PermissionCalculator build(QueryOptions queryOptions, CacheMetadata metadata) {
+    public PermissionCalculator build(QueryOptions queryOptions, Map<String, Node> sourceMap, CacheMetadata metadata) {
         List<PermissionProcessor> processors = new ArrayList<>(4);
 
-        processors.add(new DirectProcessor());
+        processors.add(new DirectProcessor(sourceMap));
 
         if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) {
-            processors.add(new RegexProcessor());
+            processors.add(new RegexProcessor(sourceMap));
         }
 
         if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) {
-            processors.add(new WildcardProcessor());
+            processors.add(new WildcardProcessor(sourceMap));
         }
 
         if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS_SPONGE)) {
-            processors.add(new SpongeWildcardProcessor());
+            processors.add(new SpongeWildcardProcessor(sourceMap));
         }
 
-        return new PermissionCalculator(this.plugin, metadata, processors);
+        return new PermissionCalculatorMonitored(this.plugin, metadata, processors);
     }
 }