refactor: rename some Class name

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -15,7 +15,7 @@ body:
         如果此bug被尝试修复，您可以帮助我们测试并回复。若bug的确被修复，您可以关闭issue来让开发者确认。
         If this bug is tried to fix, you can help us test and reply. If the bug is fixed, you can close the issue to let the developer confirm.
   - type: input
-    id: luminolMC-version
+    id: leavesMC-version
     attributes:
       label: 服务端版本 LuminolMC Version
       description:

.github/workflows/build_1.21.4.yml

@@ -1,10 +1,10 @@
-name: Luminol CI - ver/1.21.6
+name: Luminol CI - dev/1.21.4-hardfork
 
 on:
-  push:
-    branches: [ "ver/1.21.6" ]
-  pull_request:
-    branches: [ "ver/1.21.6" ]
+    push:
+      branches: [ "dev/1.21.4-hardfork" ]
+    pull_request:
+      branches: [ "dev/1.21.4-hardfork" ]
 
 permissions: write-all
 
@@ -15,56 +15,61 @@ jobs:
     steps:
       - name: Checkout Git Repository
         uses: actions/checkout@v4
-
+        
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        
       - name: Set up JDK
         uses: actions/setup-java@v4
         with:
-          distribution: zulu
-          java-version: 22
-
-      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v4
-
+          distribution: 'zulu'
+          java-version: '22'
+          
+      - name: Grant execute permission for gradlew
+        run: chmod +x gradlew
+        
       - name: Configure Git User Details
         run: git config --global user.email "ci@luminolmc.com" && git config --global user.name "LuminolMC CI"
-
-      - name: Apply All Patches
+        
+      - name: Apply Patches
         run: ./gradlew applyAllPatches
-
-      - name: CreateMojmapPaperclipJar
+        
+      - name: CreateJar
         run: ./gradlew createMojmapPaperclipJar
-
+        
       - name: Publish to repo
-        if: github.event_name != 'pull_request' && false # do not push in preview
+        if: github.event_name != 'pull_request'
         continue-on-error: true
-        run: ./gradlew generateDevelopmentBundle publish -PpublishDevBundle=true
+        run: |
+          ./gradlew generateDevelopmentBundle publish -PpublishDevBundle=true
         env:
           PRIVATE_MAVEN_REPO_PASSWORD: ${{ secrets.PRIVATE_MAVEN_REPO_PASSWORD }}
           PRIVATE_MAVEN_REPO_USERNAME: ${{ secrets.PRIVATE_MAVEN_REPO_USERNAME }}
-
+          
       - name: Upload Artifact
         uses: actions/upload-artifact@v4
         with:
-          name: ${{ env.project_id_b }} CI Artifacts
-          path: luminol-server/build/libs/*-paperclip-*-mojmap.jar
-
+          name: "${{ env.project_id_b }} CI Artifacts"
+          path: "luminol-server/build/libs/*-paperclip-*-mojmap.jar"
+          
       - name: SetENV
         if: github.event_name != 'pull_request'
         run: sh scripts/SetENV.sh
-
+        
       - name: Create Release
-        if: github.event_name != 'pull_request' && false # do not push in preview
+        if: github.event_name != 'pull_request'
         uses: ncipollo/release-action@v1
         with:
           tag: ${{ env.tag }}
           name: ${{ env.project_id_b }} ${{ env.mcversion }} - ${{ env.commit_id }}
           body: |
-            📦Version: `${{ env.mcversion }}` | Commit ${{ env.commit_id }} [![download](https://img.shields.io/github/downloads/LuminolMC/${{ env.project_id }}/${{ env.tag }}/total?color=red&style=flat-square)](https://github.com/LuminolMC/${{ env.project_id }}/releases/download/${{ env.tag }}/${{ env.jar }})
+            📦Version: `${{ env.mcversion }}` | Commit ${{ env.commit_id }} [![download](https://img.shields.io/github/downloads/LuminolMC/${{ env.project_id }}/${{ env.tag }}/total?color=red&style=flat-square)](https://github.com/LuminolMC/${{ env.project_id }}/download/${{ env.tag }}/${{ env.jar }})
             This release is automatically compiled by GitHub Actions
             ### Commit Message
             ${{ env.commit_msg }}
-          artifacts: ${{ env.jar_dir }}
+          artifacts: |
+            ${{ env.jar_dir }}
           generateReleaseNotes: true
           prerelease: ${{ env.pre }}
           makeLatest: ${{ env.make_latest }}
-          token: ${{ secrets.GITHUB_TOKEN }}
+          token: "${{ secrets.GITHUB_TOKEN }}"

build.gradle.kts

@@ -3,7 +3,7 @@ import org.gradle.api.tasks.testing.logging.TestLogEvent
 
 plugins {
     java // TODO java launcher tasks
-    id("io.papermc.paperweight.patcher") version "2.0.0-beta.17"
+    id("io.papermc.paperweight.patcher") version "2.0.0-beta.14"
 }
 
 paperweight {
@@ -64,7 +64,6 @@ subprojects {
         options.encoding = Charsets.UTF_8.name()
         options.release = 21
         options.isFork = true
-        options.forkOptions.memoryMaximumSize = "6g" // Prevent OOM during building
     }
     tasks.withType<Javadoc> {
         options.encoding = Charsets.UTF_8.name()

docs/CONTRIBUTING.md

@@ -23,11 +23,6 @@
 - `git`
 - `JDK 21 或更高版本`
 
-特别提醒：在操作前，您需要启用系统和Git的长路径支持，以下为部分平台的相关描述。
-
-[`Windows`](https://learn.microsoft.com/windows/win32/fileio/maximum-file-path-limitation)
-[`Git for Windows`](https://gitforwindows.org/faq.html#i-get-errors-trying-to-check-out-files-with-long-path-names)
-
 ## 了解补丁（Patches）
 
 Luminol 使用和 Folia 一样的补丁系统，并为了针对不同部分的修改分成了两个目录：

docs/CONTRIBUTING_EN.md

@@ -25,11 +25,6 @@ Before coding, you need these pieces of software / tools as Dev Environment.
 - `git`
 - `JDK 21 or higher`
 
-PS: You need to enable long path support in your System and Git before start, some of the platform's resolution here.
-
-[`Windows`](https://learn.microsoft.com/windows/win32/fileio/maximum-file-path-limitation)
-[`Git for Windows`](https://gitforwindows.org/faq.html#i-get-errors-trying-to-check-out-files-with-long-path-names)
-
 ## Understanding "Patches"
 
 Luminol uses as the same patching system as Paper,  
@@ -63,7 +58,7 @@ BTW, `*-api` and `*-server` and are not normal git repositories.
 
 - Before applying patches, the base will point to unmodified source code.
 - Every commit after the base is a patch.
-- Only commits after the last commit of Folia will be considered as Luminol patches.
+- Only commits after the last commit of Paper will be considered as Luminol patches.
 
 ## Adding new patches
 

gradle.properties

@@ -1,8 +1,8 @@
 group = me.earthme.luminol
-version=1.21.6-R0.1-SNAPSHOT
-mcVersion=1.21.6
+version=1.21.4-R0.1-SNAPSHOT
+mcVersion=1.21.4
 
-foliaRef=03cc09fa2601f8ec7f70753e5f0d527997c06618
+foliaRef=f69d1c974daa7646b869d4c11dcc86915eec96a8
 
 org.gradle.configuration-cache=true
 org.gradle.caching=true

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.12-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

gradlew

@@ -114,7 +114,7 @@ case "$( uname )" in                #(
   NONSTOP* )        nonstop=true ;;
 esac
 
-CLASSPATH="\\\"\\\""
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
 
 # Determine the Java command to use to start the JVM.
@@ -205,7 +205,7 @@ fi
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Collect all arguments for the java command:
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
 #     and any embedded shellness will be escaped.
 #   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
 #     treated as '${Hostname}' itself on the command line.
@@ -213,7 +213,7 @@ DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \
         -classpath "$CLASSPATH" \
-        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        org.gradle.wrapper.GradleWrapperMain \
         "$@"
 
 # Stop when "xargs" is not available.

gradlew.bat

@@ -70,11 +70,11 @@ goto fail
 :execute
 @rem Setup the command line
 
-set CLASSPATH=
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell

luminol-api/build.gradle.kts.patch

@@ -1,16 +1,16 @@
 --- a/folia-api/build.gradle.kts
 +++ b/folia-api/build.gradle.kts
-@@ -51,6 +_,7 @@
+@@ -54,6 +_,7 @@
      api("org.apache.logging.log4j:log4j-api:$log4jVersion")
      api("org.slf4j:slf4j-api:$slf4jVersion")
      api("com.mojang:brigadier:1.3.10")
 +    api("io.sentry:sentry:8.0.0-rc.2") // Pufferfish
  
      // Deprecate bungeecord-chat in favor of adventure
-     api("net.md-5:bungeecord-chat:$bungeeCordChatVersion") {
-@@ -101,17 +_,21 @@
+     api("net.md-5:bungeecord-chat:$bungeeCordChatVersion-deprecated+build.19") {
+@@ -104,17 +_,21 @@
          java {
-             srcDir(generatedDir)
+             srcDir(generatedApiPath)
              srcDir(file("../paper-api/src/main/java"))
 +            srcDir(file("../folia-api/src/main/java"))
          }
@@ -30,9 +30,9 @@
          }
      }
  }
-@@ -257,3 +_,10 @@
-         dependsOn(scanJarForOldGeneratedCode)
-     }
+@@ -258,3 +_,10 @@
+ tasks.check {
+     dependsOn(scanJarForOldGeneratedCode)
  }
 +
 +// Pufferfish Start

luminol-api/paper-patches/features/0002-KioCG-Chunk-API.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] KioCG Chunk API
 
 
 diff --git a/src/main/java/org/bukkit/Chunk.java b/src/main/java/org/bukkit/Chunk.java
-index 9f8414f854646ad7429fe806e35a13e32a07ddaa..9a0995bf82830b45b2d72b2a1cff2bfdd4f7a638 100644
+index d434277342b2db19f98e032d3a316b27d728b840..e188353ad193f6203533790ae52fafc0554df63f 100644
 --- a/src/main/java/org/bukkit/Chunk.java
 +++ b/src/main/java/org/bukkit/Chunk.java
 @@ -388,4 +388,6 @@ public interface Chunk extends PersistentDataHolder {
@@ -16,10 +16,10 @@ index 9f8414f854646ad7429fe806e35a13e32a07ddaa..9a0995bf82830b45b2d72b2a1cff2bfd
 +    long getChunkHotAvg(); // KioCG
  }
 diff --git a/src/main/java/org/bukkit/entity/Player.java b/src/main/java/org/bukkit/entity/Player.java
-index d34419693fc78b3f7e8f6bbf115f17f29e5e3377..aefcae5d9b7beff4bb7185cf44b443fc340af179 100644
+index 494dca2ee48a03953d47050b178496df12bc48c5..a65d64b1ef64cf1cf213cec00e7f73cc7ad2b79c 100644
 --- a/src/main/java/org/bukkit/entity/Player.java
 +++ b/src/main/java/org/bukkit/entity/Player.java
-@@ -3925,4 +3925,6 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
+@@ -3918,4 +3918,6 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
       * @param score New death screen score of player
       */
      void setDeathScreenScore(int score);

luminol-api/paper-patches/features/0003-Disable-timings-warn-msg-and-commands.patch

@@ -18,14 +18,14 @@ index 89017af09ce32e7a66014fc3aeb50155921252a5..b862779b48176dd7e67a2f1a3e7f24bc
          }
      }
 diff --git a/src/main/java/org/bukkit/command/SimpleCommandMap.java b/src/main/java/org/bukkit/command/SimpleCommandMap.java
-index 4acda947b7d69ab4133b4cc94e76d945e4d148d5..8093eff77c80be2c2e97bf6700a69d879d4c62a5 100644
+index 5df19bd701c67506689fc7f49d91f99ebfbc83f0..baf0cbd2f995ebe2e4382244eff6e15ec125d790 100644
 --- a/src/main/java/org/bukkit/command/SimpleCommandMap.java
 +++ b/src/main/java/org/bukkit/command/SimpleCommandMap.java
-@@ -32,7 +32,7 @@ public class SimpleCommandMap implements CommandMap {
- 
-     private void setDefaultCommands() {
+@@ -39,7 +39,7 @@ public class SimpleCommandMap implements CommandMap {
+         register("bukkit", new VersionCommand("version"));
          register("bukkit", new ReloadCommand("reload"));
--        register("bukkit", new co.aikar.timings.TimingsCommand("timings"));
+         //register("bukkit", new PluginsCommand("plugins")); // Paper
+-        register("bukkit", new co.aikar.timings.TimingsCommand("timings")); // Paper
 +        //register("bukkit", new co.aikar.timings.TimingsCommand("timings")); // Paper // Luminol - Disable timings warn msg and commands
      }
  

luminol-api/paper-patches/features/0004-Force-disable-reload-command.patch

@@ -5,15 +5,15 @@ Subject: [PATCH] Force disable reload command
 
 
 diff --git a/src/main/java/org/bukkit/command/SimpleCommandMap.java b/src/main/java/org/bukkit/command/SimpleCommandMap.java
-index 8093eff77c80be2c2e97bf6700a69d879d4c62a5..c51bc888011091925d73945a52b252aef3e2b384 100644
+index baf0cbd2f995ebe2e4382244eff6e15ec125d790..0d354eb5e7df427faff2d6c816c297c3d39a6e63 100644
 --- a/src/main/java/org/bukkit/command/SimpleCommandMap.java
 +++ b/src/main/java/org/bukkit/command/SimpleCommandMap.java
-@@ -31,7 +31,7 @@ public class SimpleCommandMap implements CommandMap {
-     }
+@@ -37,7 +37,7 @@ public class SimpleCommandMap implements CommandMap {
  
      private void setDefaultCommands() {
+         register("bukkit", new VersionCommand("version"));
 -        register("bukkit", new ReloadCommand("reload"));
 +        //register("bukkit", new ReloadCommand("reload")); // Luminol - Force disable reload command
+         //register("bukkit", new PluginsCommand("plugins")); // Paper
          //register("bukkit", new co.aikar.timings.TimingsCommand("timings")); // Paper // Luminol - Disable timings warn msg and commands
      }
- 

luminol-api/paper-patches/features/0005-Pufferfish-Sentry.patch

@@ -4,6 +4,177 @@ Date: Sun, 12 Jan 2025 13:27:38 +0800
 Subject: [PATCH] Pufferfish Sentry
 
 
+diff --git a/src/main/java/gg/pufferfish/pufferfish/sentry/SentryContext.java b/src/main/java/gg/pufferfish/pufferfish/sentry/SentryContext.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..c7772aac00f6db664f7a5673bc2585fa025e6aad
+--- /dev/null
++++ b/src/main/java/gg/pufferfish/pufferfish/sentry/SentryContext.java
+@@ -0,0 +1,165 @@
++package gg.pufferfish.pufferfish.sentry;
++
++import com.google.gson.Gson;
++
++import java.lang.reflect.Field;
++import java.lang.reflect.Modifier;
++import java.util.Map;
++import java.util.TreeMap;
++
++import org.apache.logging.log4j.ThreadContext;
++import org.bukkit.command.Command;
++import org.bukkit.command.CommandSender;
++import org.bukkit.entity.Player;
++import org.bukkit.event.Event;
++import org.bukkit.event.player.PlayerEvent;
++import org.bukkit.plugin.Plugin;
++import org.bukkit.plugin.RegisteredListener;
++import org.jetbrains.annotations.Nullable;
++
++public class SentryContext {
++
++    private static final Gson GSON = new Gson();
++
++    public static void setPluginContext(@Nullable Plugin plugin) {
++        if (plugin != null) {
++            ThreadContext.put("pufferfishsentry_pluginname", plugin.getName());
++            ThreadContext.put("pufferfishsentry_pluginversion", plugin.getPluginMeta().getVersion());
++        }
++    }
++
++    public static void removePluginContext() {
++        ThreadContext.remove("pufferfishsentry_pluginname");
++        ThreadContext.remove("pufferfishsentry_pluginversion");
++    }
++
++    public static void setSenderContext(@Nullable CommandSender sender) {
++        if (sender != null) {
++            ThreadContext.put("pufferfishsentry_playername", sender.getName());
++            if (sender instanceof Player player) {
++                ThreadContext.put("pufferfishsentry_playerid", player.getUniqueId().toString());
++            }
++        }
++    }
++
++    public static void removeSenderContext() {
++        ThreadContext.remove("pufferfishsentry_playername");
++        ThreadContext.remove("pufferfishsentry_playerid");
++    }
++
++    public static void setEventContext(Event event, RegisteredListener registration) {
++        setPluginContext(registration.getPlugin());
++
++        try {
++            // Find the player that was involved with this event
++            Player player = null;
++            if (event instanceof PlayerEvent) {
++                player = ((PlayerEvent) event).getPlayer();
++            } else {
++                Class<? extends Event> eventClass = event.getClass();
++
++                Field playerField = null;
++
++                for (Field field : eventClass.getDeclaredFields()) {
++                    if (field.getType().equals(Player.class)) {
++                        playerField = field;
++                        break;
++                    }
++                }
++
++                if (playerField != null) {
++                    playerField.setAccessible(true);
++                    player = (Player) playerField.get(event);
++                }
++            }
++
++            if (player != null) {
++                setSenderContext(player);
++            }
++        } catch (Exception ignored) {
++        } // We can't really safely log exceptions.
++
++        ThreadContext.put("pufferfishsentry_eventdata", GSON.toJson(serializeFields(event)));
++    }
++
++    public static void removeEventContext() {
++        removePluginContext();
++        removeSenderContext();
++        ThreadContext.remove("pufferfishsentry_eventdata");
++    }
++
++    private static Map<String, String> serializeFields(Object object) {
++        Map<String, String> fields = new TreeMap<>();
++        fields.put("_class", object.getClass().getName());
++        for (Field declaredField : object.getClass().getDeclaredFields()) {
++            try {
++                if (Modifier.isStatic(declaredField.getModifiers())) {
++                    continue;
++                }
++
++                String fieldName = declaredField.getName();
++                if (fieldName.equals("handlers")) {
++                    continue;
++                }
++                declaredField.setAccessible(true);
++                Object value = declaredField.get(object);
++                if (value != null) {
++                    fields.put(fieldName, value.toString());
++                } else {
++                    fields.put(fieldName, "<null>");
++                }
++            } catch (Exception ignored) {
++            } // We can't really safely log exceptions.
++        }
++        return fields;
++    }
++
++    public static class State {
++
++        private Plugin plugin;
++        private Command command;
++        private String commandLine;
++        private Event event;
++        private RegisteredListener registeredListener;
++
++        public Plugin getPlugin() {
++            return plugin;
++        }
++
++        public void setPlugin(Plugin plugin) {
++            this.plugin = plugin;
++        }
++
++        public Command getCommand() {
++            return command;
++        }
++
++        public void setCommand(Command command) {
++            this.command = command;
++        }
++
++        public String getCommandLine() {
++            return commandLine;
++        }
++
++        public void setCommandLine(String commandLine) {
++            this.commandLine = commandLine;
++        }
++
++        public Event getEvent() {
++            return event;
++        }
++
++        public void setEvent(Event event) {
++            this.event = event;
++        }
++
++        public RegisteredListener getRegisteredListener() {
++            return registeredListener;
++        }
++
++        public void setRegisteredListener(RegisteredListener registeredListener) {
++            this.registeredListener = registeredListener;
++        }
++    }
++}
 diff --git a/src/main/java/org/bukkit/plugin/SimplePluginManager.java b/src/main/java/org/bukkit/plugin/SimplePluginManager.java
 index ab36e3aaff57e2f27b5aed06b4bdfe277f86a35e..96da9f1082ab134d197b3a6069f2fcdf38585efe 100644
 --- a/src/main/java/org/bukkit/plugin/SimplePluginManager.java
@@ -31,10 +202,10 @@ index ab36e3aaff57e2f27b5aed06b4bdfe277f86a35e..96da9f1082ab134d197b3a6069f2fcdf
                      callEvent(new com.destroystokyo.paper.event.server.ServerExceptionEvent(new com.destroystokyo.paper.exception.ServerEventException(msg, ex, registration.getPlugin(), registration.getListener(), event)));
                  }
 diff --git a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
-index 163e9a0e179dc88be93614ff66ee2be3eccc694f..78cdf669328fc1ec5e9943033a11d2200857a07e 100644
+index b412aaf08901d169ac9fc89b36f9d6ccb95c53d3..45a9ca8969f635d20cc44c062fda85bbccd8f8ff 100644
 --- a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
 +++ b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
-@@ -329,7 +329,13 @@ public final class JavaPluginLoader implements PluginLoader {
+@@ -336,7 +336,13 @@ public final class JavaPluginLoader implements PluginLoader {
              try {
                  jPlugin.setEnabled(true);
              } catch (Throwable ex) {
@@ -48,7 +219,7 @@ index 163e9a0e179dc88be93614ff66ee2be3eccc694f..78cdf669328fc1ec5e9943033a11d220
              }
  
              // Perhaps abort here, rather than continue going, but as it stands,
-@@ -354,7 +360,9 @@ public final class JavaPluginLoader implements PluginLoader {
+@@ -361,7 +367,9 @@ public final class JavaPluginLoader implements PluginLoader {
              try {
                  jPlugin.setEnabled(false);
              } catch (Throwable ex) {

luminol-api/paper-patches/features/0006-Pufferfish-SIMD-Utilities.patch

@@ -4,20 +4,191 @@ Date: Sun, 12 Jan 2025 14:00:28 +0800
 Subject: [PATCH] Pufferfish SIMD Utilities
 
 
+diff --git a/src/main/java/gg/pufferfish/pufferfish/simd/SIMDChecker.java b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDChecker.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..856de1331b15542c00e01990f471fa5152722c11
+--- /dev/null
++++ b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDChecker.java
+@@ -0,0 +1,35 @@
++package gg.pufferfish.pufferfish.simd;
++
++import jdk.incubator.vector.FloatVector;
++import jdk.incubator.vector.IntVector;
++import jdk.incubator.vector.VectorSpecies;
++import org.slf4j.Logger;
++
++/**
++ * Basically, java is annoying and we have to push this out to its own class.
++ */
++@Deprecated
++public class SIMDChecker {
++	
++	@Deprecated
++	public static boolean canEnable(Logger logger) {
++		try {
++			SIMDDetection.testRun = true;
++
++			VectorSpecies<Integer> ISPEC = IntVector.SPECIES_PREFERRED;
++			VectorSpecies<Float> FSPEC = FloatVector.SPECIES_PREFERRED;
++
++			logger.info("Max SIMD vector size on this system is {} bits (int)", ISPEC.vectorBitSize());
++			logger.info("Max SIMD vector size on this system is " + FSPEC.vectorBitSize() + " bits (float)");
++
++			if (ISPEC.elementSize() < 2 || FSPEC.elementSize() < 2) {
++				logger.warn("SIMD is not properly supported on this system!");
++				return false;
++			}
++
++			return true;
++		} catch (NoClassDefFoundError | Exception ignored) {} // Basically, we don't do anything. This lets us detect if it's not functional and disable it.
++		return false;
++	}
++	
++}
+diff --git a/src/main/java/gg/pufferfish/pufferfish/simd/SIMDDetection.java b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDDetection.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0a64cd0e88083ac4af6674ad0fb07b771109c737
+--- /dev/null
++++ b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDDetection.java
+@@ -0,0 +1,34 @@
++package gg.pufferfish.pufferfish.simd;
++
++import org.slf4j.Logger;
++
++@Deprecated
++public class SIMDDetection {
++	
++	public static boolean isEnabled = false;
++	public static boolean testRun = false;
++	
++	@Deprecated
++	public static boolean canEnable(Logger logger) {
++		try {
++			return SIMDChecker.canEnable(logger);
++		} catch (NoClassDefFoundError | Exception ignored) {
++			return false;
++		}
++	}
++	
++	@Deprecated
++	public static int getJavaVersion() {
++		// https://stackoverflow.com/a/2591122
++		String version = System.getProperty("java.version");
++		if(version.startsWith("1.")) {
++			version = version.substring(2, 3);
++		} else {
++			int dot = version.indexOf(".");
++			if(dot != -1) { version = version.substring(0, dot); }
++		}
++		version = version.split("-")[0]; // Azul is stupid
++		return Integer.parseInt(version);
++	}
++	
++}
+diff --git a/src/main/java/gg/pufferfish/pufferfish/simd/VectorMapPalette.java b/src/main/java/gg/pufferfish/pufferfish/simd/VectorMapPalette.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..c26dcaaa2e85882730c854099df80d69eec70f33
+--- /dev/null
++++ b/src/main/java/gg/pufferfish/pufferfish/simd/VectorMapPalette.java
+@@ -0,0 +1,84 @@
++package gg.pufferfish.pufferfish.simd;
++
++import jdk.incubator.vector.FloatVector;
++import jdk.incubator.vector.IntVector;
++import jdk.incubator.vector.VectorMask;
++import jdk.incubator.vector.VectorSpecies;
++import org.bukkit.map.MapPalette;
++
++import java.awt.*;
++
++@Deprecated
++public class VectorMapPalette {
++
++    private static final VectorSpecies<Integer> I_SPEC = IntVector.SPECIES_PREFERRED;
++    private static final VectorSpecies<Float> F_SPEC = FloatVector.SPECIES_PREFERRED;
++
++    @Deprecated
++    public static void matchColorVectorized(int[] in, byte[] out) {
++        int speciesLength = I_SPEC.length();
++        int i;
++        for (i = 0; i < in.length - speciesLength; i += speciesLength) {
++            float[] redsArr = new float[speciesLength];
++            float[] bluesArr = new float[speciesLength];
++            float[] greensArr = new float[speciesLength];
++            int[] alphasArr = new int[speciesLength];
++
++            for (int j = 0; j < speciesLength; j++) {
++                alphasArr[j] = (in[i + j] >> 24) & 0xFF;
++                redsArr[j] = (in[i + j] >> 16) & 0xFF;
++                greensArr[j] = (in[i + j] >> 8) & 0xFF;
++                bluesArr[j] = (in[i + j] >> 0) & 0xFF;
++            }
++
++            IntVector alphas = IntVector.fromArray(I_SPEC, alphasArr, 0);
++            FloatVector reds = FloatVector.fromArray(F_SPEC, redsArr, 0);
++            FloatVector greens = FloatVector.fromArray(F_SPEC, greensArr, 0);
++            FloatVector blues = FloatVector.fromArray(F_SPEC, bluesArr, 0);
++            IntVector resultIndex = IntVector.zero(I_SPEC);
++            VectorMask<Integer> modificationMask = VectorMask.fromLong(I_SPEC, 0xffffffff);
++
++            modificationMask = modificationMask.and(alphas.lt(128).not());
++            FloatVector bestDistances = FloatVector.broadcast(F_SPEC, Float.MAX_VALUE);
++
++            for (int c = 4; c < MapPalette.colors.length; c++) {
++                // We're using 32-bit floats here because it's 2x faster and nobody will know the difference.
++                // For correctness, the original algorithm uses 64-bit floats instead. Completely unnecessary.
++                FloatVector compReds = FloatVector.broadcast(F_SPEC, MapPalette.colors[c].getRed());
++                FloatVector compGreens = FloatVector.broadcast(F_SPEC, MapPalette.colors[c].getGreen());
++                FloatVector compBlues = FloatVector.broadcast(F_SPEC, MapPalette.colors[c].getBlue());
++
++                FloatVector rMean = reds.add(compReds).div(2.0f);
++                FloatVector rDiff = reds.sub(compReds);
++                FloatVector gDiff = greens.sub(compGreens);
++                FloatVector bDiff = blues.sub(compBlues);
++
++                FloatVector weightR = rMean.div(256.0f).add(2);
++                FloatVector weightG = FloatVector.broadcast(F_SPEC, 4.0f);
++                FloatVector weightB = FloatVector.broadcast(F_SPEC, 255.0f).sub(rMean).div(256.0f).add(2.0f);
++
++                FloatVector distance = weightR.mul(rDiff).mul(rDiff).add(weightG.mul(gDiff).mul(gDiff)).add(weightB.mul(bDiff).mul(bDiff));
++
++                // Now we compare to the best distance we've found.
++                // This mask contains a "1" if better, and a "0" otherwise.
++                VectorMask<Float> bestDistanceMask = distance.lt(bestDistances);
++                bestDistances = bestDistances.blend(distance, bestDistanceMask); // Update the best distances
++
++                // Update the result array
++                // We also AND with the modification mask because we don't want to interfere if the alpha value isn't large enough.
++                resultIndex = resultIndex.blend(c, bestDistanceMask.cast(I_SPEC).and(modificationMask)); // Update the results
++            }
++
++            for (int j = 0; j < speciesLength; j++) {
++                int index = resultIndex.lane(j);
++                out[i + j] = (byte) (index < 128 ? index : -129 + (index - 127));
++            }
++        }
++
++        // For the final ones, fall back to the regular method
++        for (; i < in.length; i++) {
++            out[i] = MapPalette.matchColor(new Color(in[i], true));
++        }
++    }
++
++}
 diff --git a/src/main/java/org/bukkit/map/MapPalette.java b/src/main/java/org/bukkit/map/MapPalette.java
-index fd6f3bce50a66004687b08fd80568543f814747a..bc565037b855f2063bdcbc6c5742b1985e27bff0 100644
+index 6995f9cc08d162e3adcd3a28f6bfa6d329661999..83ea70a16b4090a8c628784f2807cd16e7065103 100644
 --- a/src/main/java/org/bukkit/map/MapPalette.java
 +++ b/src/main/java/org/bukkit/map/MapPalette.java
-@@ -35,7 +35,7 @@ public final class MapPalette {
+@@ -45,7 +45,7 @@ public final class MapPalette {
      }
  
      @NotNull
 -    static final Color[] colors = {
 +    public static final Color[] colors = { // Luminol - package-private -> public
-         // Start generate - MapPalette#colors
-         // @GeneratedFrom 1.21.6
-         new Color(0x00000000, true),
-@@ -395,9 +395,11 @@ public final class MapPalette {
+         c(0, 0, 0, 0), c(0, 0, 0, 0), c(0, 0, 0, 0), c(0, 0, 0, 0),
+         c(89, 125, 39), c(109, 153, 48), c(127, 178, 56), c(67, 94, 29),
+         c(174, 164, 115), c(213, 201, 140), c(247, 233, 163), c(130, 123, 86),
+@@ -216,9 +216,11 @@ public final class MapPalette {
          temp.getRGB(0, 0, temp.getWidth(), temp.getHeight(), pixels, 0, temp.getWidth());
  
          byte[] result = new byte[temp.getWidth() * temp.getHeight()];

luminol-api/paper-patches/features/0007-Tick-regions-api.patch

@@ -4,11 +4,198 @@ Date: Mon, 27 Jan 2025 13:01:59 +0800
 Subject: [PATCH] Tick regions api
 
 
+diff --git a/src/main/java/me/earthme/luminol/api/RegionStats.java b/src/main/java/me/earthme/luminol/api/RegionStats.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..96147cace1550d14c682258dab0397587dcf76a4
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/RegionStats.java
+@@ -0,0 +1,25 @@
++package me.earthme.luminol.api;
++
++/**
++ * A simple package of folia's tick region state.It linked to the RegionStats of the nms part so that</br>
++ * You could call these methods to get the status of this tick region</br>
++ */
++public interface RegionStats {
++    /**
++     * Get the entity count in this tick region
++     * @return the entity count
++     */
++    int getEntityCount();
++
++    /**
++     * Get the player count in this tick region
++     * @return the player count
++     */
++    int getPlayerCount();
++
++    /**
++     * Get the chunk count in this tick region
++     * @return the chunk count
++     */
++    int getChunkCount();
++}
+diff --git a/src/main/java/me/earthme/luminol/api/ThreadedRegion.java b/src/main/java/me/earthme/luminol/api/ThreadedRegion.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..01dac0602b5f66f80c0adfbb779666fe0325a24f
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/ThreadedRegion.java
+@@ -0,0 +1,56 @@
++package me.earthme.luminol.api;
++
++import org.bukkit.Location;
++import org.bukkit.World;
++
++import javax.annotation.Nullable;
++
++/**
++ * A mirror of folia's ThreadedRegion</br>
++ * Including some handy methods to get the information of the tick region</br>
++ * Note: You should call these methods inside this tick region's thread context
++ */
++public interface ThreadedRegion {
++    /**
++     * Get the center chunk pos of this tick region</br>
++     * Note:</br>
++     *      1.Global region will return a null value(But we don't finish the global region yet()</br>
++     *      2.You should call these methods inside this tick region's thread context
++     * @return The center chunk pos
++     */
++    @Nullable
++    Location getCenterChunkPos();
++
++    /**
++     * Get the dead section percent of this tick region
++     * Note: </br>
++     *      1.Dead percent is mean the percent of the unloaded chunk count of this tick region, which is also used for determine
++     * that the tick region should or not check for splitting</br>
++     *      2.You should call these methods inside this tick region's thread context
++     * @return The dead section percent
++     */
++    double getDeadSectionPercent();
++
++    /**
++     * Get the tick region data of this tick region</br>
++     * Note:</br>
++     *       1.You should call this method inside this tick region's thread context</br>
++     *       2.You should call these methods inside this tick region's thread context
++     * @return The tick region data
++     */
++    TickRegionData getTickRegionData();
++
++    /**
++     * Get the world of this tick region</br>
++     * Note: Global region will return a null value too
++     * @return The world of this tick region
++     */
++    @Nullable
++    World getWorld();
++
++    /**
++     * Get the id of the tick region</br>
++     * @return The id of the tick region
++     */
++    long getId();
++}
+diff --git a/src/main/java/me/earthme/luminol/api/ThreadedRegionizer.java b/src/main/java/me/earthme/luminol/api/ThreadedRegionizer.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..ff31a68a019fd9e5e687e6818f8729f4950bc060
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/ThreadedRegionizer.java
+@@ -0,0 +1,56 @@
++package me.earthme.luminol.api;
++
++import org.bukkit.Location;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++import java.util.Collection;
++
++/**
++ * A mirror of folia's ThreadedRegionizer
++ */
++public interface ThreadedRegionizer {
++    /**
++     * Get all the tick regions
++     * @return Temporary copied collection of all tick regions
++     */
++    Collection<ThreadedRegion> getAllRegions();
++
++    /**
++     * Get the tick region at the given chunk coordinates
++     * @param chunkX Chunk X
++     * @param chunkZ Chunk Z
++     * @return The tick region at the given chunk coordinates
++     */
++    @Nullable
++    ThreadedRegion getAtSynchronized(int chunkX, int chunkZ);
++
++    /**
++     * Get the tick region at the given chunk coordinates
++     * @param chunkX Chunk X
++     * @param chunkZ Chunk Z
++     * @return The tick region at the given chunk coordinates
++     */
++    @Nullable
++    ThreadedRegion getAtUnSynchronized(int chunkX, int chunkZ);
++
++    /**
++     * Get the tick region at the given location
++     * @param pos The location
++     * @return The tick region at the given location
++     */
++    @Nullable
++    default ThreadedRegion getAtSynchronized(@NotNull Location pos) {
++        return this.getAtSynchronized(pos.getBlockX() >> 4, pos.getBlockZ() >> 4);
++    }
++
++    /**
++     * Get the tick region at the given location
++     * @param pos The location
++     * @return The tick region at the given location
++     */
++    @Nullable
++    default ThreadedRegion getAtUnSynchronized(@NotNull Location pos) {
++        return this.getAtUnSynchronized(pos.getBlockX() >> 4, pos.getBlockZ() >> 4);
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/TickRegionData.java b/src/main/java/me/earthme/luminol/api/TickRegionData.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..ecde4462b08d701b8bff9f26902f17754cf791dd
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/TickRegionData.java
+@@ -0,0 +1,26 @@
++package me.earthme.luminol.api;
++
++import org.bukkit.World;
++
++/**
++ * A mirror of folia's tick region data
++ */
++public interface TickRegionData {
++    /**
++     * Get the world it's currently holding
++     * @return the world
++     */
++    World getWorld();
++
++    /**
++     * Get the current tick count
++     * @return the current tick count
++     */
++    long getCurrentTickCount();
++
++    /**
++     * Get the region stats
++     * @return the region stats
++     */
++    RegionStats getRegionStats();
++}
 diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
-index 04a1379f5fe281ab72610d2f8f18e1355fe3a134..d5116c1014ce123d831ce93c6204284a9642cc56 100644
+index bff01411f4b2d3ecd9e6d807c3f450d72c108323..1d74f4814d5c87d6cd1320634e5610cac16d32c5 100644
 --- a/src/main/java/org/bukkit/World.java
 +++ b/src/main/java/org/bukkit/World.java
-@@ -4462,4 +4462,8 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
+@@ -4437,4 +4437,8 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
              }
          }
      }

luminol-api/paper-patches/features/0008-Leaves-Fix-SculkCatalyst-exp-skip.patch

@@ -1,34 +1,30 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Helvetica Volubi <suisuroru@blue-millennium.fun>
-Date: Sat, 24 May 2025 01:25:10 +0800
+From: violetc <58360096+s-yh-china@users.noreply.github.com>
+Date: Sun, 6 Apr 2025 10:42:47 +0800
 Subject: [PATCH] Leaves Fix SculkCatalyst exp skip
 
 
 diff --git a/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java b/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java
-index 76c08499b704a6cb0cb95ce69b9a9248d69cc127..d516595a8675a9f3d9c14658b66160ba4b3c4278 100644
+index 42ffb81708b327f765ba3235fdd1ab69cd7589fd..0a7e37420f8d024ffba1fd1c52edc50c10408e6e 100644
 --- a/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java
 +++ b/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java
-@@ -27,6 +27,7 @@ public class EntityDeathEvent extends EntityEvent implements Cancellable {
-     @Nullable private org.bukkit.SoundCategory deathSoundCategory;
+@@ -25,17 +25,25 @@ public class EntityDeathEvent extends EntityEvent implements org.bukkit.event.Ca
      private float deathSoundVolume;
      private float deathSoundPitch;
+     // Paper end
 +    private int rewardExp; // Leaves - exp fix
  
-     private boolean cancelled;
- 
-@@ -35,13 +36,20 @@ public class EntityDeathEvent extends EntityEvent implements Cancellable {
-         this(livingEntity, damageSource, drops, 0);
+     public EntityDeathEvent(@NotNull final LivingEntity entity, @NotNull DamageSource damageSource, @NotNull final List<ItemStack> drops) {
+         this(entity, damageSource, drops, 0);
      }
  
--    @ApiStatus.Internal
-     public EntityDeathEvent(@NotNull final LivingEntity livingEntity, @NotNull DamageSource damageSource, @NotNull final List<ItemStack> drops, final int droppedExp) {
-+        // Leaves start - exp fix
-+        this(livingEntity, damageSource, drops, droppedExp, droppedExp);
+     public EntityDeathEvent(@NotNull final LivingEntity what, @NotNull DamageSource damageSource, @NotNull final List<ItemStack> drops, final int droppedExp) {
++    // Leaves start - exp fix
++        this(what, damageSource, drops, droppedExp, droppedExp);
 +    }
 +
-+    @ApiStatus.Internal
-+    public EntityDeathEvent(@NotNull final LivingEntity livingEntity, @NotNull DamageSource damageSource, @NotNull final List<ItemStack> drops, final int droppedExp, final int rewardExp) {
-         super(livingEntity);
++    public EntityDeathEvent(@NotNull final LivingEntity what, @NotNull DamageSource damageSource, @NotNull final List<ItemStack> drops, final int droppedExp, final int rewardExp) {
+         super(what);
          this.damageSource = damageSource;
          this.drops = drops;
          this.dropExp = droppedExp;
@@ -38,10 +34,18 @@ index 76c08499b704a6cb0cb95ce69b9a9248d69cc127..d516595a8675a9f3d9c14658b66160ba
  
      @NotNull
      @Override
-@@ -230,4 +238,14 @@ public class EntityDeathEvent extends EntityEvent implements Cancellable {
-     public static HandlerList getHandlerList() {
-         return HANDLER_LIST;
+@@ -75,6 +83,7 @@ public class EntityDeathEvent extends EntityEvent implements org.bukkit.event.Ca
+      */
+     public void setDroppedExp(int exp) {
+         this.dropExp = exp;
++        this.rewardExp = exp; // Leaves - exp fix
      }
+ 
+     /**
+@@ -226,4 +235,14 @@ public class EntityDeathEvent extends EntityEvent implements org.bukkit.event.Ca
+         this.deathSoundPitch = pitch;
+     }
+     // Paper end
 +
 +    // Leaves start - exp fix
 +    public int getRewardExp() {
@@ -53,31 +57,3 @@ index 76c08499b704a6cb0cb95ce69b9a9248d69cc127..d516595a8675a9f3d9c14658b66160ba
 +    }
 +    // Leaves end - exp fix
  }
-diff --git a/src/main/java/org/bukkit/event/entity/PlayerDeathEvent.java b/src/main/java/org/bukkit/event/entity/PlayerDeathEvent.java
-index 6316a2f1d2dc0314397e33e6dbd354fb8bc50541..6e2d1bf0e8eb9fa4917b464324a02b9b5d0dd496 100644
---- a/src/main/java/org/bukkit/event/entity/PlayerDeathEvent.java
-+++ b/src/main/java/org/bukkit/event/entity/PlayerDeathEvent.java
-@@ -25,6 +25,7 @@ public class PlayerDeathEvent extends EntityDeathEvent {
-     private boolean doExpDrop;
-     private boolean keepLevel = false;
-     private boolean keepInventory = false;
-+    private boolean useApiExpDropStatus = false; // Leaves - exp fix
-     @Deprecated
-     private final List<ItemStack> itemsToKeep = new ArrayList<>();
- 
-@@ -82,8 +83,15 @@ public class PlayerDeathEvent extends EntityDeathEvent {
-         this.showDeathMessages = true;
-         this.deathMessage = LegacyComponentSerializer.legacySection().deserializeOrNull(deathMessage);
-         this.doExpDrop = doExpDrop;
-+        this.useApiExpDropStatus = true; // Leaves - exp fix
-     }
- 
-+    // Leaves start - exp fix
-+    public boolean forceUseEventDropStatus() {
-+        return this.useApiExpDropStatus;
-+    }
-+    // Leaves end - exp fix
-+
-     @NotNull
-     @Override
-     public Player getEntity() {

luminol-api/paper-patches/features/0009-Purpur-Lobotomize-stuck-villagers.patch

@@ -1,17 +1,18 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MrHua269 <mrhua269@gmail.com>
-Date: Thu, 12 Jun 2025 08:00:15 +0800
+From: MrHua269 <wangxyper@163.com>
+Date: Thu, 30 Jan 2025 09:29:03 +0800
 Subject: [PATCH] Purpur Lobotomize stuck villagers
 
 
 diff --git a/src/main/java/org/bukkit/entity/Villager.java b/src/main/java/org/bukkit/entity/Villager.java
-index 4d88bb2eaa43709fb6103a6f77d8c01e83bfe743..60b87d52c20cec947b196f47fc333bc643accbd2 100644
+index 1db3742024e9cd1b70af2d52b4b756a544c019df..9c722a762c88a88bb5ef18c3b9eab8b371360dac 100644
 --- a/src/main/java/org/bukkit/entity/Villager.java
 +++ b/src/main/java/org/bukkit/entity/Villager.java
-@@ -408,4 +408,13 @@ public interface Villager extends AbstractVillager {
-      * Demand is still updated even if all events are canceled.
+@@ -367,4 +367,14 @@ public interface Villager extends AbstractVillager {
       */
-     public void restock();
+     public void clearReputations();
+     // Paper end
++
 +    // Purpur start
 +
 +    /**

luminol-api/paper-patches/features/0010-Add-missing-teleportation-apis-for-folia.patch

@@ -0,0 +1,357 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Fri, 31 Jan 2025 20:28:47 +0800
+Subject: [PATCH] Add missing teleportation apis for folia
+
+
+diff --git a/src/main/java/me/earthme/luminol/api/entity/EntityTeleportAsyncEvent.java b/src/main/java/me/earthme/luminol/api/entity/EntityTeleportAsyncEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..a31c803831dad3d31386924cbe27deff59855fc9
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/entity/EntityTeleportAsyncEvent.java
+@@ -0,0 +1,68 @@
++package me.earthme.luminol.api.entity;
++
++import org.apache.commons.lang3.Validate;
++import org.bukkit.Location;
++import org.bukkit.entity.Entity;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.player.PlayerTeleportEvent;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A simple event fired when a teleportAsync was called
++ * @see org.bukkit.entity.Entity#teleportAsync(org.bukkit.Location, org.bukkit.event.player.PlayerTeleportEvent.TeleportCause)
++ * @see org.bukkit.entity.Entity#teleportAsync(org.bukkit.Location)
++ * (Also fired when teleportAsync called from nms)
++ */
++public class EntityTeleportAsyncEvent extends Event {
++    private static final HandlerList HANDLERS = new HandlerList();
++
++    private final Entity entity;
++    private final PlayerTeleportEvent.TeleportCause teleportCause;
++    private final Location destination;
++
++    public EntityTeleportAsyncEvent(Entity entity, PlayerTeleportEvent.TeleportCause teleportCause, Location destination) {
++        Validate.notNull(entity, "entity cannot be a null value!");
++        Validate.notNull(teleportCause, "teleportCause cannot be a null value!");
++        Validate.notNull(destination, "destination cannot be a null value!");
++
++        this.entity = entity;
++        this.teleportCause = teleportCause;
++        this.destination = destination;
++    }
++
++    /**
++     * Get the entity is about to be teleported
++     * @return that entity
++     */
++    public @NotNull Entity getEntity() {
++        return this.entity;
++    }
++
++    /**
++     * Get the cause of the teleport
++     * @return the cause
++     */
++    public @NotNull PlayerTeleportEvent.TeleportCause getTeleportCause() {
++        return this.teleportCause;
++    }
++
++    /**
++     * Get the destination of the teleport
++     * @return the destination
++     */
++    public @NotNull Location getDestination() {
++        return this.destination;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLERS;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLERS;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/entity/PostEntityPortalEvent.java b/src/main/java/me/earthme/luminol/api/entity/PostEntityPortalEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..dd3087b407ccf4e96448701e6fbf75705498f982
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/entity/PostEntityPortalEvent.java
+@@ -0,0 +1,41 @@
++package me.earthme.luminol.api.entity;
++
++import org.apache.commons.lang3.Validate;
++import org.bukkit.entity.Entity;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A simple event created for missing teleport events api of folia
++ * This event is fired when the entity portal process has been done
++ */
++public class PostEntityPortalEvent extends Event {
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private final Entity teleportedEntity;
++
++    public PostEntityPortalEvent(Entity teleportedEntity) {
++        Validate.notNull(teleportedEntity, "teleportedEntity cannot be null!");
++
++        this.teleportedEntity = teleportedEntity;
++    }
++
++    /**
++     * Get the entity which was teleported
++     * @return the entity which was teleported
++     */
++    public Entity getTeleportedEntity() {
++        return this.teleportedEntity;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/entity/PreEntityPortalEvent.java b/src/main/java/me/earthme/luminol/api/entity/PreEntityPortalEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..fc844429e3ecfe2529c0a49b8a5d958eeb188ad9
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/entity/PreEntityPortalEvent.java
+@@ -0,0 +1,78 @@
++package me.earthme.luminol.api.entity;
++
++import org.apache.commons.lang3.Validate;
++import org.bukkit.Location;
++import org.bukkit.World;
++import org.bukkit.entity.Entity;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A simple event created for missing teleport events api of folia
++ * This event will be fired when a portal teleportation is about to happen
++ */
++public class PreEntityPortalEvent extends Event implements Cancellable {
++    private static final HandlerList HANDLERS = new HandlerList();
++
++    private final Entity entity;
++    private final Location portalPos;
++    private final World destination;
++
++    private boolean cancelled = false;
++
++    public PreEntityPortalEvent(Entity entity, Location portalPos, World destination) {
++        Validate.notNull(entity, "entity cannot be null!");
++        Validate.notNull(portalPos, "portalPos cannot be null!");
++        Validate.notNull(destination, "destination cannot be null!");
++
++        this.entity = entity;
++        this.portalPos = portalPos;
++        this.destination = destination;
++    }
++
++    /**
++     * Get the entity that is about to teleport
++     * @return the entity
++     */
++    public @NotNull Entity getEntity() {
++        return this.entity;
++    }
++
++    /**
++     * Get the location of the portal
++     * @return the portal location
++     */
++    public @NotNull Location getPortalPos() {
++        return this.portalPos;
++    }
++
++    /**
++     * Get the destination world
++     * @return the destination world
++     */
++    public @NotNull World getDestination() {
++        return this.destination;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLERS;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLERS;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/entity/player/PostPlayerRespawnEvent.java b/src/main/java/me/earthme/luminol/api/entity/player/PostPlayerRespawnEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..9a561455560dfeee1d8762297ebf15a7c11de4d1
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/entity/player/PostPlayerRespawnEvent.java
+@@ -0,0 +1,40 @@
++package me.earthme.luminol.api.entity.player;
++
++import org.apache.commons.lang3.Validate;
++import org.bukkit.entity.Player;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A simple event fired when the respawn process of player is done
++ */
++public class PostPlayerRespawnEvent extends Event {
++    private static final HandlerList HANDLERS = new HandlerList();
++
++    private final Player player;
++
++    public PostPlayerRespawnEvent(Player player) {
++        Validate.notNull(player, "Player cannot be a null value!");
++
++        this.player = player;
++    }
++
++    /**
++     * Get the respawned player
++     * @return the player
++     */
++    public @NotNull Player getPlayer() {
++        return this.player;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLERS;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLERS;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/portal/EndPlatformCreateEvent.java b/src/main/java/me/earthme/luminol/api/portal/EndPlatformCreateEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..cf87a7cce5d1ebec9709b762595609344807150b
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/portal/EndPlatformCreateEvent.java
+@@ -0,0 +1,35 @@
++package me.earthme.luminol.api.portal;
++
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A event fired when an end platform is created.
++ */
++public class EndPlatformCreateEvent extends Event implements Cancellable {
++    private static final HandlerList HANDLERS = new HandlerList();
++
++    private boolean cancelled = false;
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLERS;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLERS;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/portal/PortalLocateEvent.java b/src/main/java/me/earthme/luminol/api/portal/PortalLocateEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..e09ffb99aad6f6acca3d6a411877715b90413eb0
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/portal/PortalLocateEvent.java
+@@ -0,0 +1,53 @@
++package me.earthme.luminol.api.portal;
++
++import org.apache.commons.lang3.Validate;
++import org.bukkit.Location;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A event fired when the portal process started locating the destination position
++ * Notice: If you changed the destination to an another position in end teleportation.The end platform won't create under the entity and won't create
++ * if the position is out of current tick region
++ */
++public class PortalLocateEvent extends Event {
++    private static final HandlerList HANDLERS = new HandlerList();
++
++    private final Location original;
++    private final Location destination;
++
++    public PortalLocateEvent(Location original, Location destination) {
++        Validate.notNull(original, "original couldn't be null!");
++        Validate.notNull(destination, "destination couldn't be null!");
++
++        this.original = original;
++        this.destination = destination;
++    }
++
++    /**
++     * Get the destination position of this teleportation
++     * @return the destination position
++     */
++    public Location getDestination() {
++        return this.destination;
++    }
++
++    /**
++     * Get the original portal position of this teleportation
++     * @return the original portal position
++     */
++    public Location getOriginal() {
++        return this.original;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLERS;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLERS;
++    }
++}

luminol-api/paper-patches/features/0011-Leaves-Fix-SculkCatalyst-exp-skip.patch

@@ -0,0 +1,38 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: violetc <58360096+s-yh-china@users.noreply.github.com>
+Date: Sun, 6 Apr 2025 10:42:47 +0800
+Subject: [PATCH] Leaves Fix SculkCatalyst exp skip
+
+Co-authored by: violetc <58360096+s-yh-china@users.noreply.github.com>
+As part of: Leaves (https://github.com/LeavesMC/Leaves/blob/master/leaves-api/paper-patches/features/0008-Fix-SculkCatalyst-exp-skip.patch)
+Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
+
+diff --git a/src/main/java/org/bukkit/event/entity/PlayerDeathEvent.java b/src/main/java/org/bukkit/event/entity/PlayerDeathEvent.java
+index ab7584873e46020148bceecbd42a43055684e6a0..f33ab20313310a113d6c88e0fc1fe1666218061e 100644
+--- a/src/main/java/org/bukkit/event/entity/PlayerDeathEvent.java
++++ b/src/main/java/org/bukkit/event/entity/PlayerDeathEvent.java
+@@ -18,6 +18,7 @@ public class PlayerDeathEvent extends EntityDeathEvent {
+     private boolean keepLevel = false;
+     private boolean keepInventory = false;
+     private boolean doExpDrop; // Paper - shouldDropExperience API
++    private boolean useApiExpDropStatus = false; // Leaves - exp fix
+     // Paper start - adventure
+     @org.jetbrains.annotations.ApiStatus.Internal
+     public PlayerDeathEvent(final @NotNull Player player, final @NotNull DamageSource damageSource, final @NotNull List<ItemStack> drops, final int droppedExp, final @Nullable net.kyori.adventure.text.Component deathMessage) {
+@@ -122,9 +123,16 @@ public class PlayerDeathEvent extends EntityDeathEvent {
+      */
+     public void setShouldDropExperience(boolean doExpDrop) {
+         this.doExpDrop = doExpDrop;
++        this.useApiExpDropStatus = true; // Leaves - exp fix
+     }
+     // Paper end - shouldDropExperience API
+ 
++    // Leaves start - exp fix
++    public boolean forceUseEventDropStatus() {
++        return this.useApiExpDropStatus;
++    }
++    // Leaves end - exp fix
++
+     @NotNull
+     @Override
+     public Player getEntity() {

luminol-api/src/main/java/gg/pufferfish/pufferfish/sentry/SentryContext.java

@@ -1,165 +0,0 @@
-package gg.pufferfish.pufferfish.sentry;
-
-import com.google.gson.Gson;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.util.Map;
-import java.util.TreeMap;
-
-import org.apache.logging.log4j.ThreadContext;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.bukkit.event.Event;
-import org.bukkit.event.player.PlayerEvent;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.plugin.RegisteredListener;
-import org.jetbrains.annotations.Nullable;
-
-public class SentryContext {
-
-    private static final Gson GSON = new Gson();
-
-    public static void setPluginContext(@Nullable Plugin plugin) {
-        if (plugin != null) {
-            ThreadContext.put("pufferfishsentry_pluginname", plugin.getName());
-            ThreadContext.put("pufferfishsentry_pluginversion", plugin.getPluginMeta().getVersion());
-        }
-    }
-
-    public static void removePluginContext() {
-        ThreadContext.remove("pufferfishsentry_pluginname");
-        ThreadContext.remove("pufferfishsentry_pluginversion");
-    }
-
-    public static void setSenderContext(@Nullable CommandSender sender) {
-        if (sender != null) {
-            ThreadContext.put("pufferfishsentry_playername", sender.getName());
-            if (sender instanceof Player player) {
-                ThreadContext.put("pufferfishsentry_playerid", player.getUniqueId().toString());
-            }
-        }
-    }
-
-    public static void removeSenderContext() {
-        ThreadContext.remove("pufferfishsentry_playername");
-        ThreadContext.remove("pufferfishsentry_playerid");
-    }
-
-    public static void setEventContext(Event event, RegisteredListener registration) {
-        setPluginContext(registration.getPlugin());
-
-        try {
-            // Find the player that was involved with this event
-            Player player = null;
-            if (event instanceof PlayerEvent) {
-                player = ((PlayerEvent) event).getPlayer();
-            } else {
-                Class<? extends Event> eventClass = event.getClass();
-
-                Field playerField = null;
-
-                for (Field field : eventClass.getDeclaredFields()) {
-                    if (field.getType().equals(Player.class)) {
-                        playerField = field;
-                        break;
-                    }
-                }
-
-                if (playerField != null) {
-                    playerField.setAccessible(true);
-                    player = (Player) playerField.get(event);
-                }
-            }
-
-            if (player != null) {
-                setSenderContext(player);
-            }
-        } catch (Exception ignored) {
-        } // We can't really safely log exceptions.
-
-        ThreadContext.put("pufferfishsentry_eventdata", GSON.toJson(serializeFields(event)));
-    }
-
-    public static void removeEventContext() {
-        removePluginContext();
-        removeSenderContext();
-        ThreadContext.remove("pufferfishsentry_eventdata");
-    }
-
-    private static Map<String, String> serializeFields(Object object) {
-        Map<String, String> fields = new TreeMap<>();
-        fields.put("_class", object.getClass().getName());
-        for (Field declaredField : object.getClass().getDeclaredFields()) {
-            try {
-                if (Modifier.isStatic(declaredField.getModifiers())) {
-                    continue;
-                }
-
-                String fieldName = declaredField.getName();
-                if (fieldName.equals("handlers")) {
-                    continue;
-                }
-                declaredField.setAccessible(true);
-                Object value = declaredField.get(object);
-                if (value != null) {
-                    fields.put(fieldName, value.toString());
-                } else {
-                    fields.put(fieldName, "<null>");
-                }
-            } catch (Exception ignored) {
-            } // We can't really safely log exceptions.
-        }
-        return fields;
-    }
-
-    public static class State {
-
-        private Plugin plugin;
-        private Command command;
-        private String commandLine;
-        private Event event;
-        private RegisteredListener registeredListener;
-
-        public Plugin getPlugin() {
-            return plugin;
-        }
-
-        public void setPlugin(Plugin plugin) {
-            this.plugin = plugin;
-        }
-
-        public Command getCommand() {
-            return command;
-        }
-
-        public void setCommand(Command command) {
-            this.command = command;
-        }
-
-        public String getCommandLine() {
-            return commandLine;
-        }
-
-        public void setCommandLine(String commandLine) {
-            this.commandLine = commandLine;
-        }
-
-        public Event getEvent() {
-            return event;
-        }
-
-        public void setEvent(Event event) {
-            this.event = event;
-        }
-
-        public RegisteredListener getRegisteredListener() {
-            return registeredListener;
-        }
-
-        public void setRegisteredListener(RegisteredListener registeredListener) {
-            this.registeredListener = registeredListener;
-        }
-    }
-}

luminol-api/src/main/java/gg/pufferfish/pufferfish/simd/SIMDChecker.java

@@ -1,35 +0,0 @@
-package gg.pufferfish.pufferfish.simd;
-
-import jdk.incubator.vector.FloatVector;
-import jdk.incubator.vector.IntVector;
-import jdk.incubator.vector.VectorSpecies;
-import org.slf4j.Logger;
-
-/**
- * Basically, java is annoying and we have to push this out to its own class.
- */
-@Deprecated
-public class SIMDChecker {
-	
-	@Deprecated
-	public static boolean canEnable(Logger logger) {
-		try {
-			SIMDDetection.testRun = true;
-
-			VectorSpecies<Integer> ISPEC = IntVector.SPECIES_PREFERRED;
-			VectorSpecies<Float> FSPEC = FloatVector.SPECIES_PREFERRED;
-
-			logger.info("Max SIMD vector size on this system is {} bits (int)", ISPEC.vectorBitSize());
-			logger.info("Max SIMD vector size on this system is " + FSPEC.vectorBitSize() + " bits (float)");
-
-			if (ISPEC.elementSize() < 2 || FSPEC.elementSize() < 2) {
-				logger.warn("SIMD is not properly supported on this system!");
-				return false;
-			}
-
-			return true;
-		} catch (NoClassDefFoundError | Exception ignored) {} // Basically, we don't do anything. This lets us detect if it's not functional and disable it.
-		return false;
-	}
-	
-}

luminol-api/src/main/java/gg/pufferfish/pufferfish/simd/SIMDDetection.java

@@ -1,34 +0,0 @@
-package gg.pufferfish.pufferfish.simd;
-
-import org.slf4j.Logger;
-
-@Deprecated
-public class SIMDDetection {
-	
-	public static boolean isEnabled = false;
-	public static boolean testRun = false;
-	
-	@Deprecated
-	public static boolean canEnable(Logger logger) {
-		try {
-			return SIMDChecker.canEnable(logger);
-		} catch (NoClassDefFoundError | Exception ignored) {
-			return false;
-		}
-	}
-	
-	@Deprecated
-	public static int getJavaVersion() {
-		// https://stackoverflow.com/a/2591122
-		String version = System.getProperty("java.version");
-		if(version.startsWith("1.")) {
-			version = version.substring(2, 3);
-		} else {
-			int dot = version.indexOf(".");
-			if(dot != -1) { version = version.substring(0, dot); }
-		}
-		version = version.split("-")[0]; // Azul is stupid
-		return Integer.parseInt(version);
-	}
-	
-}

luminol-api/src/main/java/gg/pufferfish/pufferfish/simd/VectorMapPalette.java

@@ -1,84 +0,0 @@
-package gg.pufferfish.pufferfish.simd;
-
-import jdk.incubator.vector.FloatVector;
-import jdk.incubator.vector.IntVector;
-import jdk.incubator.vector.VectorMask;
-import jdk.incubator.vector.VectorSpecies;
-import org.bukkit.map.MapPalette;
-
-import java.awt.*;
-
-@Deprecated
-public class VectorMapPalette {
-
-    private static final VectorSpecies<Integer> I_SPEC = IntVector.SPECIES_PREFERRED;
-    private static final VectorSpecies<Float> F_SPEC = FloatVector.SPECIES_PREFERRED;
-
-    @Deprecated
-    public static void matchColorVectorized(int[] in, byte[] out) {
-        int speciesLength = I_SPEC.length();
-        int i;
-        for (i = 0; i < in.length - speciesLength; i += speciesLength) {
-            float[] redsArr = new float[speciesLength];
-            float[] bluesArr = new float[speciesLength];
-            float[] greensArr = new float[speciesLength];
-            int[] alphasArr = new int[speciesLength];
-
-            for (int j = 0; j < speciesLength; j++) {
-                alphasArr[j] = (in[i + j] >> 24) & 0xFF;
-                redsArr[j] = (in[i + j] >> 16) & 0xFF;
-                greensArr[j] = (in[i + j] >> 8) & 0xFF;
-                bluesArr[j] = (in[i + j] >> 0) & 0xFF;
-            }
-
-            IntVector alphas = IntVector.fromArray(I_SPEC, alphasArr, 0);
-            FloatVector reds = FloatVector.fromArray(F_SPEC, redsArr, 0);
-            FloatVector greens = FloatVector.fromArray(F_SPEC, greensArr, 0);
-            FloatVector blues = FloatVector.fromArray(F_SPEC, bluesArr, 0);
-            IntVector resultIndex = IntVector.zero(I_SPEC);
-            VectorMask<Integer> modificationMask = VectorMask.fromLong(I_SPEC, 0xffffffff);
-
-            modificationMask = modificationMask.and(alphas.lt(128).not());
-            FloatVector bestDistances = FloatVector.broadcast(F_SPEC, Float.MAX_VALUE);
-
-            for (int c = 4; c < MapPalette.colors.length; c++) {
-                // We're using 32-bit floats here because it's 2x faster and nobody will know the difference.
-                // For correctness, the original algorithm uses 64-bit floats instead. Completely unnecessary.
-                FloatVector compReds = FloatVector.broadcast(F_SPEC, MapPalette.colors[c].getRed());
-                FloatVector compGreens = FloatVector.broadcast(F_SPEC, MapPalette.colors[c].getGreen());
-                FloatVector compBlues = FloatVector.broadcast(F_SPEC, MapPalette.colors[c].getBlue());
-
-                FloatVector rMean = reds.add(compReds).div(2.0f);
-                FloatVector rDiff = reds.sub(compReds);
-                FloatVector gDiff = greens.sub(compGreens);
-                FloatVector bDiff = blues.sub(compBlues);
-
-                FloatVector weightR = rMean.div(256.0f).add(2);
-                FloatVector weightG = FloatVector.broadcast(F_SPEC, 4.0f);
-                FloatVector weightB = FloatVector.broadcast(F_SPEC, 255.0f).sub(rMean).div(256.0f).add(2.0f);
-
-                FloatVector distance = weightR.mul(rDiff).mul(rDiff).add(weightG.mul(gDiff).mul(gDiff)).add(weightB.mul(bDiff).mul(bDiff));
-
-                // Now we compare to the best distance we've found.
-                // This mask contains a "1" if better, and a "0" otherwise.
-                VectorMask<Float> bestDistanceMask = distance.lt(bestDistances);
-                bestDistances = bestDistances.blend(distance, bestDistanceMask); // Update the best distances
-
-                // Update the result array
-                // We also AND with the modification mask because we don't want to interfere if the alpha value isn't large enough.
-                resultIndex = resultIndex.blend(c, bestDistanceMask.cast(I_SPEC).and(modificationMask)); // Update the results
-            }
-
-            for (int j = 0; j < speciesLength; j++) {
-                int index = resultIndex.lane(j);
-                out[i + j] = (byte) (index < 128 ? index : -129 + (index - 127));
-            }
-        }
-
-        // For the final ones, fall back to the regular method
-        for (; i < in.length; i++) {
-            out[i] = MapPalette.matchColor(new Color(in[i], true));
-        }
-    }
-
-}

luminol-api/src/main/java/me/earthme/luminol/api/RegionStats.java

@@ -1,25 +0,0 @@
-package me.earthme.luminol.api;
-
-/**
- * A simple package of folia's tick region state.It linked to the RegionStats of the nms part so that</br>
- * You could call these methods to get the status of this tick region</br>
- */
-public interface RegionStats {
-    /**
-     * Get the entity count in this tick region
-     * @return the entity count
-     */
-    int getEntityCount();
-
-    /**
-     * Get the player count in this tick region
-     * @return the player count
-     */
-    int getPlayerCount();
-
-    /**
-     * Get the chunk count in this tick region
-     * @return the chunk count
-     */
-    int getChunkCount();
-}

luminol-api/src/main/java/me/earthme/luminol/api/ThreadedRegion.java

@@ -1,56 +0,0 @@
-package me.earthme.luminol.api;
-
-import org.bukkit.Location;
-import org.bukkit.World;
-
-import javax.annotation.Nullable;
-
-/**
- * A mirror of folia's ThreadedRegion</br>
- * Including some handy methods to get the information of the tick region</br>
- * Note: You should call these methods inside this tick region's thread context
- */
-public interface ThreadedRegion {
-    /**
-     * Get the center chunk pos of this tick region</br>
-     * Note:</br>
-     *      1.Global region will return a null value(But we don't finish the global region yet()</br>
-     *      2.You should call these methods inside this tick region's thread context
-     * @return The center chunk pos
-     */
-    @Nullable
-    Location getCenterChunkPos();
-
-    /**
-     * Get the dead section percent of this tick region
-     * Note: </br>
-     *      1.Dead percent is mean the percent of the unloaded chunk count of this tick region, which is also used for determine
-     * that the tick region should or not check for splitting</br>
-     *      2.You should call these methods inside this tick region's thread context
-     * @return The dead section percent
-     */
-    double getDeadSectionPercent();
-
-    /**
-     * Get the tick region data of this tick region</br>
-     * Note:</br>
-     *       1.You should call this method inside this tick region's thread context</br>
-     *       2.You should call these methods inside this tick region's thread context
-     * @return The tick region data
-     */
-    TickRegionData getTickRegionData();
-
-    /**
-     * Get the world of this tick region</br>
-     * Note: Global region will return a null value too
-     * @return The world of this tick region
-     */
-    @Nullable
-    World getWorld();
-
-    /**
-     * Get the id of the tick region</br>
-     * @return The id of the tick region
-     */
-    long getId();
-}

luminol-api/src/main/java/me/earthme/luminol/api/ThreadedRegionizer.java

@@ -1,56 +0,0 @@
-package me.earthme.luminol.api;
-
-import org.bukkit.Location;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Collection;
-
-/**
- * A mirror of folia's ThreadedRegionizer
- */
-public interface ThreadedRegionizer {
-    /**
-     * Get all the tick regions
-     * @return Temporary copied collection of all tick regions
-     */
-    Collection<ThreadedRegion> getAllRegions();
-
-    /**
-     * Get the tick region at the given chunk coordinates
-     * @param chunkX Chunk X
-     * @param chunkZ Chunk Z
-     * @return The tick region at the given chunk coordinates
-     */
-    @Nullable
-    ThreadedRegion getAtSynchronized(int chunkX, int chunkZ);
-
-    /**
-     * Get the tick region at the given chunk coordinates
-     * @param chunkX Chunk X
-     * @param chunkZ Chunk Z
-     * @return The tick region at the given chunk coordinates
-     */
-    @Nullable
-    ThreadedRegion getAtUnSynchronized(int chunkX, int chunkZ);
-
-    /**
-     * Get the tick region at the given location
-     * @param pos The location
-     * @return The tick region at the given location
-     */
-    @Nullable
-    default ThreadedRegion getAtSynchronized(@NotNull Location pos) {
-        return this.getAtSynchronized(pos.getBlockX() >> 4, pos.getBlockZ() >> 4);
-    }
-
-    /**
-     * Get the tick region at the given location
-     * @param pos The location
-     * @return The tick region at the given location
-     */
-    @Nullable
-    default ThreadedRegion getAtUnSynchronized(@NotNull Location pos) {
-        return this.getAtUnSynchronized(pos.getBlockX() >> 4, pos.getBlockZ() >> 4);
-    }
-}

luminol-api/src/main/java/me/earthme/luminol/api/TickRegionData.java

@@ -1,26 +0,0 @@
-package me.earthme.luminol.api;
-
-import org.bukkit.World;
-
-/**
- * A mirror of folia's tick region data
- */
-public interface TickRegionData {
-    /**
-     * Get the world it's currently holding
-     * @return the world
-     */
-    World getWorld();
-
-    /**
-     * Get the current tick count
-     * @return the current tick count
-     */
-    long getCurrentTickCount();
-
-    /**
-     * Get the region stats
-     * @return the region stats
-     */
-    RegionStats getRegionStats();
-}

luminol-api/src/main/java/me/earthme/luminol/api/entity/EntityTeleportAsyncEvent.java

@@ -1,68 +0,0 @@
-package me.earthme.luminol.api.entity;
-
-import org.apache.commons.lang3.Validate;
-import org.bukkit.Location;
-import org.bukkit.entity.Entity;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.player.PlayerTeleportEvent;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * A simple event fired when a teleportAsync was called
- * @see org.bukkit.entity.Entity#teleportAsync(org.bukkit.Location, org.bukkit.event.player.PlayerTeleportEvent.TeleportCause)
- * @see org.bukkit.entity.Entity#teleportAsync(org.bukkit.Location)
- * (Also fired when teleportAsync called from nms)
- */
-public class EntityTeleportAsyncEvent extends Event {
-    private static final HandlerList HANDLERS = new HandlerList();
-
-    private final Entity entity;
-    private final PlayerTeleportEvent.TeleportCause teleportCause;
-    private final Location destination;
-
-    public EntityTeleportAsyncEvent(Entity entity, PlayerTeleportEvent.TeleportCause teleportCause, Location destination) {
-        Validate.notNull(entity, "entity cannot be a null value!");
-        Validate.notNull(teleportCause, "teleportCause cannot be a null value!");
-        Validate.notNull(destination, "destination cannot be a null value!");
-
-        this.entity = entity;
-        this.teleportCause = teleportCause;
-        this.destination = destination;
-    }
-
-    /**
-     * Get the entity is about to be teleported
-     * @return that entity
-     */
-    public @NotNull Entity getEntity() {
-        return this.entity;
-    }
-
-    /**
-     * Get the cause of the teleport
-     * @return the cause
-     */
-    public @NotNull PlayerTeleportEvent.TeleportCause getTeleportCause() {
-        return this.teleportCause;
-    }
-
-    /**
-     * Get the destination of the teleport
-     * @return the destination
-     */
-    public @NotNull Location getDestination() {
-        return this.destination;
-    }
-
-    @Override
-    public @NotNull HandlerList getHandlers() {
-        return HANDLERS;
-    }
-
-    @NotNull
-    public static HandlerList getHandlerList() {
-        return HANDLERS;
-    }
-}

luminol-api/src/main/java/me/earthme/luminol/api/entity/PostEntityPortalEvent.java

@@ -1,41 +0,0 @@
-package me.earthme.luminol.api.entity;
-
-import org.apache.commons.lang3.Validate;
-import org.bukkit.entity.Entity;
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * A simple event created for missing teleport events api of folia
- * This event is fired when the entity portal process has been done
- */
-public class PostEntityPortalEvent extends Event {
-    private static final HandlerList HANDLER_LIST = new HandlerList();
-
-    private final Entity teleportedEntity;
-
-    public PostEntityPortalEvent(Entity teleportedEntity) {
-        Validate.notNull(teleportedEntity, "teleportedEntity cannot be null!");
-
-        this.teleportedEntity = teleportedEntity;
-    }
-
-    /**
-     * Get the entity which was teleported
-     * @return the entity which was teleported
-     */
-    public Entity getTeleportedEntity() {
-        return this.teleportedEntity;
-    }
-
-    @Override
-    public @NotNull HandlerList getHandlers() {
-        return HANDLER_LIST;
-    }
-
-    @NotNull
-    public static HandlerList getHandlerList() {
-        return HANDLER_LIST;
-    }
-}

luminol-api/src/main/java/me/earthme/luminol/api/entity/PreEntityPortalEvent.java

@@ -1,78 +0,0 @@
-package me.earthme.luminol.api.entity;
-
-import org.apache.commons.lang3.Validate;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.entity.Entity;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * A simple event created for missing teleport events api of folia
- * This event will be fired when a portal teleportation is about to happen
- */
-public class PreEntityPortalEvent extends Event implements Cancellable {
-    private static final HandlerList HANDLERS = new HandlerList();
-
-    private final Entity entity;
-    private final Location portalPos;
-    private final World destination;
-
-    private boolean cancelled = false;
-
-    public PreEntityPortalEvent(Entity entity, Location portalPos, World destination) {
-        Validate.notNull(entity, "entity cannot be null!");
-        Validate.notNull(portalPos, "portalPos cannot be null!");
-        Validate.notNull(destination, "destination cannot be null!");
-
-        this.entity = entity;
-        this.portalPos = portalPos;
-        this.destination = destination;
-    }
-
-    /**
-     * Get the entity that is about to teleport
-     * @return the entity
-     */
-    public @NotNull Entity getEntity() {
-        return this.entity;
-    }
-
-    /**
-     * Get the location of the portal
-     * @return the portal location
-     */
-    public @NotNull Location getPortalPos() {
-        return this.portalPos;
-    }
-
-    /**
-     * Get the destination world
-     * @return the destination world
-     */
-    public @NotNull World getDestination() {
-        return this.destination;
-    }
-
-    @Override
-    public boolean isCancelled() {
-        return this.cancelled;
-    }
-
-    @Override
-    public void setCancelled(boolean cancel) {
-        this.cancelled = cancel;
-    }
-
-    @Override
-    public @NotNull HandlerList getHandlers() {
-        return HANDLERS;
-    }
-
-    @NotNull
-    public static HandlerList getHandlerList() {
-        return HANDLERS;
-    }
-}

luminol-api/src/main/java/me/earthme/luminol/api/entity/player/PostPlayerRespawnEvent.java

@@ -1,40 +0,0 @@
-package me.earthme.luminol.api.entity.player;
-
-import org.apache.commons.lang3.Validate;
-import org.bukkit.entity.Player;
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * A simple event fired when the respawn process of player is done
- */
-public class PostPlayerRespawnEvent extends Event {
-    private static final HandlerList HANDLERS = new HandlerList();
-
-    private final Player player;
-
-    public PostPlayerRespawnEvent(Player player) {
-        Validate.notNull(player, "Player cannot be a null value!");
-
-        this.player = player;
-    }
-
-    /**
-     * Get the respawned player
-     * @return the player
-     */
-    public @NotNull Player getPlayer() {
-        return this.player;
-    }
-
-    @Override
-    public @NotNull HandlerList getHandlers() {
-        return HANDLERS;
-    }
-
-    @NotNull
-    public static HandlerList getHandlerList() {
-        return HANDLERS;
-    }
-}

luminol-api/src/main/java/me/earthme/luminol/api/portal/EndPlatformCreateEvent.java

@@ -1,35 +0,0 @@
-package me.earthme.luminol.api.portal;
-
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * A event fired when an end platform is created.
- */
-public class EndPlatformCreateEvent extends Event implements Cancellable {
-    private static final HandlerList HANDLERS = new HandlerList();
-
-    private boolean cancelled = false;
-
-    @Override
-    public boolean isCancelled() {
-        return this.cancelled;
-    }
-
-    @Override
-    public void setCancelled(boolean cancel) {
-        this.cancelled = cancel;
-    }
-
-    @Override
-    public @NotNull HandlerList getHandlers() {
-        return HANDLERS;
-    }
-
-    @NotNull
-    public static HandlerList getHandlerList() {
-        return HANDLERS;
-    }
-}

luminol-api/src/main/java/me/earthme/luminol/api/portal/PortalLocateEvent.java

@@ -1,53 +0,0 @@
-package me.earthme.luminol.api.portal;
-
-import org.apache.commons.lang3.Validate;
-import org.bukkit.Location;
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * A event fired when the portal process started locating the destination position
- * Notice: If you changed the destination to an another position in end teleportation.The end platform won't create under the entity and won't create
- * if the position is out of current tick region
- */
-public class PortalLocateEvent extends Event {
-    private static final HandlerList HANDLERS = new HandlerList();
-
-    private final Location original;
-    private final Location destination;
-
-    public PortalLocateEvent(Location original, Location destination) {
-        Validate.notNull(original, "original couldn't be null!");
-        Validate.notNull(destination, "destination couldn't be null!");
-
-        this.original = original;
-        this.destination = destination;
-    }
-
-    /**
-     * Get the destination position of this teleportation
-     * @return the destination position
-     */
-    public Location getDestination() {
-        return this.destination;
-    }
-
-    /**
-     * Get the original portal position of this teleportation
-     * @return the original portal position
-     */
-    public Location getOriginal() {
-        return this.original;
-    }
-
-    @Override
-    public @NotNull HandlerList getHandlers() {
-        return HANDLERS;
-    }
-
-    @NotNull
-    public static HandlerList getHandlerList() {
-        return HANDLERS;
-    }
-}

luminol-server/build.gradle.kts.patch

@@ -1,14 +1,17 @@
 --- a/folia-server/build.gradle.kts
 +++ b/folia-server/build.gradle.kts
-@@ -27,6 +_,7 @@
-     gitFilePatches = false
-     
+@@ -20,8 +_,9 @@
+     minecraftVersion = providers.gradleProperty("mcVersion")
+     // macheOldPath = file("F:\\Projects\\PaperTooling\\mache\\versions\\1.21.4\\src\\main\\java")
+     // gitFilePatches = true
+-    
++
      val fork = forks.register("folia") {
 +        rootDirectory = upstreamsDirectory().map { it.dir("folia") }
          upstream.patchDir("paperServer") {
              upstreamPath = "paper-server"
              excludes = setOf("src/minecraft", "patches", "build.gradle.kts")
-@@ -35,7 +_,23 @@
+@@ -30,7 +_,23 @@
          }
      }
  
@@ -31,11 +34,11 @@
 +
 +    activeFork = luminol
  
- 
      spigot {
-@@ -123,10 +_,14 @@
+         buildDataRef = "3edaf46ec1eed4115ce1b18d2846cded42577e42"
+@@ -116,10 +_,14 @@
      main {
-         java { srcDir("../paper-server/src/main/java"); srcDir("../paper-server/src/generated/java") }
+         java { srcDir("../paper-server/src/main/java") }
          resources { srcDir("../paper-server/src/main/resources") }
 +        java { srcDir("../folia-server/src/main/java") }
 +        resources { srcDir("../folia-server/src/main/resources") }
@@ -47,14 +50,14 @@
 +        resources { srcDir("../folia-server/src/test/resources") }
      }
  }
- val log4jPlugins = sourceSets.create("log4jPlugins") {
-@@ -153,12 +_,20 @@
+ 
+@@ -143,7 +_,14 @@
  }
  
  dependencies {
 -    implementation(project(":folia-api"))
 +    implementation(project(":luminol-api")) // Luminol
-+    implementation("com.electronwill.night-config:toml:3.8.2") // Luminol - Night config
++    implementation("com.electronwill.night-config:toml:3.6.6") // Luminol - Night config
 +    // Abomination start
 +    implementation("com.github.luben:zstd-jni:1.5.4-1")
 +    implementation("org.lz4:lz4-java:1.8.0")
@@ -64,23 +67,17 @@
      implementation("ca.spottedleaf:concurrentutil:0.0.3")
      implementation("org.jline:jline-terminal-ffm:3.27.1") // use ffm on java 22+
      implementation("org.jline:jline-terminal-jni:3.27.1") // fall back to jni on java 21
-     implementation("net.minecrell:terminalconsoleappender:1.3.0")
-     implementation("net.kyori:adventure-text-serializer-ansi:4.21.0") // Keep in sync with adventureVersion from Paper-API build file
-+    implementation("net.openhft:affinity:3.23.3") // Luminol
-     runtimeConfiguration(sourceSets.main.map { it.runtimeClasspath })
- 
-     /*
-@@ -216,27 +_,33 @@
-     implementation("me.lucko:spark-api:0.1-20240720.200737-2")
-     implementation("me.lucko:spark-paper:1.10.133-20250413.112336-1")
+@@ -201,26 +_,33 @@
+     implementation("me.lucko:spark-paper:1.10.119-20241121.092015-1")
  }
+ 
 +// Pufferfish Start
 +tasks.withType<JavaCompile> {
 +    val compilerArgs = options.compilerArgs
 +    compilerArgs.add("--add-modules=jdk.incubator.vector")
 +}
 +// Pufferfish End
- 
++
  tasks.jar {
      manifest {
          val git = Git(rootProject.layout.projectDirectory.path)
@@ -110,12 +107,14 @@
              "Build-Number" to (build ?: ""),
              "Build-Time" to buildTime.toString(),
              "Git-Branch" to gitBranch,
-@@ -400,7 +_,7 @@
+@@ -351,3 +_,10 @@
+     classpath(tasks.createReobfPaperclipJar.flatMap { it.outputZip })
+     mainClass.set(null as String?)
  }
- 
- fill {
--    project("folia")
-+    project("luminol") // Luminol
-     versionFamily(paperweight.minecraftVersion.map { it.split(".", "-").takeWhile { part -> part.toIntOrNull() != null }.take(2).joinToString(".") })
-     version(paperweight.minecraftVersion)
- 
++
++// Pufferfish Start
++tasks.withType<JavaCompile> {
++    val compilerArgs = options.compilerArgs
++    compilerArgs.add("--add-modules=jdk.incubator.vector")
++}
++// Pufferfish End

luminol-server/minecraft-patches/features/0001-Add-config-for-command-block-command-execution.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:36:31 +0800
+Subject: [PATCH] Add config for command block command execution
+
+
+diff --git a/net/minecraft/world/level/BaseCommandBlock.java b/net/minecraft/world/level/BaseCommandBlock.java
+index b02b79ccedb8b87bc22270377dfc36e21ebe1724..3786e8288c3a66a5e986ae2a150d03ce2dd5ed16 100644
+--- a/net/minecraft/world/level/BaseCommandBlock.java
++++ b/net/minecraft/world/level/BaseCommandBlock.java
+@@ -114,7 +114,7 @@ public abstract class BaseCommandBlock implements CommandSource {
+     }
+ 
+     public boolean performCommand(Level level) {
+-        if (true) return false; // Folia - region threading
++        if (!me.earthme.luminol.config.modules.experiment.CommandBlockConfig.enabled) return false; // Folia - region threading // Luminol
+         if (level.isClientSide || level.getGameTime() == this.lastExecution) {
+             return false;
+         } else if ("Searge".equalsIgnoreCase(this.command)) {

luminol-server/minecraft-patches/features/0001-Rebrand-to-Luminol.patch

@@ -1,31 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Helvetica Volubi <suisuroru@blue-millennium.fun>
-Date: Sun, 22 Jun 2025 23:53:59 +0800
-Subject: [PATCH] Rebrand to Luminol
-
-
-diff --git a/net/minecraft/server/Main.java b/net/minecraft/server/Main.java
-index fd3553bdc1c3cdbf6aa3dc00e0a4987f8eaa4fb8..a75a5ce8477da8d3f7b0ae41bfbd75defe1d2ed4 100644
---- a/net/minecraft/server/Main.java
-+++ b/net/minecraft/server/Main.java
-@@ -109,6 +109,7 @@ public class Main {
-                 JvmProfiler.INSTANCE.start(Environment.SERVER);
-             }
- 
-+            me.earthme.luminol.config.LuminolConfig.preLoadConfig(); // Luminol - Luminol config
-             io.papermc.paper.plugin.PluginInitializerManager.load(optionSet); // Paper
-             Bootstrap.bootStrap();
-             Bootstrap.validate();
-diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
-index d8bab0ba6e2374fb74f3fa9f7db802f442240414..f21026ef975864700ad5ef86052acdcb7621e210 100644
---- a/net/minecraft/server/dedicated/DedicatedServer.java
-+++ b/net/minecraft/server/dedicated/DedicatedServer.java
-@@ -171,6 +171,8 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
-         this.paperConfigurations.initializeGlobalConfiguration(this.registryAccess());
-         this.paperConfigurations.initializeWorldDefaultsConfiguration(this.registryAccess());
-         // Paper end - initialize global and world-defaults configuration
-+        me.earthme.luminol.config.LuminolConfig.finalizeLoadConfig(); // Luminol - load config file
-+        me.earthme.luminol.config.LuminolConfig.setupLatch(); // Luminol - load config file
-         this.server.spark.enableEarlyIfRequested(); // Paper - spark
-         // Paper start - fix converting txt to json file; convert old users earlier after PlayerList creation but before file load/save
-         if (this.convertOldUsers()) {

luminol-server/minecraft-patches/features/0002-Add-config-for-entity-to-clean-memory-value-which-is.patch

@@ -7,10 +7,10 @@ Subject: [PATCH] Add config for entity to clean memory value which is not
 Folia does not fully get the entity AI patched correctly, like some memories in entity's brain is still exists when switched dimension or teleported to the new tickregion, which entity is still accessing in the next tick then it will trigger the async catcher, which lead the entity go disappear and throw an exception in the console.In this patch, if this function is turned on, the server will clean the memory that doesn't belong to the entity's tickregion before ticking any behaviors, which can simply fix that.
 
 diff --git a/net/minecraft/world/entity/ai/Brain.java b/net/minecraft/world/entity/ai/Brain.java
-index 3eb1362e6597faa21b27c9d1611d64a236491f98..c589e18b68e45d5991291db3a0bdd833588ce945 100644
+index 65b2b3ece213d901cdd585093e2fafcd2ef4a7cd..52b08be8b37117edc38dddf6d1919178b1f86271 100644
 --- a/net/minecraft/world/entity/ai/Brain.java
 +++ b/net/minecraft/world/entity/ai/Brain.java
-@@ -408,7 +408,7 @@ public class Brain<E extends LivingEntity> {
+@@ -399,7 +399,7 @@ public class Brain<E extends LivingEntity> {
      }
  
      public void tick(ServerLevel level, E entity) {
@@ -19,7 +19,7 @@ index 3eb1362e6597faa21b27c9d1611d64a236491f98..c589e18b68e45d5991291db3a0bdd833
          this.tickSensors(level, entity);
          this.startEachNonRunningBehavior(level, entity);
          this.tickEachRunningBehavior(level, entity);
-@@ -420,10 +420,31 @@ public class Brain<E extends LivingEntity> {
+@@ -411,10 +411,31 @@ public class Brain<E extends LivingEntity> {
          }
      }
  

luminol-server/minecraft-patches/features/0003-Add-config-for-offline-mode-warning.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Add config for offline mode warning
 
 
 diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
-index f21026ef975864700ad5ef86052acdcb7621e210..61d63e5668e110e9c0b891959bf4cd7c91e54645 100644
+index 375f4a59333ee1d75fb1acb8c2cbada7866bd48e..f4b738b05ec9488e20402efb6c935ff55d86adf2 100644
 --- a/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/net/minecraft/server/dedicated/DedicatedServer.java
-@@ -243,7 +243,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+@@ -285,7 +285,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
          String proxyFlavor = (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled) ? "Velocity" : "BungeeCord";
          String proxyLink = (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled) ? "https://docs.papermc.io/velocity/security" : "http://www.spigotmc.org/wiki/firewall-guide/";
          // Paper end - Add Velocity IP Forwarding Support

luminol-server/minecraft-patches/features/0005-Add-config-for-server-mod-name.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Add config for server mod name
 
 
 diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index 29101af861b6b8c577d08c940cea17c843d00081..7e4fe0f33f69ae37fd8b1ffbfc8795a2b7ba3cad 100644
+index faf72dd6dff74296c73cb058aaabd1f9f475a072..46375fa81b36b89b79c22f0a7ac6d610ab1183d4 100644
 --- a/net/minecraft/server/MinecraftServer.java
 +++ b/net/minecraft/server/MinecraftServer.java
-@@ -1966,7 +1966,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -1967,7 +1967,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
  
      @DontObfuscate
      public String getServerModName() {

luminol-server/minecraft-patches/features/0006-Add-config-for-unsafe-teleportation.patch

@@ -5,11 +5,11 @@ Subject: [PATCH] Add config for unsafe teleportation
 
 
 diff --git a/net/minecraft/world/entity/item/FallingBlockEntity.java b/net/minecraft/world/entity/item/FallingBlockEntity.java
-index 34e31fa13e5107f13e166f694fafe58e306330ae..c444c4b7dc8454abd257030a8c59b9b22b9013d9 100644
+index 1fa5e6a12b943e889bde566038a632a6adcf319e..c1f6a3b3a8fa990b8e9b052341ab31bde7c04e7a 100644
 --- a/net/minecraft/world/entity/item/FallingBlockEntity.java
 +++ b/net/minecraft/world/entity/item/FallingBlockEntity.java
-@@ -70,7 +70,7 @@ public class FallingBlockEntity extends Entity {
-     public float fallDamagePerDistance = 0.0F;
+@@ -65,7 +65,7 @@ public class FallingBlockEntity extends Entity {
+     public float fallDamagePerDistance;
      @Nullable
      public CompoundTag blockData;
 -    public boolean forceTickAfterTeleportToDuplicate;
@@ -17,7 +17,7 @@ index 34e31fa13e5107f13e166f694fafe58e306330ae..c444c4b7dc8454abd257030a8c59b9b2
      protected static final EntityDataAccessor<BlockPos> DATA_START_POS = SynchedEntityData.defineId(FallingBlockEntity.class, EntityDataSerializers.BLOCK_POS);
      public boolean autoExpire = true; // Paper - Expand FallingBlock API
  
-@@ -387,7 +387,7 @@ public class FallingBlockEntity extends Entity {
+@@ -401,7 +401,7 @@ public class FallingBlockEntity extends Entity {
          ResourceKey<Level> resourceKey1 = this.level().dimension();
          boolean flag = (resourceKey1 == Level.END || resourceKey == Level.END) && resourceKey1 != resourceKey;
          Entity entity = super.teleport(teleportTransition);
@@ -27,10 +27,10 @@ index 34e31fa13e5107f13e166f694fafe58e306330ae..c444c4b7dc8454abd257030a8c59b9b2
      }
  }
 diff --git a/net/minecraft/world/level/block/EndPortalBlock.java b/net/minecraft/world/level/block/EndPortalBlock.java
-index 6e495b2c4176d5a30ea911f8e44a22655df92ef6..cd12e35d784c8ac4737fa617d2e78cef6606299f 100644
+index 554d75ac1374d7d93977a10e06fcf51259830c97..17c1ce4397c5953bb92aaa3b56c179b7c24a0736 100644
 --- a/net/minecraft/world/level/block/EndPortalBlock.java
 +++ b/net/minecraft/world/level/block/EndPortalBlock.java
-@@ -69,6 +69,11 @@ public class EndPortalBlock extends BaseEntityBlock implements Portal {
+@@ -67,6 +67,11 @@ public class EndPortalBlock extends BaseEntityBlock implements Portal {
                  if (level.paperConfig().misc.disableEndCredits) {serverPlayer.seenCredits = true; return;} // Paper - Option to disable end credits
                  serverPlayer.showEndCredits();
              } else {

luminol-server/minecraft-patches/features/0007-Add-config-for-username-check.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Add config for username check
 
 
 diff --git a/net/minecraft/server/network/ServerLoginPacketListenerImpl.java b/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-index 829ff1f36d565f15cfe5d4997d3ccfdfe7898e0f..b7cfe0c73de732e22f90a7b38321c775e405aaa5 100644
+index 159f2f169d26b436a70006f7bc9bdc481315dd32..2b366fea4d8d376b150786fdc00fd5e2413388f6 100644
 --- a/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
 +++ b/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-@@ -175,7 +175,8 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
+@@ -176,7 +176,8 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
      public void handleHello(ServerboundHelloPacket packet) {
          Validate.validState(this.state == ServerLoginPacketListenerImpl.State.HELLO, "Unexpected hello packet");
          // Paper start - Validate usernames
@@ -19,10 +19,10 @@ index 829ff1f36d565f15cfe5d4997d3ccfdfe7898e0f..b7cfe0c73de732e22f90a7b38321c775
              && !this.iKnowThisMayNotBeTheBestIdeaButPleaseDisableUsernameValidation) {
              Validate.validState(StringUtil.isReasonablePlayerName(packet.name()), "Invalid characters in username");
 diff --git a/net/minecraft/server/players/GameProfileCache.java b/net/minecraft/server/players/GameProfileCache.java
-index 066f84df5c31242ab542932f1e243369d0e766e2..144a2644c15f276f02bb3be859dc5d05a677ac55 100644
+index 6fb3712f33a84a3612752dcfd9e97d67066f610e..1999188b5667035362ba579a80b30336c5c7fc38 100644
 --- a/net/minecraft/server/players/GameProfileCache.java
 +++ b/net/minecraft/server/players/GameProfileCache.java
-@@ -75,7 +75,7 @@ public class GameProfileCache {
+@@ -77,7 +77,7 @@ public class GameProfileCache {
      }
  
      private static Optional<GameProfile> lookupGameProfile(GameProfileRepository profileRepo, String name) {
@@ -30,7 +30,7 @@ index 066f84df5c31242ab542932f1e243369d0e766e2..144a2644c15f276f02bb3be859dc5d05
 +        if (!StringUtil.isValidPlayerName(name, false)) { // Luminol - Add config for username check - Directly return, skip unnecessary following logic
              return createUnknownProfile(name);
          } else {
-             final boolean shouldLookup = !org.apache.commons.lang3.StringUtils.isBlank(name)  // Paper - Don't lookup a profile with a blank name
+             final AtomicReference<GameProfile> atomicReference = new AtomicReference<>();
 diff --git a/net/minecraft/util/StringUtil.java b/net/minecraft/util/StringUtil.java
 index 77947e6915facee44588943fcd3e5b513de37e77..d9f95c5cf4bd2946244c153db0fd21c8d51ae20d 100644
 --- a/net/minecraft/util/StringUtil.java

luminol-server/minecraft-patches/features/0008-Add-config-for-vanilla-random.patch

@@ -5,15 +5,15 @@ Subject: [PATCH] Add config for vanilla random
 
 
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index 737ae61a40385d6231576e3cec405b1bdfbd08a9..49c76f150c913fdc21d0e253b78625e273f69a22 100644
+index 2cd2ce1060f567be6c72b7bc9d02651ec7166203..f69fd922fa67cd366dbb93c34fa15659ba76c844 100644
 --- a/net/minecraft/world/entity/Entity.java
 +++ b/net/minecraft/world/entity/Entity.java
-@@ -281,7 +281,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-     public double yOld;
+@@ -255,7 +255,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
      public double zOld;
      public boolean noPhysics;
+     private boolean wasOnFire;
 -    public final RandomSource random = SHARED_RANDOM; // Paper - Share random for entities to make them more random
 +    public final RandomSource random = me.earthme.luminol.config.modules.fixes.VanillaRandomSourceConfig.useLegacyRandomSourceForPlayers ? RandomSource.create() : SHARED_RANDOM; // Paper - Share random for entities to make them more random // Luminol - Add config for vanilla random SHARED_RANDOM
      public int tickCount;
-     private int remainingFireTicks;
+     private int remainingFireTicks = -this.getFireImmuneTicks();
      public boolean wasTouchingWater;

luminol-server/minecraft-patches/features/0009-Add-config-for-watchdog-timeout.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Add config for watchdog timeout
 
 
 diff --git a/io/papermc/paper/threadedregions/FoliaWatchdogThread.java b/io/papermc/paper/threadedregions/FoliaWatchdogThread.java
-index e9ca1a15049b0211d10401cb78e953b93afaf6c7..fe1560579f9c9572082d52cf910f5916957f5601 100644
+index 258d82ab2c78482e1561343e8e1f81fc33f1895e..967107c0f4a18a29877883ccddb4d7962f4b5788 100644
 --- a/io/papermc/paper/threadedregions/FoliaWatchdogThread.java
 +++ b/io/papermc/paper/threadedregions/FoliaWatchdogThread.java
 @@ -65,7 +65,7 @@ public final class FoliaWatchdogThread extends Thread {

luminol-server/minecraft-patches/features/0010-Add-config-to-disable-entity-tick-catchers.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Add config to disable entity tick catchers
 
 
 diff --git a/net/minecraft/world/level/Level.java b/net/minecraft/world/level/Level.java
-index 5fe048ce442957a534d44454e0bb908afe8ad3a6..93d722d437121e605cee0e168ac17ee9bef0610e 100644
+index dafd90502937019b616ac0a79465e1dbc578cf66..96daa716aa06de31b2867f09833ac8e77b6314c4 100644
 --- a/net/minecraft/world/level/Level.java
 +++ b/net/minecraft/world/level/Level.java
-@@ -1533,6 +1533,7 @@ public abstract class Level implements LevelAccessor, UUIDLookup<Entity>, AutoCl
+@@ -1547,6 +1547,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
          try {
              consumerEntity.accept(entity);
          } catch (Throwable var6) {

luminol-server/minecraft-patches/features/0011-Add-config-to-disable-heightmap-warning.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Add config to disable heightmap warning
 
 
 diff --git a/net/minecraft/world/level/levelgen/Heightmap.java b/net/minecraft/world/level/levelgen/Heightmap.java
-index f7b8637680e654dc0b3e8850d65081a1c565bb69..5edbc84650243d1c47d269d4e8176ccdffa6c4e9 100644
+index 3b27bcfbbe0529d1526adc30760c846b4011645f..95747ae41cea0d4b577c58ef44959a18e0a46672 100644
 --- a/net/minecraft/world/level/levelgen/Heightmap.java
 +++ b/net/minecraft/world/level/levelgen/Heightmap.java
-@@ -128,7 +128,8 @@ public class Heightmap {
+@@ -123,7 +123,8 @@ public class Heightmap {
          if (raw.length == data.length) {
              System.arraycopy(data, 0, raw, 0, data.length);
          } else {

luminol-server/minecraft-patches/features/0012-Add-config-to-enable-tick-command.patch

@@ -0,0 +1,167 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Thu, 1 May 2025 22:43:08 +0800
+Subject: [PATCH] Add config to enable tick command
+
+
+diff --git a/io/papermc/paper/threadedregions/RegionizedServer.java b/io/papermc/paper/threadedregions/RegionizedServer.java
+index 1382c695c4991488b113401e231875ddc74f6b01..68280b07a71dcdb42eaee6f62fbda074813a22e4 100644
+--- a/io/papermc/paper/threadedregions/RegionizedServer.java
++++ b/io/papermc/paper/threadedregions/RegionizedServer.java
+@@ -286,6 +286,11 @@ public final class RegionizedServer {
+         this.randomWalk();
+          */
+         ++this.tickCount;
++        // Luminol start - Add a config to enable tick command
++        if (me.earthme.luminol.config.modules.experiment.CommandTickConfig.enabled) {
++            MinecraftServer.tickRateManager.tick();
++        }
++        // Luminol end - Add a config to enable tick command
+         // expire invalid click command callbacks
+         io.papermc.paper.adventure.providers.ClickCallbackProviderImpl.CALLBACK_MANAGER.handleQueue((int)this.tickCount);
+ 
+@@ -308,6 +313,13 @@ public final class RegionizedServer {
+             this.globalTick(world, tickCount);
+         }
+ 
++        // Luminol start - Add a config to enable tick command
++        if (me.earthme.luminol.config.modules.experiment.CommandTickConfig.enabled) {
++            MinecraftServer.tickRateManager.reduceSprintTicks();
++            MinecraftServer.tickRateManager.endTickWork();
++        }
++        // Luminol end - Add a config to enable tick command
++
+         // tick connections
+         this.tickConnections();
+ 
+@@ -441,7 +453,7 @@ public final class RegionizedServer {
+     }
+ 
+     private void tickTime(final ServerLevel world, final int tickCount) {
+-        if (world.tickTime) {
++        if ((!me.earthme.luminol.config.modules.experiment.CommandTickConfig.enabled || world.tickRateManager().runsNormally()) && world.tickTime) { // Luminol - Add a config to enable tick command
+             if (world.getGameRules().getBoolean(GameRules.RULE_DAYLIGHT)) {
+                 world.setDayTime(world.levelData.getDayTime() + (long)tickCount);
+             }
+diff --git a/io/papermc/paper/threadedregions/TickRegionScheduler.java b/io/papermc/paper/threadedregions/TickRegionScheduler.java
+index 7123b3eb2f2e52946b8ef9de993a6828eb0bb6f7..82948984404a183711588932a4a026dc4c241feb 100644
+--- a/io/papermc/paper/threadedregions/TickRegionScheduler.java
++++ b/io/papermc/paper/threadedregions/TickRegionScheduler.java
+@@ -31,8 +31,8 @@ public final class TickRegionScheduler {
+         }
+     }
+ 
+-    public static final int TICK_RATE = 20;
+-    public static final long TIME_BETWEEN_TICKS = 1_000_000_000L / TICK_RATE; // ns
++    public static float TICK_RATE = 20; // Luminol - Add tick command support
++    public static long TIME_BETWEEN_TICKS = (long) (1_000_000_000L / TICK_RATE); // ns // Luminol - Add tick command support
+ 
+     // Folia start - watchdog
+     public static final FoliaWatchdogThread WATCHDOG_THREAD = new FoliaWatchdogThread();
+@@ -375,8 +375,23 @@ public final class TickRegionScheduler {
+             final long cpuStart = MEASURE_CPU_TIME ? THREAD_MX_BEAN.getCurrentThreadCpuTime() : 0L;
+             final long tickStart = System.nanoTime();
+ 
+-            // use max(), don't assume that tickStart >= scheduledStart
+-            final int tickCount = Math.max(1, this.tickSchedule.getPeriodsAhead(TIME_BETWEEN_TICKS, tickStart));
++            // Luminol start - Add a config to enable tick command
++            final int tickCount;
++            if (me.earthme.luminol.config.modules.experiment.CommandTickConfig.enabled) {
++                if (MinecraftServer.tickRateManager.isSprinting() && MinecraftServer.tickRateManager.checkShouldSprintThisTick()) {
++                    TICK_RATE = net.minecraft.server.commands.TickCommand.MAX_TICKRATE;
++                    TIME_BETWEEN_TICKS = (long) (1_000_000_000L / TICK_RATE);
++                    tickCount = 1;
++                } else {
++                    TICK_RATE = MinecraftServer.tickRateManager.tickrate();
++                    TIME_BETWEEN_TICKS = (long) (1_000_000_000L / TICK_RATE);
++                    tickCount = Math.max(1, this.tickSchedule.getPeriodsAhead(TIME_BETWEEN_TICKS, tickStart));
++                }
++            } else {
++                // use max(), don't assume that tickStart >= scheduledStart
++                tickCount = Math.max(1, this.tickSchedule.getPeriodsAhead(TIME_BETWEEN_TICKS, tickStart));
++            }
++            // Luminol end - Add tick command support
+ 
+             if (!this.tryMarkTicking()) {
+                 if (!this.cancelled.get()) {
+@@ -416,6 +431,11 @@ public final class TickRegionScheduler {
+             try {
+                 // next start isn't updated until the end of this tick
+                 this.tickRegion(tickCount, tickStart, scheduledEnd);
++                // Luminol start - Add a config to enable tick command
++                if (me.earthme.luminol.config.modules.experiment.CommandTickConfig.enabled) {
++                    MinecraftServer.tickRateManager.endTickWork();
++                }
++                // Luminol end - Add a config to enable tick command
+             } catch (final Throwable thr) {
+                 this.scheduler.regionFailed(this, false, thr);
+                 // regionFailed will schedule a shutdown, so we should avoid letting this region tick further
+diff --git a/net/minecraft/commands/Commands.java b/net/minecraft/commands/Commands.java
+index 009e6405a11a391adca41a7c4ecafbf3254d799d..779dfa95d91ec4661227c94b012cb63953d4ba96 100644
+--- a/net/minecraft/commands/Commands.java
++++ b/net/minecraft/commands/Commands.java
+@@ -211,7 +211,11 @@ public class Commands {
+         //TeamMsgCommand.register(this.dispatcher); // Folia - region threading - TODO later
+         TeleportCommand.register(this.dispatcher);
+         TellRawCommand.register(this.dispatcher, context);
+-        //TickCommand.register(this.dispatcher); // Folia - region threading - TODO later
++        // Luminol start - Add a config to enable tick command
++        if (me.earthme.luminol.config.modules.experiment.CommandTickConfig.enabled) {
++            TickCommand.register(this.dispatcher); // Folia - region threading - TODO later
++        }
++        // Luminol end - Add a config to enable tick command
+         TimeCommand.register(this.dispatcher);
+         TitleCommand.register(this.dispatcher, context);
+         //TriggerCommand.register(this.dispatcher); // Folia - region threading - TODO later
+diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
+index 46375fa81b36b89b79c22f0a7ac6d610ab1183d4..2f0a1810e3ab4ff4376e893af7ceb2bf5849ba76 100644
+--- a/net/minecraft/server/MinecraftServer.java
++++ b/net/minecraft/server/MinecraftServer.java
+@@ -267,7 +267,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     private String serverId;
+     public MinecraftServer.ReloadableResources resources;
+     private final StructureTemplateManager structureTemplateManager;
+-    private final ServerTickRateManager tickRateManager;
++    public static ServerTickRateManager tickRateManager; // Luminol - Add tick command support
+     protected WorldData worldData;
+     public PotionBrewing potionBrewing;
+     private FuelValues fuelValues;
+diff --git a/net/minecraft/server/ServerTickRateManager.java b/net/minecraft/server/ServerTickRateManager.java
+index 40338efd1c0e56d869d03f1d0687e7ff0fcbf11a..d0d90a25a10bbecfffceee1992af88c60d14fd87 100644
+--- a/net/minecraft/server/ServerTickRateManager.java
++++ b/net/minecraft/server/ServerTickRateManager.java
+@@ -105,7 +105,7 @@ public class ServerTickRateManager extends TickRateManager {
+             return false;
+         } else if (this.remainingSprintTicks > 0L) {
+             this.sprintTickStartTime = System.nanoTime();
+-            this.remainingSprintTicks--;
++            // this.remainingSprintTicks--; // Luminol - Add tick command support
+             return true;
+         } else {
+             this.finishTickSprint();
+@@ -113,6 +113,12 @@ public class ServerTickRateManager extends TickRateManager {
+         }
+     }
+ 
++    // Luminol start - Add tick command support
++    public void reduceSprintTicks() {
++        this.remainingSprintTicks--;
++    }
++    // Luminol end - Add tick command support
++
+     public void endTickWork() {
+         this.sprintTimeSpend = this.sprintTimeSpend + (System.nanoTime() - this.sprintTickStartTime);
+     }
+diff --git a/net/minecraft/server/commands/TickCommand.java b/net/minecraft/server/commands/TickCommand.java
+index 6b6c8ce49eda6806c8288d70848dd143ba2c4703..5d09d2c8bb45cc10b2a13100793249adc7b5a7e9 100644
+--- a/net/minecraft/server/commands/TickCommand.java
++++ b/net/minecraft/server/commands/TickCommand.java
+@@ -14,7 +14,7 @@ import net.minecraft.server.ServerTickRateManager;
+ import net.minecraft.util.TimeUtil;
+ 
+ public class TickCommand {
+-    private static final float MAX_TICKRATE = 10000.0F;
++    public static final float MAX_TICKRATE = 10000.0F; // Luminol - Add tick command support
+     private static final String DEFAULT_TICKRATE = String.valueOf(20);
+ 
+     public static void register(CommandDispatcher<CommandSourceStack> dispatcher) {

luminol-server/minecraft-patches/features/0013-Add-config-to-modify-tripwire-behavior.patch

@@ -5,24 +5,25 @@ Subject: [PATCH] Add config to modify tripwire behavior
 
 
 diff --git a/net/minecraft/world/level/block/TripWireHookBlock.java b/net/minecraft/world/level/block/TripWireHookBlock.java
-index 8a3a8b0fdf9545a41501dc992c6982d9c8ce7b66..8f9f5b0bf098a32a732e3ff9f636e3ea828e5f43 100644
+index 9aace993c6c18f1a50610e4766225485984b8167..419c1c7e14691a472b70ed548ecb928cb289b939 100644
 --- a/net/minecraft/world/level/block/TripWireHookBlock.java
 +++ b/net/minecraft/world/level/block/TripWireHookBlock.java
-@@ -200,10 +200,17 @@ public class TripWireHookBlock extends Block {
+@@ -214,10 +214,18 @@ public class TripWireHookBlock extends Block {
                      BlockPos blockPos1 = pos.relative(direction, i2);
                      BlockState blockState2 = blockStates[i2];
                      if (blockState2 != null) {
 -                        BlockState blockState3 = level.getBlockState(blockPos1);
 -                        if (blockState3.is(Blocks.TRIPWIRE) || blockState3.is(Blocks.TRIPWIRE_HOOK)) {
--                            if (!io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates || !blockState3.is(Blocks.TRIPWIRE))  level.setBlock(blockPos1, blockState2.trySetValue(ATTACHED, flag2), 3); // Paper - prevent tripwire from updating
+-                            if (!io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates || !blockState3.is(Blocks.TRIPWIRE)) level.setBlock(blockPos1, blockState2.trySetValue(ATTACHED, Boolean.valueOf(flag2)), 3); // Paper - prevent tripwire from updating
 +                        // Luminol start - tripwire and tripwireHook dupe
-+                        if (me.earthme.luminol.config.modules.misc.TripwireBehaviorConfig.enabled) {
++                        if (me.earthme.luminol.config.modules.misc.AllowTripwireDupe.enabled) {
 +                            level.setBlock(blockPos1, blockState2.trySetValue(ATTACHED, flag2), 3);
 +                            level.getBlockState(blockPos1);
 +                        } else {
 +                            BlockState blockState3 = level.getBlockState(blockPos1);
 +                            if (blockState3.is(Blocks.TRIPWIRE) || blockState3.is(Blocks.TRIPWIRE_HOOK)) {
-+                                if (!io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates || !blockState3.is(Blocks.TRIPWIRE))  level.setBlock(blockPos1, blockState2.trySetValue(ATTACHED, flag2), 3); // Paper - prevent tripwire from updating
++                                if (!io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates || !blockState3.is(Blocks.TRIPWIRE))
++                                    level.setBlock(blockPos1, blockState2.trySetValue(ATTACHED, Boolean.valueOf(flag2)), 3); // Paper - prevent tripwire from updating
 +                            }
                          }
 +                        // Luminol end - tripwire and tripwireHook dupe
@@ -30,29 +31,29 @@ index 8a3a8b0fdf9545a41501dc992c6982d9c8ce7b66..8f9f5b0bf098a32a732e3ff9f636e3ea
                  }
              }
 diff --git a/net/minecraft/world/level/levelgen/feature/EndPlatformFeature.java b/net/minecraft/world/level/levelgen/feature/EndPlatformFeature.java
-index 49b810ae9d9a8d0718a5f8c512e15a5573ed04fd..7d5fc6860ed426c4906f8c3eb2c10fd6db4296e5 100644
+index f96fc1391167dea48cac1caa464b9026657df89a..ba2da205b046d7d3aab8fb21e116f9be73b13eb3 100644
 --- a/net/minecraft/world/level/levelgen/feature/EndPlatformFeature.java
 +++ b/net/minecraft/world/level/levelgen/feature/EndPlatformFeature.java
-@@ -28,6 +28,11 @@ public class EndPlatformFeature extends Feature<NoneFeatureConfiguration> {
+@@ -27,6 +27,11 @@ public class EndPlatformFeature extends Feature<NoneFeatureConfiguration> {
          // CraftBukkit end
          BlockPos.MutableBlockPos mutableBlockPos = pos.mutable();
  
 +        // Luminol start - tripwire behavior modifier
 +        java.util.List<BlockPos> blockList1 = new java.util.ArrayList<>();
 +        java.util.List<BlockPos> blockList2 = new java.util.ArrayList<>();
-+        boolean flag21 = !java.util.Objects.equals(me.earthme.luminol.config.modules.misc.TripwireBehaviorConfig.behaviorMode, "VANILLA20")
-+                && !java.util.Objects.equals(me.earthme.luminol.config.modules.misc.TripwireBehaviorConfig.behaviorMode, "MIXED");
++        boolean flag21 = !java.util.Objects.equals(me.earthme.luminol.config.modules.misc.AllowTripwireDupe.behaviorMode, "VANILLA20")
++                && !java.util.Objects.equals(me.earthme.luminol.config.modules.misc.AllowTripwireDupe.behaviorMode, "MIXED");
          for (int i = -2; i <= 2; i++) {
              for (int i1 = -2; i1 <= 2; i1++) {
                  for (int i2 = -1; i2 < 3; i2++) {
 @@ -35,7 +40,29 @@ public class EndPlatformFeature extends Feature<NoneFeatureConfiguration> {
-                     Block block = i2 == -1 ? Blocks.OBSIDIAN : Blocks.AIR;
-                     if (!blockList.getBlockState(blockPos).is(block)) { // CraftBukkit
+                     // CraftBukkit start
+                     if (!blockList.getBlockState(blockPos).is(block)) {
                          if (dropBlocks) {
--                            blockList.destroyBlock(blockPos, true, null); // CraftBukkit
+-                            blockList.destroyBlock(blockPos, true, null);
 +                            boolean flag = false;
-+                            if (me.earthme.luminol.config.modules.misc.TripwireBehaviorConfig.enabled) {
-+                                switch (me.earthme.luminol.config.modules.misc.TripwireBehaviorConfig.behaviorMode) {
++                            if (me.earthme.luminol.config.modules.misc.AllowTripwireDupe.enabled) {
++                                switch (me.earthme.luminol.config.modules.misc.AllowTripwireDupe.behaviorMode) {
 +                                    case "VANILLA20": {
 +                                        flag = true;
 +                                    }
@@ -72,31 +73,42 @@ index 49b810ae9d9a8d0718a5f8c512e15a5573ed04fd..7d5fc6860ed426c4906f8c3eb2c10fd6
 +                                }
 +                            }
 +                            if (flag) blockList1.add(blockPos.immutable());
-+                            else blockList.destroyBlock(blockPos, true, null); // CraftBukkit
++                            else blockList.destroyBlock(blockPos, true, null);
                          }
  
-                         blockList.setBlock(blockPos, block.defaultBlockState(), 3); // CraftBukkit
-@@ -53,11 +80,30 @@ public class EndPlatformFeature extends Feature<NoneFeatureConfiguration> {
+                         blockList.setBlock(blockPos, block.defaultBlockState(), 3);
+@@ -54,11 +81,39 @@ public class EndPlatformFeature extends Feature<NoneFeatureConfiguration> {
              if (portalEvent.isCancelled()) return;
          }
  
+-        // SPIGOT-7856: End platform not dropping items after replacing blocks
 -        if (dropBlocks) {
--            blockList.placeBlocks(state -> level.destroyBlock(state.getPosition(), true, null));
-+        if (flag21 || !me.earthme.luminol.config.modules.misc.TripwireBehaviorConfig.enabled) {
+-            blockList.getList().forEach((state) -> level.destroyBlock(state.getPosition(), true, null));
++        if (flag21 && !me.earthme.luminol.config.modules.misc.AllowTripwireDupe.enabled) {
++            // Luminol start - When updated replace it with newer code
 +            if (dropBlocks) {
-+                blockList.placeBlocks(state -> level.destroyBlock(state.getPosition(), true, null));
++                java.util.function.Consumer<? super org.bukkit.craftbukkit.block.CraftBlockState> beforeRun = state -> level.destroyBlock(state.getPosition(), !blockList1.contains(state.getPosition()), null);
++                java.util.function.Predicate<? super org.bukkit.block.BlockState> filter = $ -> true;
++                for (org.bukkit.craftbukkit.block.CraftBlockState state : blockList.getList()) {
++                    if (filter.test(state)) {
++                        beforeRun.accept(state);
++                        if (state.isPlaced()) {
++                            state.getWorldHandle().setBlock(state.getPosition(), state.getHandle(), state.getFlag());
++                        }
++                    }
++                }
 +            } else {
-+                blockList.placeBlocks();
++                blockList.updateList();
 +            }
-         } else {
++            // Luminol end - When updated replace it with newer code
++        } else {
++            // SPIGOT-7856: End platform not dropping items after replacing blocks
 +            if (dropBlocks) {
-+                blockList.getSnapshotBlocks().forEach((state) -> {
-+                                        level.destroyBlock(state.getPosition(), !blockList1.contains(state.getPosition()), null);
-+                });
-+                // Luminol - prevent tripwire dupe in end platform generate
++                blockList.getList().forEach((state) -> level.destroyBlock(state.getPosition(), !blockList1.contains(state.getPosition()), null)); // Luminol - prevent tripwire dupe in end platform generate
 +            }
-             blockList.placeBlocks();
++            blockList.updateList();
          }
+-        blockList.updateList();
          // CraftBukkit end
      }
 +

luminol-server/minecraft-patches/features/0014-Add-config-to-revert-raid-changes.patch

@@ -0,0 +1,197 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Fri, 11 Apr 2025 16:53:57 +0800
+Subject: [PATCH] Add config to revert raid changes
+
+
+diff --git a/net/minecraft/world/effect/BadOmenMobEffect.java b/net/minecraft/world/effect/BadOmenMobEffect.java
+index 80f17f33f670018240c854df589cf90cdeab6e70..8672757a4d5fb5c247599782fece6b8d7d6ec921 100644
+--- a/net/minecraft/world/effect/BadOmenMobEffect.java
++++ b/net/minecraft/world/effect/BadOmenMobEffect.java
+@@ -22,6 +22,11 @@ class BadOmenMobEffect extends MobEffect {
+             && !serverPlayer.isSpectator()
+             && level.getDifficulty() != Difficulty.PEACEFUL
+             && level.isVillage(serverPlayer.blockPosition())) {
++            // Leaves start - Revert raid changes
++            if (me.earthme.luminol.config.modules.misc.RaidChangesConfig.trigger) {
++                return level.getRaids().createOrExtendRaid(serverPlayer, serverPlayer.blockPosition()) == null;
++            }
++            // Leaves end - Revert raid changes
+             Raid raidAt = level.getRaidAt(serverPlayer.blockPosition());
+             if (raidAt == null || raidAt.getRaidOmenLevel() < raidAt.getMaxRaidOmenLevel()) {
+                 serverPlayer.addEffect(new MobEffectInstance(MobEffects.RAID_OMEN, 600, amplifier));
+diff --git a/net/minecraft/world/entity/raid/Raid.java b/net/minecraft/world/entity/raid/Raid.java
+index 2f45befbb50645f1bfb5961ad725f3670ff0d592..0d91ae860a5c506c634e88341d958618996cc5bc 100644
+--- a/net/minecraft/world/entity/raid/Raid.java
++++ b/net/minecraft/world/entity/raid/Raid.java
+@@ -325,7 +325,20 @@ public class Raid {
+                         }
+ 
+                         if (flag1) {
+-                            this.waveSpawnPos = this.getValidSpawnPos();
++                            // Luminol Start - Raid revert
++                            if (!me.earthme.luminol.config.modules.misc.RaidChangesConfig.pos_revert) {
++                                this.waveSpawnPos = this.getValidSpawnPos();
++                            } else {
++                                int n4 = 0;
++                                if (this.raidCooldownTicks < 100) {
++                                    n4 = 1;
++                                }
++                                if (this.raidCooldownTicks < 40) {
++                                    n4 = 2;
++                                }
++                                this.waveSpawnPos = this.getValidSpawnPos(n4);
++                            }
++                            // Luminol End - Raid revert
+                         }
+ 
+                         if (this.raidCooldownTicks == 300 || this.raidCooldownTicks % 20 == 0) {
+@@ -360,7 +373,14 @@ public class Raid {
+                 int i = 0;
+ 
+                 while (this.shouldSpawnGroup()) {
+-                    BlockPos blockPos = this.waveSpawnPos.orElseGet(() -> this.findRandomSpawnPos(20));
++                    // Luminol Start - Raid revert
++                    BlockPos blockPos;
++                    if (!me.earthme.luminol.config.modules.misc.RaidChangesConfig.pos_revert) {
++                        blockPos = this.waveSpawnPos.orElseGet(() -> this.findRandomSpawnPos(20));
++                    } else {
++                        blockPos = this.waveSpawnPos.isPresent() ? this.waveSpawnPos.get() : this.findRandomSpawnPos(i, 20);
++                    }
++                    // Luminol End - Raid revert
+                     if (blockPos != null) {
+                         this.started = true;
+                         this.spawnGroup(blockPos);
+@@ -372,7 +392,7 @@ public class Raid {
+                         i++;
+                     }
+ 
+-                    if (i > 5) {
++                    if (i > (me.earthme.luminol.config.modules.misc.RaidChangesConfig.pos_revert ? 3 : 5)) { // Luminol - Raid revert
+                         org.bukkit.craftbukkit.event.CraftEventFactory.callRaidStopEvent(this, org.bukkit.event.raid.RaidStopEvent.Reason.UNSPAWNABLE); // CraftBukkit
+                         this.stop();
+                         break;
+@@ -449,6 +469,17 @@ public class Raid {
+         return blockPos != null ? Optional.of(blockPos) : Optional.empty();
+     }
+ 
++    // Luminol Start - Raid revert
++    private Optional<BlockPos> getValidSpawnPos(int n) {
++        for (int i = 0; i < 3; ++i) {
++            BlockPos blockPos = this.findRandomSpawnPos(n, 1);
++            if (blockPos == null) continue;
++            return Optional.of(blockPos);
++        }
++        return Optional.empty();
++    }
++    // Luminol End - Raid revert
++
+     private boolean hasMoreWaves() {
+         return this.hasBonusWave() ? !this.hasSpawnedBonusWave() : !this.isFinalWave();
+     }
+@@ -674,7 +705,7 @@ public class Raid {
+             int i2 = this.center.getX() + Mth.floor(Mth.cos(f2) * 32.0F * f) + this.level.random.nextInt(3) * Mth.floor(f);
+             int i3 = this.center.getZ() + Mth.floor(Mth.sin(f2) * 32.0F * f) + this.level.random.nextInt(3) * Mth.floor(f);
+             int height = this.level.getHeight(Heightmap.Types.WORLD_SURFACE, i2, i3);
+-            if (Mth.abs(height - this.center.getY()) <= 96) {
++            if (me.earthme.luminol.config.modules.misc.RaidChangesConfig.height_check || Mth.abs(height - this.center.getY()) <= 96) { // Leaves - Disable height check
+                 mutableBlockPos.set(i2, height, i3);
+                 if (!this.level.isVillage(mutableBlockPos) || i <= 7) {
+                     int i4 = 10;
+@@ -694,6 +725,26 @@ public class Raid {
+         return null;
+     }
+ 
++    // Luminol Start - Raid revert
++    @Nullable
++    private BlockPos findRandomSpawnPos(int n, int n2) {
++        int n3 = 2 - n;
++        BlockPos.MutableBlockPos mutableBlockPos = new BlockPos.MutableBlockPos();
++        SpawnPlacementType spawnPlacementType = SpawnPlacements.getPlacementType(EntityType.RAVAGER);
++        for (int i = 0; i < n2; ++i) {
++            float f = this.level.random.nextFloat() * ((float)Math.PI * 2);
++            int n4 = this.center.getX() + Mth.floor(Mth.cos(f) * 32.0f * (float)n3) + this.level.random.nextInt(5);
++            int n5 = this.center.getZ() + Mth.floor(Mth.sin(f) * 32.0f * (float)n3) + this.level.random.nextInt(5);
++            int n6 = this.level.getHeight(Heightmap.Types.WORLD_SURFACE, n4, n5);
++            mutableBlockPos.set(n4, n6, n5);
++            if (this.level.isVillage(mutableBlockPos) && n < 2) continue;
++            if (!this.level.hasChunksAt(mutableBlockPos.getX() - 10, mutableBlockPos.getZ() - 10, mutableBlockPos.getX() + 10, mutableBlockPos.getZ() + 10) || !this.level.isPositionEntityTicking(mutableBlockPos) || !spawnPlacementType.isSpawnPositionOk(this.level, mutableBlockPos, EntityType.RAVAGER) && (!this.level.getBlockState((BlockPos)mutableBlockPos.below()).is(Blocks.SNOW) || !this.level.getBlockState(mutableBlockPos).isAir())) continue;
++            return mutableBlockPos;
++        }
++        return null;
++    }
++    // Luminol End - Raid revert
++
+     private boolean addWaveMob(int wave, Raider raider) {
+         return this.addWaveMob(wave, raider, true);
+     }
+diff --git a/net/minecraft/world/entity/raid/Raider.java b/net/minecraft/world/entity/raid/Raider.java
+index 7c385baae81b9a987c0e1e4deb017884600331bc..75a8e0602c249df4b587a454e35f4cd7eab2a25c 100644
+--- a/net/minecraft/world/entity/raid/Raider.java
++++ b/net/minecraft/world/entity/raid/Raider.java
+@@ -125,6 +125,43 @@ public abstract class Raider extends PatrollingMonster {
+ 
+                 currentRaid.removeFromRaid(this, false);
+             }
++
++            // Leaves start - Revert raid changes
++            if (this.level() instanceof ServerLevel serverLevel) {
++                if (me.earthme.luminol.config.modules.misc.RaidChangesConfig.effect && !this.hasRaid()) {
++                    ItemStack itemstack = this.getItemBySlot(EquipmentSlot.HEAD);
++                    net.minecraft.world.entity.player.Player entityhuman = null;
++                    if (entity instanceof net.minecraft.world.entity.player.Player player) {
++                        entityhuman = player;
++                    } else if (entity instanceof net.minecraft.world.entity.animal.Wolf wolf) {
++                        LivingEntity entityliving = wolf.getOwner();
++                        if (wolf.isTame() && entityliving instanceof net.minecraft.world.entity.player.Player player) {
++                            entityhuman = player;
++                        }
++                    }
++
++                    if (entityhuman != null && !itemstack.isEmpty() && this.isCaptain()) {
++                        net.minecraft.world.effect.MobEffectInstance mobeffect = entityhuman.getEffect(net.minecraft.world.effect.MobEffects.BAD_OMEN);
++                        int i = 1;
++
++                        if (mobeffect != null) {
++                            i += mobeffect.getAmplifier();
++                            entityhuman.removeEffectNoUpdate(net.minecraft.world.effect.MobEffects.BAD_OMEN);
++                            } else {
++                            --i;
++                        }
++
++                        i = net.minecraft.util.Mth.clamp(i, 0, 4);
++                        net.minecraft.world.effect.MobEffectInstance mobeffect1 = new net.minecraft.world.effect.MobEffectInstance(net.minecraft.world.effect.MobEffects.BAD_OMEN, me.earthme.luminol.config.modules.misc.RaidChangesConfig.infinite ? net.minecraft.world.effect.MobEffectInstance.INFINITE_DURATION : 120000, i, false, false, true);
++
++                        if (!serverLevel.getGameRules().getBoolean(net.minecraft.world.level.GameRules.RULE_DISABLE_RAIDS)) {
++                            entityhuman.addEffect(mobeffect1, entityhuman, org.bukkit.event.entity.EntityPotionEffectEvent.Cause.PATROL_CAPTAIN, true, true); // CraftBukkit // Luminol - Raid revert adapt Cross Region Damage trace
++                        }
++                        this.setPatrolLeader(false);
++                    }
++                }
++            }
++            // Leaves end - Revert raid changes
+         }
+ 
+         super.die(cause);
+@@ -153,7 +190,7 @@ public abstract class Raider extends PatrollingMonster {
+     }
+ 
+     public boolean hasRaid() {
+-        return this.level() instanceof ServerLevel serverLevel && (this.getCurrentRaid() != null || serverLevel.getRaidAt(this.blockPosition()) != null);
++        return !me.earthme.luminol.config.modules.misc.RaidChangesConfig.self_check && (this.level() instanceof ServerLevel serverLevel && (this.getCurrentRaid() != null || serverLevel.getRaidAt(this.blockPosition()) != null)); // Leaves - Disable raid self check
+     }
+ 
+     public boolean hasActiveRaid() {
+diff --git a/net/minecraft/world/item/component/OminousBottleAmplifier.java b/net/minecraft/world/item/component/OminousBottleAmplifier.java
+index 318f24d67be4daf6993ba547da0540be9c221a75..5607d2f21131510563f8fdc9079d1145483b11df 100644
+--- a/net/minecraft/world/item/component/OminousBottleAmplifier.java
++++ b/net/minecraft/world/item/component/OminousBottleAmplifier.java
+@@ -40,7 +40,7 @@ public record OminousBottleAmplifier(int value) implements ConsumableListener, T
+ 
+     @Override
+     public void addToTooltip(Item.TooltipContext context, Consumer<Component> tooltipAdder, TooltipFlag tooltipFlag) {
+-        List<MobEffectInstance> list = List.of(new MobEffectInstance(MobEffects.BAD_OMEN, 120000, this.value, false, false, true));
++        List<MobEffectInstance> list = List.of(new MobEffectInstance(MobEffects.BAD_OMEN, me.earthme.luminol.config.modules.misc.RaidChangesConfig.infinite ? net.minecraft.world.effect.MobEffectInstance.INFINITE_DURATION : 120000, this.value, false, false, true)); // Luminol - Raid effect infinite
+         PotionContents.addPotionTooltip(list, tooltipAdder, 1.0F, context.tickRate());
+     }
+ }

luminol-server/minecraft-patches/features/0015-Add-config-to-verify-signature-only-in-online-mode.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Add config to verify signature only in online-mode
 
 
 diff --git a/net/minecraft/world/entity/player/ProfilePublicKey.java b/net/minecraft/world/entity/player/ProfilePublicKey.java
-index 15293ed76018f4790754721bd687cbbf906c71dc..c2eaf52590f417b9562edcc70cca68ad9904fe90 100644
+index 41a9cc693183e96c83837692e93b177a521d6789..f4a2d1a2d467808b9cb75fc32765ddc27be5fdba 100644
 --- a/net/minecraft/world/entity/player/ProfilePublicKey.java
 +++ b/net/minecraft/world/entity/player/ProfilePublicKey.java
 @@ -23,7 +23,7 @@ public record ProfilePublicKey(ProfilePublicKey.Data data) {

luminol-server/minecraft-patches/features/0015-Add-fix-for-off-region-adult-following-ai-behavior.patch

@@ -1,36 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MrHua269 <wangxyper@163.com>
-Date: Sun, 12 Jan 2025 10:39:35 +0800
-Subject: [PATCH] Add fix for off region adult following ai behavior
-
-
-diff --git a/net/minecraft/world/entity/ai/behavior/BabyFollowAdult.java b/net/minecraft/world/entity/ai/behavior/BabyFollowAdult.java
-index d69cb6f45cba4234605c7a0f7ddf8f331eee0c62..2ac16196b96041abc82bd3230d8305fe3333831f 100644
---- a/net/minecraft/world/entity/ai/behavior/BabyFollowAdult.java
-+++ b/net/minecraft/world/entity/ai/behavior/BabyFollowAdult.java
-@@ -29,6 +29,12 @@ public class BabyFollowAdult {
-                             return false;
-                         } else {
-                             LivingEntity livingEntity = instance.get(memoryAccessor);
-+                            // Luminol start - Fix off world entity following which caused async issue
-+                            if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(livingEntity)) {
-+                                memoryAccessor.erase();
-+                                return true;
-+                            }
-+                            // Luminol end
-                             if (entity.closerThan(livingEntity, followRange.getMaxValue() + 1) && !entity.closerThan(livingEntity, followRange.getMinValue())) {
-                                 // CraftBukkit start
-                                 org.bukkit.event.entity.EntityTargetLivingEntityEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityTargetLivingEvent(entity, livingEntity, org.bukkit.event.entity.EntityTargetEvent.TargetReason.FOLLOW_LEADER);
-@@ -39,6 +45,12 @@ public class BabyFollowAdult {
-                                     memoryAccessor.erase();
-                                     return true;
-                                 }
-+                                // Luminol start - Fix off region baby follow adult ai
-+                                if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(((org.bukkit.craftbukkit.entity.CraftEntity)event.getTarget()).getHandleRaw())) {
-+                                    memoryAccessor.erase();
-+                                    return true;
-+                                }
-+                                // Luminol end
-                                 livingEntity = ((org.bukkit.craftbukkit.entity.CraftLivingEntity) event.getTarget()).getHandle();
-                                 // CraftBukkit end
-                                 WalkTarget walkTarget = new WalkTarget(

luminol-server/minecraft-patches/features/0016-Add-configurable-region-format-framework-linear-v2-r.patch

@@ -22,7 +22,7 @@ index a814512fcfb85312474ae2c2c21443843bf57831..2e084a5b28cbe4737f48c25e10af5892
      public MoonriseRegionFileIO.RegionDataController.WriteData moonrise$startWrite(
              final int chunkX, final int chunkZ, final CompoundTag compound
 diff --git a/ca/spottedleaf/moonrise/patches/chunk_system/io/MoonriseRegionFileIO.java b/ca/spottedleaf/moonrise/patches/chunk_system/io/MoonriseRegionFileIO.java
-index f5ed467c0880e4bcdf1b9ae773a5aac21c4381c3..f517079dad3b7e29af33feb78fe344d006570aab 100644
+index 98fbc5c8044bd945d64569f13412a6e7e49a4e7f..9709d60d3b2a5478cd6c711669e32f28ac105667 100644
 --- a/ca/spottedleaf/moonrise/patches/chunk_system/io/MoonriseRegionFileIO.java
 +++ b/ca/spottedleaf/moonrise/patches/chunk_system/io/MoonriseRegionFileIO.java
 @@ -1260,7 +1260,7 @@ public final class MoonriseRegionFileIO {
@@ -55,10 +55,10 @@ index 51c126735ace8fdde89ad97b5cab62f244212db0..c7d4d944eb198ac53a3eeae717a25c7d
 +    public void moonrise$write(final abomination.IRegionFile regionFile) throws IOException; // Luminol - Configurable region file format
  }
 diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index 7e4fe0f33f69ae37fd8b1ffbfc8795a2b7ba3cad..8502fdb94142cf12b8d9d4900d8a2440051051ae 100644
+index 2f0a1810e3ab4ff4376e893af7ceb2bf5849ba76..27782d1096dc4c9c82c02c29e9b17e2bf8d3f4d3 100644
 --- a/net/minecraft/server/MinecraftServer.java
 +++ b/net/minecraft/server/MinecraftServer.java
-@@ -981,10 +981,10 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -986,10 +986,10 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
          // CraftBukkit end
          if (flush) {
              for (ServerLevel serverLevel2 : this.getAllLevels()) {
@@ -72,10 +72,10 @@ index 7e4fe0f33f69ae37fd8b1ffbfc8795a2b7ba3cad..8502fdb94142cf12b8d9d4900d8a2440
  
          return flag;
 diff --git a/net/minecraft/util/worldupdate/WorldUpgrader.java b/net/minecraft/util/worldupdate/WorldUpgrader.java
-index 79d57ca8a7870a02e95562d89cbd4341d8282660..9ac0e2f5ee4e8ac2e70c5445a7c9f47f0e414929 100644
+index e0bcda2ddea0d6633445a7440fbf0d18e50a7653..57ed3f61b265fc5c231ef0f2b7c4d33b4f3f6cba 100644
 --- a/net/minecraft/util/worldupdate/WorldUpgrader.java
 +++ b/net/minecraft/util/worldupdate/WorldUpgrader.java
-@@ -75,7 +75,7 @@ public class WorldUpgrader implements AutoCloseable {
+@@ -72,7 +72,7 @@ public class WorldUpgrader implements AutoCloseable {
      volatile int skipped;
      final Reference2FloatMap<ResourceKey<Level>> progressMap = Reference2FloatMaps.synchronize(new Reference2FloatOpenHashMap<>());
      volatile Component status = Component.translatable("optimizeWorld.stage.counting");
@@ -84,7 +84,7 @@ index 79d57ca8a7870a02e95562d89cbd4341d8282660..9ac0e2f5ee4e8ac2e70c5445a7c9f47f
      final DimensionDataStorage overworldDataStorage;
  
      public WorldUpgrader(
-@@ -272,7 +272,7 @@ public class WorldUpgrader implements AutoCloseable {
+@@ -261,7 +261,7 @@ public class WorldUpgrader implements AutoCloseable {
          }
  
          private static List<WorldUpgrader.FileToUpgrade> getAllChunkPositions(RegionStorageInfo regionStorageInfo, Path path) {
@@ -93,7 +93,7 @@ index 79d57ca8a7870a02e95562d89cbd4341d8282660..9ac0e2f5ee4e8ac2e70c5445a7c9f47f
              if (files == null) {
                  return List.of();
              } else {
-@@ -285,7 +285,7 @@ public class WorldUpgrader implements AutoCloseable {
+@@ -274,7 +274,7 @@ public class WorldUpgrader implements AutoCloseable {
                          int i1 = Integer.parseInt(matcher.group(2)) << 5;
                          List<ChunkPos> list1 = Lists.newArrayList();
  
@@ -102,7 +102,7 @@ index 79d57ca8a7870a02e95562d89cbd4341d8282660..9ac0e2f5ee4e8ac2e70c5445a7c9f47f
                              for (int i2 = 0; i2 < 32; i2++) {
                                  for (int i3 = 0; i3 < 32; i3++) {
                                      ChunkPos chunkPos = new ChunkPos(i2 + i, i3 + i1);
-@@ -333,7 +333,7 @@ public class WorldUpgrader implements AutoCloseable {
+@@ -322,7 +322,7 @@ public class WorldUpgrader implements AutoCloseable {
  
          protected abstract boolean tryProcessOnePosition(T chunkStorage, ChunkPos chunkPos, ResourceKey<Level> dimension);
  
@@ -111,7 +111,7 @@ index 79d57ca8a7870a02e95562d89cbd4341d8282660..9ac0e2f5ee4e8ac2e70c5445a7c9f47f
              if (WorldUpgrader.this.recreateRegionFiles) {
                  if (this.previousWriteFuture != null) {
                      this.previousWriteFuture.join();
-@@ -438,7 +438,7 @@ public class WorldUpgrader implements AutoCloseable {
+@@ -424,7 +424,7 @@ public class WorldUpgrader implements AutoCloseable {
          }
      }
  
@@ -121,7 +121,7 @@ index 79d57ca8a7870a02e95562d89cbd4341d8282660..9ac0e2f5ee4e8ac2e70c5445a7c9f47f
  
      class PoiUpgrader extends WorldUpgrader.SimpleRegionStorageUpgrader {
 diff --git a/net/minecraft/world/level/chunk/storage/RegionFile.java b/net/minecraft/world/level/chunk/storage/RegionFile.java
-index 22f3aa1674664906e8ec45372d758d79017e3987..76f1b5bb94b82044d72658d4b187dd020d4c9012 100644
+index 0c41177462cca5c4bbab6490e323b9535fd6300f..39b3c3ca7248fe60833f04aee89c8851b21d5008 100644
 --- a/net/minecraft/world/level/chunk/storage/RegionFile.java
 +++ b/net/minecraft/world/level/chunk/storage/RegionFile.java
 @@ -22,7 +22,7 @@ import net.minecraft.util.profiling.jfr.JvmProfiler;
@@ -133,16 +133,16 @@ index 22f3aa1674664906e8ec45372d758d79017e3987..76f1b5bb94b82044d72658d4b187dd02
      private static final Logger LOGGER = LogUtils.getLogger();
      public static final int MAX_CHUNK_SIZE = 500 * 1024 * 1024; // Paper - don't write garbage data to disk if writing serialization fails
      private static final int SECTOR_BYTES = 4096;
-@@ -130,7 +130,7 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
-         return this.recalculateCount.get();
+@@ -124,7 +124,7 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
      }
  
+     // note: only call for CHUNK regionfiles
 -    boolean recalculateHeader() throws IOException {
 +    public boolean recalculateHeader() throws IOException { // Luminol - Configurable region file format // Luminol - Configurable region file format
          if (!this.canRecalcHeader) {
              return false;
          }
-@@ -794,7 +794,7 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
+@@ -786,7 +786,7 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
          }
      }
  
@@ -151,7 +151,7 @@ index 22f3aa1674664906e8ec45372d758d79017e3987..76f1b5bb94b82044d72658d4b187dd02
          int offsetIndex = getOffsetIndex(chunkPos);
          int i = this.offsets.get(offsetIndex);
          int sectorNumber = getSectorNumber(i);
-@@ -912,7 +912,7 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
+@@ -904,7 +904,7 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
          }
  
          @Override
@@ -160,7 +160,7 @@ index 22f3aa1674664906e8ec45372d758d79017e3987..76f1b5bb94b82044d72658d4b187dd02
              regionFile.write(this.pos, ByteBuffer.wrap(this.buf, 0, this.count));
          }
          // Paper end - rewrite chunk system
-@@ -978,11 +978,11 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
+@@ -970,11 +970,11 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
          return (x & 31) + (z & 31) * 32;
      }
  
@@ -174,7 +174,7 @@ index 22f3aa1674664906e8ec45372d758d79017e3987..76f1b5bb94b82044d72658d4b187dd02
          final int offset = getChunkIndex(x, z);
          boolean previous = this.oversized[offset] == 1;
          this.oversized[offset] = (byte) (oversized ? 1 : 0);
-@@ -1021,7 +1021,7 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
+@@ -1013,7 +1013,7 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
          return this.path.getParent().resolve(this.path.getFileName().toString().replaceAll("\\.mca$", "") + "_oversized_" + x + "_" + z + ".nbt");
      }
  
@@ -184,7 +184,7 @@ index 22f3aa1674664906e8ec45372d758d79017e3987..76f1b5bb94b82044d72658d4b187dd02
          try (DataInputStream out = new DataInputStream(new java.io.BufferedInputStream(new java.util.zip.InflaterInputStream(Files.newInputStream(file))))) {
              return net.minecraft.nbt.NbtIo.read((java.io.DataInput) out);
 diff --git a/net/minecraft/world/level/chunk/storage/RegionFileStorage.java b/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
-index 384f2cd090d6d23bd1308d6e82c24338f2bf55d1..a81245aff4cc982b9eaca976ebbb54a8188b247b 100644
+index dad7f94b611cf0fc68b1a3878c458233f6bb6d61..437fff55b565e469f6a4e41288b6f805e125be60 100644
 --- a/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
 +++ b/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
 @@ -18,7 +18,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
@@ -289,16 +289,7 @@ index 384f2cd090d6d23bd1308d6e82c24338f2bf55d1..a81245aff4cc982b9eaca976ebbb54a8
  
          final DataInputStream input = regionFile == null ? null : regionFile.getChunkDataInputStream(new ChunkPos(chunkX, chunkZ));
  
-@@ -238,7 +257,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
- 
-             final ChunkPos pos = new ChunkPos(chunkX, chunkZ);
-             final ChunkPos headerChunkPos = SerializableChunkData.getChunkCoordinate(ret);
--            final RegionFile regionFile = this.getRegionFile(pos);
-+            final abomination.IRegionFile regionFile = this.getRegionFile(pos);  // Luminol - Configurable region file format
- 
-             if (regionFile.getRecalculateCount() != readData.recalculateCount()) {
-                 return null;
-@@ -262,7 +281,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+@@ -237,7 +256,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
      }
      // Paper end - rewrite chunk system
      // Paper start - rewrite chunk system
@@ -307,7 +298,7 @@ index 384f2cd090d6d23bd1308d6e82c24338f2bf55d1..a81245aff4cc982b9eaca976ebbb54a8
          return this.getRegionFile(chunkcoordintpair, false);
      }
      // Paper end - rewrite chunk system
-@@ -274,7 +293,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+@@ -249,7 +268,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
          this.isChunkData = isChunkDataFolder(this.folder); // Paper - recalculate region file headers
      }
  
@@ -316,7 +307,7 @@ index 384f2cd090d6d23bd1308d6e82c24338f2bf55d1..a81245aff4cc982b9eaca976ebbb54a8
          // Paper start - rewrite chunk system
          if (existingOnly) {
              return this.moonrise$getRegionFileIfExists(chunkPos.x, chunkPos.z);
-@@ -282,7 +301,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+@@ -257,7 +276,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
          synchronized (this) {
              final long key = ChunkPos.asLong(chunkPos.x >> REGION_SHIFT, chunkPos.z >> REGION_SHIFT);
  
@@ -325,7 +316,7 @@ index 384f2cd090d6d23bd1308d6e82c24338f2bf55d1..a81245aff4cc982b9eaca976ebbb54a8
              if (ret != null) {
                  return ret;
              }
-@@ -297,7 +316,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+@@ -272,7 +291,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
  
              FileUtil.createDirectoriesSafe(this.folder);
  
@@ -334,7 +325,7 @@ index 384f2cd090d6d23bd1308d6e82c24338f2bf55d1..a81245aff4cc982b9eaca976ebbb54a8
  
              this.regionCache.putAndMoveToFirst(key, ret);
  
-@@ -311,7 +330,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+@@ -286,7 +305,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
          org.apache.logging.log4j.LogManager.getLogger().fatal(msg + " (" + file.toString().replaceAll(".+[\\\\/]", "") + " - " + x + "," + z + ") Go clean it up to remove this message. /minecraft:tp " + (x<<4)+" 128 "+(z<<4) + " - DO NOT REPORT THIS TO PAPER - You may ask for help on Discord, but do not file an issue. These error messages can not be removed.");
      }
  
@@ -343,7 +334,7 @@ index 384f2cd090d6d23bd1308d6e82c24338f2bf55d1..a81245aff4cc982b9eaca976ebbb54a8
          synchronized (regionfile) {
              try (DataInputStream datainputstream = regionfile.getChunkDataInputStream(chunkCoordinate)) {
                  CompoundTag oversizedData = regionfile.getOversizedData(chunkCoordinate.x, chunkCoordinate.z);
-@@ -346,7 +365,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+@@ -321,7 +340,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
      @Nullable
      public CompoundTag read(ChunkPos chunkPos) throws IOException {
          // CraftBukkit start - SPIGOT-5680: There's no good reason to preemptively create files on read, save that for writing
@@ -352,7 +343,7 @@ index 384f2cd090d6d23bd1308d6e82c24338f2bf55d1..a81245aff4cc982b9eaca976ebbb54a8
          if (regionFile == null) {
              return null;
          }
-@@ -385,7 +404,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+@@ -360,7 +379,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
  
      public void scanChunk(ChunkPos chunkPos, StreamTagVisitor visitor) throws IOException {
          // CraftBukkit start - SPIGOT-5680: There's no good reason to preemptively create files on read, save that for writing
@@ -361,7 +352,7 @@ index 384f2cd090d6d23bd1308d6e82c24338f2bf55d1..a81245aff4cc982b9eaca976ebbb54a8
          if (regionFile == null) {
              return;
          }
-@@ -399,7 +418,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+@@ -374,7 +393,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
      }
  
      public void write(ChunkPos chunkPos, @Nullable CompoundTag chunkData) throws IOException { // Paper - rewrite chunk system - public
@@ -370,7 +361,7 @@ index 384f2cd090d6d23bd1308d6e82c24338f2bf55d1..a81245aff4cc982b9eaca976ebbb54a8
          // Paper start - rewrite chunk system
          if (regionFile == null) {
              // if the RegionFile doesn't exist, no point in deleting from it
-@@ -429,7 +448,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+@@ -404,7 +423,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
          // Paper start - rewrite chunk system
          synchronized (this) {
              final ExceptionCollector<IOException> exceptionCollector = new ExceptionCollector<>();
@@ -379,7 +370,7 @@ index 384f2cd090d6d23bd1308d6e82c24338f2bf55d1..a81245aff4cc982b9eaca976ebbb54a8
                  try {
                      regionFile.close();
                  } catch (final IOException ex) {
-@@ -445,7 +464,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+@@ -420,7 +439,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
          // Paper start - rewrite chunk system
          synchronized (this) {
              final ExceptionCollector<IOException> exceptionCollector = new ExceptionCollector<>();

luminol-server/minecraft-patches/features/0017-Add-fix-for-off-region-adult-following-ai-behavior.patch

@@ -0,0 +1,25 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:39:35 +0800
+Subject: [PATCH] Add fix for off region adult following ai behavior
+
+
+diff --git a/net/minecraft/world/entity/ai/behavior/BabyFollowAdult.java b/net/minecraft/world/entity/ai/behavior/BabyFollowAdult.java
+index a9be3acbf4ea52d2988347abfa6f4f8c02b1da26..751f3dde8e6bc2c0365e8672f5079af0379a69de 100644
+--- a/net/minecraft/world/entity/ai/behavior/BabyFollowAdult.java
++++ b/net/minecraft/world/entity/ai/behavior/BabyFollowAdult.java
+@@ -25,6 +25,14 @@ public class BabyFollowAdult {
+                         return false;
+                     } else {
+                         LivingEntity ageableMob = instance.get(nearestVisibleAdult); // CraftBukkit - type
++
++                        // Luminol start - Fix off world entity following which caused async issue
++                        if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(ageableMob)) {
++                            nearestVisibleAdult.erase();
++                            return true;
++                        }
++                        // Luminol end
++
+                         if (mob.closerThan(ageableMob, followRange.getMaxValue() + 1) && !mob.closerThan(ageableMob, followRange.getMinValue())) {
+                             // CraftBukkit start
+                             org.bukkit.event.entity.EntityTargetLivingEntityEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityTargetLivingEvent(mob, ageableMob, org.bukkit.event.entity.EntityTargetEvent.TargetReason.FOLLOW_LEADER);

luminol-server/minecraft-patches/features/0018-Add-force-the-data-command-to-be-enabled-config.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Add force the data command to be enabled config
 
 
 diff --git a/net/minecraft/commands/Commands.java b/net/minecraft/commands/Commands.java
-index 68f2f2d8067d11fa4459c9fa21bc3fd4134b9157..14719cca5ff91c8647b3b616b2dfd4d153946d92 100644
+index 779dfa95d91ec4661227c94b012cb63953d4ba96..8f7b28e5688252207ad8ce9f3fb6f9c3b65d1adc 100644
 --- a/net/minecraft/commands/Commands.java
 +++ b/net/minecraft/commands/Commands.java
-@@ -189,7 +189,9 @@ public class Commands {
+@@ -162,7 +162,9 @@ public class Commands {
          ClearInventoryCommands.register(this.dispatcher, context);
          //CloneCommands.register(this.dispatcher, context); // Folia - region threading - TODO
          DamageCommand.register(this.dispatcher, context);
@@ -16,6 +16,6 @@ index 68f2f2d8067d11fa4459c9fa21bc3fd4134b9157..14719cca5ff91c8647b3b616b2dfd4d1
 +        if(me.earthme.luminol.config.modules.experiment.CommandDataConfig.enabled) {
 +            DataCommands.register(this.dispatcher); // Folia - region threading - TODO
 +        }
-         //DataPackCommand.register(this.dispatcher, context); // Folia - region threading - TODO
+         //DataPackCommand.register(this.dispatcher); // Folia - region threading - TODO
          //DebugCommand.register(this.dispatcher); // Folia - region threading - TODO
          DefaultGameModeCommands.register(this.dispatcher);

luminol-server/minecraft-patches/features/0020-Add-tpsbar-with-chunkhot-membar-and-regionbar.patch

@@ -5,33 +5,31 @@ Subject: [PATCH] Add tpsbar with chunkhot membar and regionbar
 
 
 diff --git a/ca/spottedleaf/moonrise/paper/util/BaseChunkSystemHooks.java b/ca/spottedleaf/moonrise/paper/util/BaseChunkSystemHooks.java
-index bd3ce123652af11974be4cbf8d2e96f1b2ee0a68..5f26fd89704aa3fd9c37a1d68a7c4c65ce1e7a5d 100644
+index 8d67b4629c69d3039b199aaad45533d1acde114e..f7bfeca4b11b9860241d5eb80b6df420868c7bea 100644
 --- a/ca/spottedleaf/moonrise/paper/util/BaseChunkSystemHooks.java
 +++ b/ca/spottedleaf/moonrise/paper/util/BaseChunkSystemHooks.java
-@@ -131,6 +131,7 @@ public abstract class BaseChunkSystemHooks implements ca.spottedleaf.moonrise.co
+@@ -136,6 +136,7 @@ public abstract class BaseChunkSystemHooks implements ca.spottedleaf.moonrise.co
  
      @Override
      public void onChunkNotTicking(final LevelChunk chunk, final ChunkHolder holder) {
 +        chunk.getChunkHot().clear(); // KioCG
-         chunk.getLevel().getCurrentWorldData().removeTickingChunk(chunk); // Folia - region threading
+         chunk.getLevel().getCurrentWorldData().removeTickingChunk(chunk.moonrise$getChunkAndHolder()); // Folia - region threading
+         ((ca.spottedleaf.moonrise.patches.chunk_tick_iteration.ChunkTickServerLevel)(ServerLevel)chunk.getLevel()).moonrise$removeChunkForPlayerTicking(chunk); // Moonrise - chunk tick iteration
      }
- 
 diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index 8502fdb94142cf12b8d9d4900d8a2440051051ae..d824b49b98266539258a83f9a36f73c5961a1588 100644
+index 27782d1096dc4c9c82c02c29e9b17e2bf8d3f4d3..56f5568848d0f20b4d706c07dc8114594e0b5337 100644
 --- a/net/minecraft/server/MinecraftServer.java
 +++ b/net/minecraft/server/MinecraftServer.java
-@@ -1664,7 +1664,46 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -1665,7 +1665,44 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
          // Folia end - region threading
          //this.tickCount++; // Folia - region threading
          //this.tickRateManager.tick(); // Folia - region threading
 +        // KioCG start - ChunkHot
 +        final ca.spottedleaf.moonrise.common.list.IteratorSafeOrderedReferenceSet<net.minecraft.world.level.chunk.LevelChunk> chunks = new ca.spottedleaf.moonrise.common.list.IteratorSafeOrderedReferenceSet<>();
 +        if (region != null){
-+            for (net.minecraft.world.level.chunk.LevelChunk chunk : region.world.getCurrentWorldData().getTickingChunks()) {
-+            /* wait for rewrite - temporarily crash fix
 +            for (net.minecraft.server.level.ServerChunkCache.ChunkAndHolder chunkAndHolder : region.world.getCurrentWorldData().getTickingChunks()){
 +                final net.minecraft.world.level.chunk.LevelChunk chunk = chunkAndHolder.chunk();
-+            */
++
 +                if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(region.world, chunk.locX, chunk.locZ)){
 +                    continue;
 +                }
@@ -68,10 +66,10 @@ index 8502fdb94142cf12b8d9d4900d8a2440051051ae..d824b49b98266539258a83f9a36f73c5
              this.lastServerStatus = nanos;
              this.status = this.buildServerStatus();
 diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
-index 61d63e5668e110e9c0b891959bf4cd7c91e54645..f07d3009caf964b8e1b5328bb3e28866e0c41955 100644
+index f4b738b05ec9488e20402efb6c935ff55d86adf2..a0a8b0c7d091f63f023f15a2620b03ae2126782e 100644
 --- a/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/net/minecraft/server/dedicated/DedicatedServer.java
-@@ -721,6 +721,9 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+@@ -766,6 +766,9 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
  
      @Override
      public void stopServer() {
@@ -82,10 +80,10 @@ index 61d63e5668e110e9c0b891959bf4cd7c91e54645..f07d3009caf964b8e1b5328bb3e28866
          //Util.shutdownExecutors(); // Paper - Improved watchdog support; moved into super
          SkullBlockEntity.clear();
 diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
-index 5e3be75b27ed609be005e8169dc84c125518253e..00482efc8e736e73ad136105ad7b9dd2cafd581f 100644
+index f884c707d4c1f36801018e15efb9adf91f5d6b33..210eba85ac1a50d993ef6e19b65b9f8afada00ba 100644
 --- a/net/minecraft/server/level/ServerLevel.java
 +++ b/net/minecraft/server/level/ServerLevel.java
-@@ -1350,6 +1350,8 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -1339,6 +1339,8 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
          final int timerId = isActive ? entity.getType().tickTimerId : entity.getType().inactiveTickTimerId;
          final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler();
          profiler.startTimer(timerId);
@@ -94,7 +92,7 @@ index 5e3be75b27ed609be005e8169dc84c125518253e..00482efc8e736e73ad136105ad7b9dd2
          try {
          // Folia end - profiler
          if (isActive) { // Paper - EAR 2
-@@ -1367,6 +1369,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -1356,6 +1358,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
          } else {entity.inactiveTick();} // Paper - EAR 2
          profilerFiller.pop();
          } finally { profiler.stopTimer(timerId); } // Folia - profiler
@@ -102,7 +100,7 @@ index 5e3be75b27ed609be005e8169dc84c125518253e..00482efc8e736e73ad136105ad7b9dd2
  
          for (Entity entity1 : entity.getPassengers()) {
              this.tickPassenger(entity, entity1, isActive); // Paper - EAR 2
-@@ -1386,6 +1389,8 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -1375,6 +1378,8 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
              final int timerId = isActive ? passengerEntity.getType().tickTimerId : passengerEntity.getType().inactiveTickTimerId;
              final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler();
              profiler.startTimer(timerId);
@@ -111,7 +109,7 @@ index 5e3be75b27ed609be005e8169dc84c125518253e..00482efc8e736e73ad136105ad7b9dd2
              try {
              // Folia end - profiler
              passengerEntity.setOldPosAndRot();
-@@ -1420,6 +1425,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -1409,6 +1414,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
                  this.tickPassenger(passengerEntity, entity, isActive); // Paper - EAR 2
              }
              } finally { profiler.stopTimer(timerId); } // Folia - profiler
@@ -120,13 +118,13 @@ index 5e3be75b27ed609be005e8169dc84c125518253e..00482efc8e736e73ad136105ad7b9dd2
      }
  
 diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
-index 5e7a9be34bec7eefbb46db1409bfd90351866ec2..4e3c545f6121d3846d81d776c29edc42d6204f5c 100644
+index 8a192bb24abca6d2ea90d70e12f14733658ed27b..6e3e872ba415e8e809cfbe5a4dc1441b39c45480 100644
 --- a/net/minecraft/server/level/ServerPlayer.java
 +++ b/net/minecraft/server/level/ServerPlayer.java
-@@ -431,7 +431,9 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
-     public @Nullable com.destroystokyo.paper.event.entity.PlayerNaturallySpawnCreaturesEvent playerNaturallySpawnedEvent; // Paper - PlayerNaturallySpawnCreaturesEvent
+@@ -393,7 +393,9 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+     public com.destroystokyo.paper.event.entity.PlayerNaturallySpawnCreaturesEvent playerNaturallySpawnedEvent; // Paper - PlayerNaturallySpawnCreaturesEvent
      public @Nullable String clientBrandName = null; // Paper - Brand support
-     public @Nullable org.bukkit.event.player.PlayerQuitEvent.QuitReason quitReason = null; // Paper - Add API for quit reason; there are a lot of changes to do if we change all methods leading to the event
+     public org.bukkit.event.player.PlayerQuitEvent.QuitReason quitReason = null; // Paper - Add API for quit reason; there are a lot of changes to do if we change all methods leading to the event
 -
 +    public volatile boolean isTpsBarVisible = false; //Luminol - Tps bar
 +    public volatile boolean isMemBarVisible = false; //Luminol - Memory bar
@@ -134,10 +132,10 @@ index 5e7a9be34bec7eefbb46db1409bfd90351866ec2..4e3c545f6121d3846d81d776c29edc42
      // Paper start - rewrite chunk system
      private ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.PlayerChunkLoaderData chunkLoader;
      private final ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.ViewDistanceHolder viewDistanceHolder = new ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.ViewDistanceHolder();
-@@ -1025,8 +1027,35 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+@@ -1006,8 +1008,35 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
          this.trackEnteredOrExitedLavaOnVehicle();
          this.updatePlayerAttributes();
-         this.advancements.flushDirty(this, true);
+         this.advancements.flushDirty(this);
 +
 +        // KioCG start - ChunkHot
 +        if (this.tickCount % 20 == 0){
@@ -171,12 +169,12 @@ index 5e7a9be34bec7eefbb46db1409bfd90351866ec2..4e3c545f6121d3846d81d776c29edc42
          AttributeInstance attribute = this.getAttribute(Attributes.BLOCK_INTERACTION_RANGE);
          if (attribute != null) {
 diff --git a/net/minecraft/world/entity/AreaEffectCloud.java b/net/minecraft/world/entity/AreaEffectCloud.java
-index ec20a5a6d7c8f65abda528fec36bec7bc71117f6..b971cd61db1cfa05b8f2fd6c8a2dac2e27851288 100644
+index 23b342cc31c7e72ade0e1ccad86a9ccf34380f13..249cb7326c8e4012dcffdb6bbb7bfc1f1eeb7b33 100644
 --- a/net/minecraft/world/entity/AreaEffectCloud.java
 +++ b/net/minecraft/world/entity/AreaEffectCloud.java
-@@ -423,4 +423,11 @@ public class AreaEffectCloud extends Entity implements TraceableEntity {
-             return super.applyImplicitComponent(component, value);
-         }
+@@ -415,4 +415,11 @@ public class AreaEffectCloud extends Entity implements TraceableEntity {
+     public final boolean hurtServer(ServerLevel level, DamageSource damageSource, float amount) {
+         return false;
      }
 +
 +    // KioCG start
@@ -187,21 +185,21 @@ index ec20a5a6d7c8f65abda528fec36bec7bc71117f6..b971cd61db1cfa05b8f2fd6c8a2dac2e
 +    // KioCG end
  }
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index 49c76f150c913fdc21d0e253b78625e273f69a22..f5f03801da03089ea1d22de1012d90a2b7b17322 100644
+index f69fd922fa67cd366dbb93c34fa15659ba76c844..cc8efa162fbe7ce6a91629239bf18d7b6b096a8a 100644
 --- a/net/minecraft/world/entity/Entity.java
 +++ b/net/minecraft/world/entity/Entity.java
-@@ -6218,4 +6218,6 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-         return ((ServerLevel) this.level()).isPositionEntityTicking(this.blockPosition());
+@@ -5919,4 +5919,6 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         return ((ServerLevel) this.level).isPositionEntityTicking(this.blockPosition());
      }
      // Paper end - Expose entity id counter
 +
 +    public boolean shouldTickHot() { return this.tickCount > 20 * 10 && this.isAlive(); } // KioCG
  }
 diff --git a/net/minecraft/world/entity/LightningBolt.java b/net/minecraft/world/entity/LightningBolt.java
-index b091a382624140acb3f3f82647bdd592b7ee1f95..81b4e418687536b54f4ee8bd131185a8547ae651 100644
+index f003a65b34027dff14455860815c7d719c5289fa..6f9f8e52d2311343a0c0c3900a466c6a84f7de73 100644
 --- a/net/minecraft/world/entity/LightningBolt.java
 +++ b/net/minecraft/world/entity/LightningBolt.java
-@@ -288,4 +288,11 @@ public class LightningBolt extends Entity {
+@@ -287,4 +287,11 @@ public class LightningBolt extends Entity {
      public final boolean hurtServer(ServerLevel level, DamageSource damageSource, float amount) {
          return false;
      }
@@ -214,12 +212,12 @@ index b091a382624140acb3f3f82647bdd592b7ee1f95..81b4e418687536b54f4ee8bd131185a8
 +    // KioCG end
  }
 diff --git a/net/minecraft/world/entity/Mob.java b/net/minecraft/world/entity/Mob.java
-index 1240fb5394b1475c8e95a0e65bd03f2d15565d6f..d9ee3b56db44687cfcc6a75f44a1abbcc8ef95a9 100644
+index da922d4c0ffa0f40d5e8dd69487bf30dbbbeed87..94a7b95f41c2954561f9c3cb0f61210c0c058f1d 100644
 --- a/net/minecraft/world/entity/Mob.java
 +++ b/net/minecraft/world/entity/Mob.java
-@@ -1618,4 +1618,11 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
-             this.getNavigation().updatePathfinderMaxVisitedNodes();
-         }
+@@ -1722,4 +1722,11 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
+     public float[] getArmorDropChances() {
+         return this.armorDropChances;
      }
 +
 +    // KioCG start
@@ -230,7 +228,7 @@ index 1240fb5394b1475c8e95a0e65bd03f2d15565d6f..d9ee3b56db44687cfcc6a75f44a1abbc
 +    // KioCG end
  }
 diff --git a/net/minecraft/world/entity/animal/horse/TraderLlama.java b/net/minecraft/world/entity/animal/horse/TraderLlama.java
-index 2cd1b988f44caf271a7d2dfccf118be53b77caba..d829b230ab366922697061bdbb9a4f1cdc00744f 100644
+index c5b11a63bb2ab660efcc386ad9b4697e2a5efc97..f139822cb3e90b9d5fac6971e2ef1a8569d9849b 100644
 --- a/net/minecraft/world/entity/animal/horse/TraderLlama.java
 +++ b/net/minecraft/world/entity/animal/horse/TraderLlama.java
 @@ -157,4 +157,11 @@ public class TraderLlama extends Llama {
@@ -246,10 +244,10 @@ index 2cd1b988f44caf271a7d2dfccf118be53b77caba..d829b230ab366922697061bdbb9a4f1c
 +    // KioCG end
  }
 diff --git a/net/minecraft/world/entity/npc/WanderingTrader.java b/net/minecraft/world/entity/npc/WanderingTrader.java
-index c2573946dd1244eb5d1ef2be7823211064daa80d..7e9662bf7c17b2f5eda2ff88970a23e4fb09456a 100644
+index 6655d06e2011e20e7346dfe57527795269094d8a..48aa6fcb5c16fdbb4ae902cbb72c6b8e02820c88 100644
 --- a/net/minecraft/world/entity/npc/WanderingTrader.java
 +++ b/net/minecraft/world/entity/npc/WanderingTrader.java
-@@ -278,4 +278,11 @@ public class WanderingTrader extends net.minecraft.world.entity.npc.AbstractVill
+@@ -320,4 +320,11 @@ public class WanderingTrader extends net.minecraft.world.entity.npc.AbstractVill
              return !pos.closerToCenterThan(this.trader.position(), distance);
          }
      }
@@ -262,10 +260,10 @@ index c2573946dd1244eb5d1ef2be7823211064daa80d..7e9662bf7c17b2f5eda2ff88970a23e4
 +    // KioCG end
  }
 diff --git a/net/minecraft/world/entity/player/Player.java b/net/minecraft/world/entity/player/Player.java
-index 73d1557f2d7d60a9a2ad2c3f710b0969c4c5cf40..47f62fbe97c559c25ad2bc67c18f2025c78e2c69 100644
+index e70919757dee4b02384ded3551c8f580d289584a..ae049c5c3593525b991d865fec695c00ad408a59 100644
 --- a/net/minecraft/world/entity/player/Player.java
 +++ b/net/minecraft/world/entity/player/Player.java
-@@ -1493,6 +1493,13 @@ public abstract class Player extends LivingEntity {
+@@ -1546,6 +1546,13 @@ public abstract class Player extends LivingEntity {
          return true;
      }
  
@@ -280,10 +278,10 @@ index 73d1557f2d7d60a9a2ad2c3f710b0969c4c5cf40..47f62fbe97c559c25ad2bc67c18f2025
          // CraftBukkit start
          return this.startSleepInBed(bedPos, false);
 diff --git a/net/minecraft/world/entity/projectile/Projectile.java b/net/minecraft/world/entity/projectile/Projectile.java
-index b6cdd02ead8ecc38afd4e76fa0c19a9433550b1d..71c1473e470db82dffcf6be4b4ded61564577e92 100644
+index abfe6765faec49d4b8897608582d738c7b09522d..6e1de9252ac1236e0c5196e2511c72c0d7eb3502 100644
 --- a/net/minecraft/world/entity/projectile/Projectile.java
 +++ b/net/minecraft/world/entity/projectile/Projectile.java
-@@ -488,4 +488,11 @@ public abstract class Projectile extends Entity implements TraceableEntity {
+@@ -516,4 +516,11 @@ public abstract class Projectile extends Entity implements TraceableEntity {
      public interface ProjectileFactory<T extends Projectile> {
          T create(ServerLevel level, LivingEntity owner, ItemStack spawnedFrom);
      }
@@ -296,18 +294,18 @@ index b6cdd02ead8ecc38afd4e76fa0c19a9433550b1d..71c1473e470db82dffcf6be4b4ded615
 +    // KioCG end
  }
 diff --git a/net/minecraft/world/level/chunk/LevelChunk.java b/net/minecraft/world/level/chunk/LevelChunk.java
-index e74ea44096e071878372c5b8889f45cd2bd4ae23..7add73f2dd957374661affebfa2b0102d99363f8 100644
+index 78211c68bf52c0cd402fee7bcdde223130d49b5c..83b0e91165024697f6b7d41d43142b2b33641968 100644
 --- a/net/minecraft/world/level/chunk/LevelChunk.java
 +++ b/net/minecraft/world/level/chunk/LevelChunk.java
-@@ -106,6 +106,7 @@ public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.p
+@@ -103,6 +103,7 @@ public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.p
      // Paper start - rewrite chunk system
      private boolean postProcessingDone;
-     private ca.spottedleaf.moonrise.patches.chunk_system.scheduling.NewChunkHolder chunkAndHolder;
+     private net.minecraft.server.level.ServerChunkCache.ChunkAndHolder chunkAndHolder;
 +    private final com.kiocg.ChunkHot chunkHot = new com.kiocg.ChunkHot(); public com.kiocg.ChunkHot getChunkHot() { return this.chunkHot; } // KioCG
  
      @Override
      public final boolean moonrise$isPostProcessingDone() {
-@@ -937,6 +938,7 @@ public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.p
+@@ -926,6 +927,7 @@ public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.p
                      try {
                          ProfilerFiller profilerFiller = Profiler.get();
                          profilerFiller.push(this::getType);
@@ -315,7 +313,7 @@ index e74ea44096e071878372c5b8889f45cd2bd4ae23..7add73f2dd957374661affebfa2b0102
                          profiler.startTimer(timerId); try { // Folia - profiler
                          BlockState blockState = LevelChunk.this.getBlockState(blockPos);
                          if (this.blockEntity.getType().isValid(blockState)) {
-@@ -951,7 +953,7 @@ public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.p
+@@ -940,7 +942,7 @@ public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.p
                              }
                              // Paper end - Remove the Block Entity if it's invalid
                          }
@@ -325,11 +323,11 @@ index e74ea44096e071878372c5b8889f45cd2bd4ae23..7add73f2dd957374661affebfa2b0102
                          profilerFiller.pop();
                      } catch (Throwable var5) {
 diff --git a/net/minecraft/world/level/redstone/NeighborUpdater.java b/net/minecraft/world/level/redstone/NeighborUpdater.java
-index 332b33a004ab11150cca0cc2cefc26d0286648f5..714e291b17856aacdac7db992fc18e6ae662f659 100644
+index 26c15c60d358273a3b369c286771c81d6f0979dd..715580a893ba9dd34ee562b81350b81f9da3f905 100644
 --- a/net/minecraft/world/level/redstone/NeighborUpdater.java
 +++ b/net/minecraft/world/level/redstone/NeighborUpdater.java
-@@ -57,7 +57,10 @@ public interface NeighborUpdater {
-                 return;
+@@ -60,7 +60,10 @@ public interface NeighborUpdater {
+                 }
              }
              // CraftBukkit end
 +            net.minecraft.world.level.chunk.LevelChunk levelChunk = level.getChunkIfLoaded(pos); // KioCG
@@ -338,4 +336,4 @@ index 332b33a004ab11150cca0cc2cefc26d0286648f5..714e291b17856aacdac7db992fc18e6a
 +            } finally { if (levelChunk != null) levelChunk.getChunkHot().stopTickingAndCount(); } // KioCG
              // Spigot start
          } catch (StackOverflowError ex) {
-             level.lastPhysicsProblem = pos.immutable();
+             level.lastPhysicsProblem = new BlockPos(pos);

luminol-server/minecraft-patches/features/0021-Teleport-async-if-entity-was-moving-to-another-regio.patch

@@ -6,21 +6,21 @@ Subject: [PATCH] Teleport async if entity was moving to another region at once
 On folia, entity usually cannot move out of the tickregion, but sometimes it actually does(like some end pearl gun that can shoot an end pearl to the block faraway than 10000 blocks even more). To fix this, we added a temporary fix which teleport these entities to the destination instead running its move logics so that we could ensure anything is under control.But one thing need to consider is that teleportAsync is actually calling halfway of the entity tick and there is still something running when teleportAsync called, which is actually modified the entity in another thread, so there is still need an improvement
 
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index 43d0ad699a02a5156fe958f709c941a7cab6daa3..990ea0359c9015f867dc529a284148cd4846f5e8 100644
+index cc8efa162fbe7ce6a91629239bf18d7b6b096a8a..4026d465687604965f105ded21a8206fd52bd375 100644
 --- a/net/minecraft/world/entity/Entity.java
 +++ b/net/minecraft/world/entity/Entity.java
-@@ -1110,6 +1110,10 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
- 
-     private boolean boundingBoxChanged = false; // Gale - VMP - skip entity move if movement is zero
+@@ -1100,6 +1100,10 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     }
+     // Paper end - detailed watchdog information
  
 +    //Luminol start - Fix large pos moving
 +    private volatile boolean preventMoving = false;
 +    //Luminol end
 +
      public void move(MoverType type, Vec3 movement) {
-         // Gale start - VMP - skip entity move if movement is zero
-         if (!this.boundingBoxChanged && movement.equals(Vec3.ZERO)) {
-@@ -1125,6 +1129,32 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         final Vec3 originalMovement = movement; // Paper - Expose pre-collision velocity
+         // Paper start - detailed watchdog information
+@@ -1110,6 +1114,32 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
              this.moveStartZ = this.getZ();
              this.moveVector = movement;
          }

luminol-server/minecraft-patches/features/0023-Correct-player-respawn-place.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Correct player respawn place
 
 
 diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
-index 8b6b881896797b93a2f475c21101463e1888cee1..a632bfb00e151a395e886aff3471084dc6cf4102 100644
+index 6e3e872ba415e8e809cfbe5a4dc1441b39c45480..40f3700c9bf56cfb26f0bca0dc6320fad8c75a65 100644
 --- a/net/minecraft/server/level/ServerPlayer.java
 +++ b/net/minecraft/server/level/ServerPlayer.java
-@@ -566,8 +566,10 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+@@ -465,8 +465,10 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
          double amountX = selectMaxX - selectMinX;
          double amountZ = selectMaxZ - selectMinZ;
  
@@ -21,7 +21,7 @@ index 8b6b881896797b93a2f475c21101463e1888cee1..a632bfb00e151a395e886aff3471084d
  
          return new BlockPos(selectX, 0, selectZ);
      }
-@@ -578,10 +580,20 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+@@ -477,10 +479,20 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
      }
  
      private static BlockPos findSpawnAround(ServerLevel world, ServerPlayer player, BlockPos selected) {

luminol-server/minecraft-patches/features/0024-Command-IllegalArgumentException-crash-fix.patch

@@ -1,45 +1,45 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Helvetica Volubi <suisuroru@blue-millennium.fun>
-Date: Sat, 24 May 2025 04:04:42 +0800
+Date: Thu, 24 Apr 2025 20:59:52 +0800
 Subject: [PATCH] Command IllegalArgumentException crash fix
 
 
 diff --git a/net/minecraft/server/commands/FillCommand.java b/net/minecraft/server/commands/FillCommand.java
-index 7665bff921eda626c0f1498a4ca03b62483d10ed..350adc15b06f2405137c2c753cbb673541df61fb 100644
+index 89154adfc659afa188cd771e70087e3b1a9c98b9..e622f96e6e116bf491bbea39da099e02ceaee502 100644
 --- a/net/minecraft/server/commands/FillCommand.java
 +++ b/net/minecraft/server/commands/FillCommand.java
-@@ -248,6 +248,10 @@ public class FillCommand {
-                 // Folia start - region threading
+@@ -210,6 +210,10 @@ public class FillCommand {
+             // Folia start - region threading
                  } catch (CommandSyntaxException ex) {
                      sendMessage(source, ex);
 +                // Luminol Start - Server crash fix
 +                } catch (IllegalArgumentException ex) {
 +                    net.minecraft.server.commands.SetBlockCommand.processIAE(source, ex);
 +                // Luminol End - Server crash fix
-                 }}); return 0; // Folia end - region threading
-             }
+                 }
+             }); return 0; // Folia end - region threading
          }
 diff --git a/net/minecraft/server/commands/SetBlockCommand.java b/net/minecraft/server/commands/SetBlockCommand.java
-index 07cff4e1e7af98cf3ead1f255557c1a994072610..34cc1906bfb49501bb2b3477bc99429e05cbb0f6 100644
+index 05b824409546ba8bacf7efdaeac106af89ff0715..55911d49c7650b344b46b2cfa9c4ae840ae433c8 100644
 --- a/net/minecraft/server/commands/SetBlockCommand.java
 +++ b/net/minecraft/server/commands/SetBlockCommand.java
-@@ -102,6 +102,15 @@ public class SetBlockCommand {
+@@ -86,6 +86,15 @@ public class SetBlockCommand {
      }
      // Folia end - region threading
  
 +    // Luminol Start - Server crash fix
 +    public static void processIAE(CommandSourceStack src, IllegalArgumentException ex) {
 +        Component hoverText = Component.translatable("command.failed")
-+                .withStyle(style -> style.withHoverEvent(new net.minecraft.network.chat.HoverEvent.ShowText(Component.literal(ex.getMessage()))));
++                .withStyle(style -> style.withHoverEvent(new net.minecraft.network.chat.HoverEvent(net.minecraft.network.chat.HoverEvent.Action.SHOW_TEXT, Component.literal(ex.getMessage()))));
 +        src.sendFailure(hoverText);
 +        com.mojang.logging.LogUtils.getLogger().error(ex.getMessage(), ex);
 +    }
 +    // Luminol end - Server crash fix
 +
      private static int setBlock(
-         CommandSourceStack source, BlockPos pos, BlockInput block, SetBlockCommand.Mode mode, @Nullable Predicate<BlockInWorld> filter, boolean strict
+         CommandSourceStack source, BlockPos pos, BlockInput state, SetBlockCommand.Mode mode, @Nullable Predicate<BlockInWorld> predicate
      ) throws CommandSyntaxException {
-@@ -139,6 +148,10 @@ public class SetBlockCommand {
+@@ -119,6 +128,10 @@ public class SetBlockCommand {
          // Folia start - region threading
                  } catch (CommandSyntaxException ex) {
                      sendMessage(source, ex);

luminol-server/minecraft-patches/features/0025-Do-not-search-the-block-out-of-current-region.patch

@@ -0,0 +1,21 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <mrhua269@gmail.com>
+Date: Sun, 9 Mar 2025 11:39:01 +0800
+Subject: [PATCH] Do not search the block out of current region
+
+Skip getting the blocks don't belong to current tickregion.
+
+notice: this bug is actually caused by another bug of the teleportAsync implementation.
+
+diff --git a/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java b/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
+index 61887e6b052bca715c90dff5d9cd657e0b3f6a78..95e2dff6782bf7767ecb1a23e618862919ea71aa 100644
+--- a/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
++++ b/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
+@@ -422,6 +422,7 @@ public class TheEndGatewayBlockEntity extends TheEndPortalBlockEntity {
+                 if (i != 0 || i1 != 0 || allowBedrock) {
+                     for (int y = level.getMaxY(); y > (blockPos == null ? level.getMinY() : blockPos.getY()); y--) {
+                         BlockPos blockPos1 = new BlockPos(pos.getX() + i, y, pos.getZ() + i1);
++                        if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor((Level) level, blockPos1)) continue; // Luminol - Do not search the block out of current region as we might be at the edge of the tickregion
+                         BlockState blockState = level.getBlockState(blockPos1);
+                         if (blockState.isCollisionShapeFullBlock(level, blockPos1) && (allowBedrock || !blockState.is(Blocks.BEDROCK))) {
+                             blockPos = blockPos1;

luminol-server/minecraft-patches/features/0026-Force-disable-builtin-spark-plugin.patch

@@ -6,7 +6,7 @@ Subject: [PATCH] Force disable builtin spark plugin
 The spark passed down from paper has some memory leaking issue, so we fully removed it from the code to prevent that memory leaking issue.
 
 diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index d824b49b98266539258a83f9a36f73c5961a1588..737df5c9345e22fa4487cbb83c7462b92a4f9e78 100644
+index 56f5568848d0f20b4d706c07dc8114594e0b5337..e62e8b9af7ad3e4454702ac86ad2b27973eba66f 100644
 --- a/net/minecraft/server/MinecraftServer.java
 +++ b/net/minecraft/server/MinecraftServer.java
 @@ -783,8 +783,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
@@ -20,7 +20,7 @@ index d824b49b98266539258a83f9a36f73c5961a1588..737df5c9345e22fa4487cbb83c7462b9
          if (io.papermc.paper.plugin.PluginInitializerManager.instance().pluginRemapper != null) io.papermc.paper.plugin.PluginInitializerManager.instance().pluginRemapper.pluginsEnabled(); // Paper - Remap plugins
          io.papermc.paper.command.brigadier.PaperCommands.INSTANCE.setValid(); // Paper - reset invalid state for event fire below
          io.papermc.paper.plugin.lifecycle.event.LifecycleEventRunner.INSTANCE.callReloadableRegistrarEvent(io.papermc.paper.plugin.lifecycle.event.types.LifecycleEvents.COMMANDS, io.papermc.paper.command.brigadier.PaperCommands.INSTANCE, org.bukkit.plugin.Plugin.class, io.papermc.paper.plugin.lifecycle.event.registrar.ReloadableRegistrarEvent.Cause.INITIAL); // Paper - call commands event for regular plugins
-@@ -1067,7 +1067,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -1072,7 +1072,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
          Commands.COMMAND_SENDING_POOL.shutdownNow(); // Paper - Perf: Async command map building; Shutdown and don't bother finishing
          // CraftBukkit start
          if (this.server != null) {
@@ -29,7 +29,7 @@ index d824b49b98266539258a83f9a36f73c5961a1588..737df5c9345e22fa4487cbb83c7462b9
              this.server.disablePlugins();
              this.server.waitForAsyncTasksShutdown(); // Paper - Wait for Async Tasks during shutdown
          }
-@@ -1251,7 +1251,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -1250,7 +1250,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
              this.statusIcon = this.loadStatusIcon().orElse(null);
              this.status = this.buildServerStatus();
  
@@ -38,7 +38,7 @@ index d824b49b98266539258a83f9a36f73c5961a1588..737df5c9345e22fa4487cbb83c7462b9
              // Folia start - region threading
              if (true) {
                  io.papermc.paper.threadedregions.RegionizedServer.getInstance().init(); // Folia - region threading - only after loading worlds
-@@ -1594,7 +1594,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -1593,7 +1593,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
              }
  
              if (this.emptyTicks >= i) {
@@ -47,16 +47,17 @@ index d824b49b98266539258a83f9a36f73c5961a1588..737df5c9345e22fa4487cbb83c7462b9
                  if (this.emptyTicks == i) {
                      LOGGER.info("Server empty for {} seconds, pausing", this.pauseWhileEmptySeconds());
                      this.autoSave();
-@@ -1613,7 +1613,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -1612,7 +1612,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
                  // Paper end - avoid issues with certain tasks not processing during sleep
                  //this.server.spark.executeMainThreadTasks(); // Paper - spark // Folia - region threading
                  this.tickConnection();
 -                this.server.spark.tickEnd(((double)(System.nanoTime() - lastTick) / 1000000D)); // Paper - spark
 +                if (false) this.server.spark.tickEnd(((double)(System.nanoTime() - lastTick) / 1000000D)); // Paper - spark  // Luminol - Force disable builtin spark
++                // Paper end - Server Tick Events
                  return;
              }
          }
-@@ -1636,7 +1636,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -1635,7 +1636,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
          };
          // Folia end - region threading
  
@@ -65,7 +66,7 @@ index d824b49b98266539258a83f9a36f73c5961a1588..737df5c9345e22fa4487cbb83c7462b9
          new com.destroystokyo.paper.event.server.ServerTickStartEvent((int)region.getCurrentTick()).callEvent(); // Paper - Server Tick Events // Folia - region threading
          // Folia start - region threading
          if (region != null) {
-@@ -1744,7 +1744,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -1743,7 +1744,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
          long remaining = scheduledEnd - endTime; // Folia - region ticking
          new com.destroystokyo.paper.event.server.ServerTickEndEvent((int)io.papermc.paper.threadedregions.RegionizedServer.getCurrentTick(), ((double)(endTime - startTime) / 1000000D), remaining).callEvent(); // Folia - region ticking
          // Paper end - Server Tick Events
@@ -75,19 +76,19 @@ index d824b49b98266539258a83f9a36f73c5961a1588..737df5c9345e22fa4487cbb83c7462b9
      }
  
 diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
-index f07d3009caf964b8e1b5328bb3e28866e0c41955..1f3c26cc9f3b687693c36f2946394fad5ab6bc9f 100644
+index a0a8b0c7d091f63f023f15a2620b03ae2126782e..d7c922540b46e289395aeed514c98e43dc298e7b 100644
 --- a/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/net/minecraft/server/dedicated/DedicatedServer.java
-@@ -173,7 +173,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+@@ -214,7 +214,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
          // Paper end - initialize global and world-defaults configuration
-         me.earthme.luminol.config.LuminolConfig.finalizeLoadConfig(); // Luminol - load config file
-         me.earthme.luminol.config.LuminolConfig.setupLatch(); // Luminol - load config file
+         me.earthme.luminol.config.LuminolConfig.finalizeLoadConfig(); //Luminol - load config file
+         me.earthme.luminol.config.LuminolConfig.setupLatch(); //Luminol - load config file
 -        this.server.spark.enableEarlyIfRequested(); // Paper - spark
 +        if (false) this.server.spark.enableEarlyIfRequested(); // Paper - spark // Luminol - Force disable builtin spark
          // Paper start - fix converting txt to json file; convert old users earlier after PlayerList creation but before file load/save
          if (this.convertOldUsers()) {
              this.getProfileCache().save(false); // Paper
-@@ -183,7 +183,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+@@ -224,7 +224,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
          org.spigotmc.WatchdogThread.doStart(org.spigotmc.SpigotConfig.timeoutTime, org.spigotmc.SpigotConfig.restartOnCrash); // Paper - start watchdog thread
          thread.start(); // Paper - Enhance console tab completions for brigadier commands; start console thread after MinecraftServer.console & PaperConfig are initialized
          io.papermc.paper.command.PaperCommands.registerCommands(this); // Paper - setup /paper command

luminol-server/minecraft-patches/features/0027-Fix-creative-player-item-pick.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Fix creative player item pick
 
 
 diff --git a/net/minecraft/world/entity/item/ItemEntity.java b/net/minecraft/world/entity/item/ItemEntity.java
-index a596813c3cbacb1a4be86d41be01e8850fc6799c..244996de73d75e812e27aa896cd3875a14179b74 100644
+index 7587130e021d494ae5013f7992b8f3c96590cbd7..1116e2f00ea54f738535d7243fec6ad49b96f6ee 100644
 --- a/net/minecraft/world/entity/item/ItemEntity.java
 +++ b/net/minecraft/world/entity/item/ItemEntity.java
-@@ -409,7 +409,15 @@ public class ItemEntity extends Entity implements TraceableEntity {
+@@ -435,7 +435,15 @@ public class ItemEntity extends Entity implements TraceableEntity {
              Item item1 = item.getItem();
              int count = item.getCount();
              // CraftBukkit start - fire PlayerPickupItemEvent

luminol-server/minecraft-patches/features/0028-Fix-a-series-issue-around-entity-memory-typed-Global.patch

@@ -62,10 +62,10 @@ index 36a9887f8be04c5c3fda6d926d819a9e5b2a79f2..5681592bdeb050d875c4c5d0dfaf6e01
                  return Optional.of(new BlockPosTracker(globalPos.pos().above()));
              }
 diff --git a/net/minecraft/world/entity/animal/sniffer/Sniffer.java b/net/minecraft/world/entity/animal/sniffer/Sniffer.java
-index 6a9f31c1f39cc14ad7b5ae3af85908bc7a4caae4..34fea93dddfe0b947eb2517dd083ca842d19a0c6 100644
+index 62ca7871d1e5d0fe611948ad43e44c23fdc2d3f8..cd0fc85fbefce4669b4cb637ec3b2628da57adbf 100644
 --- a/net/minecraft/world/entity/animal/sniffer/Sniffer.java
 +++ b/net/minecraft/world/entity/animal/sniffer/Sniffer.java
-@@ -268,7 +268,17 @@ public class Sniffer extends Animal {
+@@ -257,7 +257,17 @@ public class Sniffer extends Animal {
  
      private boolean canDig(BlockPos pos) {
          return this.level().getBlockState(pos).is(BlockTags.SNIFFER_DIGGABLE_BLOCK)

luminol-server/minecraft-patches/features/0028-Leaves-Disable-moved-wrongly-threshold.patch

@@ -1,50 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: adabugra <57899270+adabugra@users.noreply.github.com>
-Date: Fri, 31 Jan 2025 19:17:01 +0300
-Subject: [PATCH] Leaves: Disable moved wrongly threshold
-
-Co-authored by: violetc <58360096+s-yh-china@users.noreply.github.com>
-As part of: Leaves (https://github.com/LeavesMC/Leaves/blob/f553c53e4230aa032e54a69b6479f1959ed24a60/patches/removed/server/0099-Disable-moved-wrongly-threshold.patch)
-Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
-
-diff --git a/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 4bab02bb85b4be5bf539b498de040fd1d4fc671a..4ced5b334fbfe68ce8eef38eeea5af6d007cea00 100644
---- a/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -600,7 +600,7 @@ public class ServerGamePacketListenerImpl
-                     return;
-                 }
-                 // Paper end - Prevent moving into unloaded chunks
--                if (d7 - d6 > Math.max(100.0, Mth.square(org.spigotmc.SpigotConfig.movedTooQuicklyMultiplier * (float) i * speed)) && !this.isSingleplayerOwner()) {
-+                if (!me.earthme.luminol.config.modules.misc.DisableMovedWronglyThreshold.enabled && d7 - d6 > Math.max(100.0, Mth.square(org.spigotmc.SpigotConfig.movedTooQuicklyMultiplier * (float) i * speed)) && !this.isSingleplayerOwner()) { // Leaves - disable can
-                     // CraftBukkit end
-                     LOGGER.warn(
-                         "{} (vehicle of {}) moved too quickly! {},{},{}", rootVehicle.getName().getString(), this.player.getName().getString(), d3, d4, d5
-@@ -630,7 +630,7 @@ public class ServerGamePacketListenerImpl
-                 d5 = d2 - rootVehicle.getZ();
-                 d7 = d3 * d3 + d4 * d4 + d5 * d5;
-                 boolean flag1 = false;
--                if (d7 > org.spigotmc.SpigotConfig.movedWronglyThreshold) { // Spigot
-+                if (!me.earthme.luminol.config.modules.misc.DisableMovedWronglyThreshold.enabled && d7 > org.spigotmc.SpigotConfig.movedWronglyThreshold) { // Spigot
-                     flag1 = true; // Paper - diff on change, this should be moved wrongly
-                     LOGGER.warn("{} (vehicle of {}) moved wrongly! {}", rootVehicle.getName().getString(), this.player.getName().getString(), Math.sqrt(d7));
-                 }
-@@ -1519,7 +1519,7 @@ public class ServerGamePacketListenerImpl
- 
-                                     if (this.shouldCheckPlayerMovement(isFallFlying)) {
-                                         float f2 = isFallFlying ? 300.0F : 100.0F;
--                                        if (d7 - d6 > Math.max(f2, Mth.square(org.spigotmc.SpigotConfig.movedTooQuicklyMultiplier * (float) i * speed))) {
-+                                        if (!me.earthme.luminol.config.modules.misc.DisableMovedWronglyThreshold.enabled && d7 - d6 > Math.max(f2, Mth.square(org.spigotmc.SpigotConfig.movedTooQuicklyMultiplier * (float) i * speed))) { // Leaves - disable can
-                                             // CraftBukkit end
-                                             // Paper start - Add fail move event
-                                             io.papermc.paper.event.player.PlayerFailMoveEvent event = fireFailMove(io.papermc.paper.event.player.PlayerFailMoveEvent.FailReason.MOVED_TOO_QUICKLY,
-@@ -1593,7 +1593,8 @@ public class ServerGamePacketListenerImpl
-                                 d5 = d2 - this.player.getZ();
-                                 d7 = d3 * d3 + d4 * d4 + d5 * d5;
-                                 boolean movedWrongly = false; // Paper - Add fail move event; rename
--                                if (!this.player.isChangingDimension()
-+                                if (!me.earthme.luminol.config.modules.misc.DisableMovedWronglyThreshold.enabled // Leaves - disable can
-+                                    && !this.player.isChangingDimension()
-                                     && d7 > org.spigotmc.SpigotConfig.movedWronglyThreshold // Spigot
-                                     && !this.player.isSleeping()
-                                     && !this.player.isCreative()

luminol-server/minecraft-patches/features/0029-Fix-incorrectly-synced-data-after-player-teleportati.patch

@@ -0,0 +1,34 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <mrhua269@gmail.com>
+Date: Fri, 2 May 2025 12:03:14 +0800
+Subject: [PATCH] Fix incorrectly synced data after player teleportation
+
+Use vanilla's flag and logics to run some status sync after post teleportation, folia forgets send some packets after teleportation and which caused some desync between client and server
+
+diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
+index 40f3700c9bf56cfb26f0bca0dc6320fad8c75a65..b5d0eb5026067080a376b9c3f902dcdf40d5dc48 100644
+--- a/net/minecraft/server/level/ServerPlayer.java
++++ b/net/minecraft/server/level/ServerPlayer.java
+@@ -1805,14 +1805,20 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+             this.connection.send(new ClientboundChangeDifficultyPacket(
+                 worlddata.getDifficulty(), worlddata.isDifficultyLocked()
+             ));
+-            this.connection.send(new ClientboundSetExperiencePacket(
++            /*this.connection.send(new ClientboundSetExperiencePacket( // Luminol start - teleportAsync tweaks, will send in next tick, see the changes below
+                 this.experienceProgress, this.totalExperience, this.experienceLevel
+-            ));
++            ));*/ // Luminol end
+ 
+             playerlist.sendActivePlayerEffects(this);
+             playerlist.sendLevelInfo(this, destination);
+             playerlist.sendPlayerPermissionLevel(this);
+ 
++            // Luminol start - teleportAsync tweaks
++            this.lastSentExp = -1;
++            this.lastSentHealth = -1.0F;
++            this.lastSentFood = -1;
++            // Luminol end
++
+             // regular world add logic
+             this.unsetRemoved();
+             destination.addDuringTeleport(this);

luminol-server/minecraft-patches/features/0029-Leaves-Configurable-collision-behavior.patch

@@ -1,56 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Helvetica Volubi <suisuroru@blue-millennium.fun>
-Date: Wed, 4 Jun 2025 12:51:07 +0800
-Subject: [PATCH] Leaves: Configurable collision behavior
-
-Co-authored by: Fortern <blueten.ki@gmail.com>
-As part of: Leaves (https://github.com/LeavesMC/Leaves/blob/c5f18b7864206cea4411211b51787f10affbcb9c/leaves-server/minecraft-patches/features/0111-Configurable-collision-behavior.patch)
-Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
-
-diff --git a/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java b/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java
-index 864ce0bd822a2bd6fb39866103dc54b56bf0b63c..b03096b298dbdd35ac0e4d54f96c2ab3b5b4bd21 100644
---- a/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java
-+++ b/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java
-@@ -101,6 +101,14 @@ public final class CollisionUtil {
-                (box1.minZ - box2.maxZ) < -COLLISION_EPSILON && (box1.maxZ - box2.minZ) > COLLISION_EPSILON;
-     }
- 
-+    // Leaves start - Configurable collision behavior
-+    public static boolean voxelShapeIntersectVanilla(final AABB box1, final AABB box2) {
-+        return box1.minX < box2.maxX && box1.maxX > box2.minX &&
-+               box1.minY < box2.maxY && box1.maxY > box2.minY &&
-+               box1.minZ < box2.maxZ && box1.maxZ > box2.minZ;
-+    }
-+    // Leaves end - Configurable collision behavior
-+
-     // assume !isEmpty(target) && abs(source_move) >= COLLISION_EPSILON
-     public static double collideX(final AABB target, final AABB source, final double source_move) {
-         if ((source.minY - target.maxY) < -COLLISION_EPSILON && (source.maxY - target.minY) > COLLISION_EPSILON &&
-@@ -2025,7 +2033,7 @@ public final class CollisionUtil {
-                                     AABB singleAABB = ((CollisionVoxelShape)blockCollision).moonrise$getSingleAABBRepresentation();
-                                     if (singleAABB != null) {
-                                         singleAABB = singleAABB.move((double)blockX, (double)blockY, (double)blockZ);
--                                        if (!voxelShapeIntersect(aabb, singleAABB)) {
-+                                        if (shouldSkip(aabb, blockCollision, singleAABB)) { // Leaves - Configurable collision behavior
-                                             continue;
-                                         }
- 
-@@ -2078,6 +2086,18 @@ public final class CollisionUtil {
-         return ret;
-     }
- 
-+    // Leaves start - Configurable collision behavior
-+    private static boolean shouldSkip(AABB aabb, VoxelShape blockCollision, AABB singleAABB) {
-+        boolean isBlockShape = blockCollision == Shapes.block();
-+        return switch (me.earthme.luminol.config.modules.misc.CollisionBehaviorConfig.behaviorMode) {
-+            case "VANILLA" -> !voxelShapeIntersectVanilla(aabb, singleAABB);
-+            case "PAPER" -> !voxelShapeIntersect(aabb, singleAABB);
-+            default -> isBlockShape && !voxelShapeIntersectVanilla(aabb, singleAABB) || !isBlockShape && !voxelShapeIntersect(aabb, singleAABB);
-+            // All other value as BLOCK_SHAPE_VANILLA to process
-+        };
-+    }
-+    // Leaves end - Configurable collision behavior
-+
-     public static boolean getEntityHardCollisions(final Level world, final Entity entity, AABB aabb,
-                                                   final List<AABB> into, final int collisionFlags, final Predicate<Entity> predicate) {
-         final boolean checkOnly = (collisionFlags & COLLISION_FLAG_CHECK_ONLY) != 0;

luminol-server/minecraft-patches/features/0030-Fix-off-tickregion-sync-teleport.patch

@@ -6,10 +6,10 @@ Subject: [PATCH] Fix off tickregion sync teleport
 Folis's teleportAsync implementation has some checks missing during the sync teleportation checks, if we are teleport to the edge of the tickregion, it is still asserting that we are in the same tickregion and moved us directly, but there is actually some logics is already touching the stuff out of current tickregion.So we added some new edge checks to the sync teleportation checks which will check the tickregion belonging in a shape of cycle which is in min(entity's bounding box + simulate distance, 6) of radius to fix that issue
 
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index 4d275da5772f90ed460f6aafef483c06b740c702..43d0ad699a02a5156fe958f709c941a7cab6daa3 100644
+index 4026d465687604965f105ded21a8206fd52bd375..771744d4540fcd163efcde43c27111680b25c928 100644
 --- a/net/minecraft/world/entity/Entity.java
 +++ b/net/minecraft/world/entity/Entity.java
-@@ -4226,6 +4226,21 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4060,6 +4060,21 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
          this.resetStoredPositions();
      }
  
@@ -31,7 +31,7 @@ index 4d275da5772f90ed460f6aafef483c06b740c702..43d0ad699a02a5156fe958f709c941a7
      protected final void transform(TeleportTransition telpeort) {
          PositionMoveRotation move = PositionMoveRotation.calculateAbsolute(
              PositionMoveRotation.of(this), PositionMoveRotation.of(telpeort), telpeort.relatives()
-@@ -4348,7 +4363,8 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4157,7 +4172,8 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
          // check for same region
          if (destination == this.level()) {
              Vec3 currPos = this.position();

luminol-server/minecraft-patches/features/0030-Leaves-Fix-chunk-reload-detector.patch

@@ -1,22 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Helvetica Volubi <suisuroru@blue-millennium.fun>
-Date: Wed, 4 Jun 2025 12:54:22 +0800
-Subject: [PATCH] Leaves: Fix chunk reload detector
-
-Co-authored by: Fortern <blueten.ki@gmail.com>
-As part of: Leaves (https://github.com/LeavesMC/Leaves/blob/c5f18b7864206cea4411211b51787f10affbcb9c/leaves-server/minecraft-patches/features/0123-Fix-chunk-reload-detector.patch)
-Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
-
-diff --git a/net/minecraft/server/level/ServerEntity.java b/net/minecraft/server/level/ServerEntity.java
-index e96d4dee14c05f2fa329bfb1588ec795d4e3d730..2d4c68b01cc1508a1a4715a91316a7db80d4efa2 100644
---- a/net/minecraft/server/level/ServerEntity.java
-+++ b/net/minecraft/server/level/ServerEntity.java
-@@ -370,7 +370,7 @@ public class ServerEntity {
-             if (!list.isEmpty()) {
-                 consumer.accept(new ClientboundSetEquipmentPacket(this.entity.getId(), list, true)); // Paper - data sanitization
-             }
--            ((LivingEntity) this.entity).detectEquipmentUpdates(); // CraftBukkit - SPIGOT-3789: sync again immediately after sending
-+            if (this.entity.totalEntityAge == 0) ((LivingEntity) this.entity).detectEquipmentUpdates(); // CraftBukkit - SPIGOT-3789: sync again immediately after sending // Leaves - fix chunk reload detector (#492)
-         }
- 
-         if (!this.entity.getPassengers().isEmpty()) {

luminol-server/minecraft-patches/features/0031-Fix-uncorrected-death-check-of-folia.patch

@@ -6,10 +6,10 @@ Subject: [PATCH] Fix uncorrected death check of folia
 In the new mc version, mojang changed some checks in A.C.M(AbstractContainerMenu) and there is a new death check of player which will be executed when player dead.But on folia, player entity cannot be discarded unless they disconnected from the server, so there is an obvious bug that when player dead, the logic depend on that dead check will not be executed correctly because the check logic is still asserting the player is alive by checking if the player is discarded, which caused some exploits can save items in the crafting slots(with InventoryTweaks turned on in meteor client) when keepInventory is set to false
 
 diff --git a/net/minecraft/world/inventory/AbstractContainerMenu.java b/net/minecraft/world/inventory/AbstractContainerMenu.java
-index f4548edae77eb86e54ba499acbb20613fd60d7bd..852b4381985ed167b05881f068e9542c31cdaf23 100644
+index 50af953a4698a3c6e16b840fab764dd733b3fbc9..a9c058238819f3631d94ac306185e909821caf35 100644
 --- a/net/minecraft/world/inventory/AbstractContainerMenu.java
 +++ b/net/minecraft/world/inventory/AbstractContainerMenu.java
-@@ -690,7 +690,7 @@ public abstract class AbstractContainerMenu {
+@@ -679,7 +679,7 @@ public abstract class AbstractContainerMenu {
      }
  
      private static void dropOrPlaceInInventory(Player player, ItemStack stack) {

luminol-server/minecraft-patches/features/0032-Paper-Hopper-behavior-fix.patch

@@ -0,0 +1,23 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 11:03:09 +0800
+Subject: [PATCH] Paper: Hopper behavior fix
+
+temporary fix
+Origin: https://github.com/PaperMC/Paper/pull/11945
+Co-authored by: Aikar <aikar@aikar.co>
+As part of: Paper (https://github.com/PaperMC/Paper/blob/d2d23118c151f11c00e42b5c60ab7e4a3a1be09c/paper-server/patches/features/0029-Optimize-Hoppers.patch)
+Licensed under: MIT (https://github.com/PaperMC/Paper/blob/fa360aa83657d15e8e803ce55800986f6bff8f70/licenses/MIT.md)
+
+diff --git a/net/minecraft/world/level/block/entity/HopperBlockEntity.java b/net/minecraft/world/level/block/entity/HopperBlockEntity.java
+index ae988c4910421fb720177178ef6136e595ae6946..72a81e29be6570fb119b159210453a86f003f893 100644
+--- a/net/minecraft/world/level/block/entity/HopperBlockEntity.java
++++ b/net/minecraft/world/level/block/entity/HopperBlockEntity.java
+@@ -698,6 +698,7 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
+             } else if (canMergeItems(item, stack)) {
+                 int i = Math.min(stack.getMaxStackSize(), destination.getMaxStackSize()) - item.getCount(); // Paper - Make hoppers respect inventory max stack size
+                 int min = Math.min(stack.getCount(), i);
++                stack = stack.copy(true); // Luminol
+                 stack.shrink(min);
+                 item.grow(min);
+                 flag = min > 0;

luminol-server/minecraft-patches/features/0033-Paper-Prevent-zombie-reinforcements-loading-chunks.patch

@@ -9,10 +9,10 @@ As part of: Paper (https://github.com/PaperMC/Paper/blob/2ae1f05336d0f13b646e6c2
 Licensed under: GPL-3.0 (https://github.com/PaperMC/Paper/blob/fa360aa83657d15e8e803ce55800986f6bff8f70/licenses/GPL.md)
 
 diff --git a/net/minecraft/world/entity/monster/Zombie.java b/net/minecraft/world/entity/monster/Zombie.java
-index a23607874a72723914cbfeea0ad1c51236c044d8..14d0758aca54d9a25e369dfa8c89c930f27946c9 100644
+index cf231380febd6d316eb902d43c636135ee0d7fa4..731473610e068a613d67efaee08ded810fe86cf0 100644
 --- a/net/minecraft/world/entity/monster/Zombie.java
 +++ b/net/minecraft/world/entity/monster/Zombie.java
-@@ -352,6 +352,13 @@ public class Zombie extends Monster {
+@@ -348,6 +348,13 @@ public class Zombie extends Monster {
                      int i2 = floor1 + Mth.nextInt(this.random, 7, 40) * Mth.nextInt(this.random, -1, 1);
                      int i3 = floor2 + Mth.nextInt(this.random, 7, 40) * Mth.nextInt(this.random, -1, 1);
                      BlockPos blockPos = new BlockPos(i1, i2, i3);

luminol-server/minecraft-patches/features/0035-Kaiiju-Entity-tick-and-removal-limiter.patch

@@ -8,10 +8,10 @@ As part of: Kaiiju (https://github.com/KaiijuMC/Kaiiju/blob/c2b7aec8f7b418a39a2e
 Licensed under: GPL-3.0 (https://github.com/KaiijuMC/Kaiiju/blob/c2b7aec8f7b418a39a2ec408e6411e6f752379da/LICENSE)
 
 diff --git a/io/papermc/paper/threadedregions/RegionizedWorldData.java b/io/papermc/paper/threadedregions/RegionizedWorldData.java
-index 01ea2e7133a41f1a75169c7e3edbd528b268412b..8c4d89c47fd176d584d3dbd0e3325f69b5e847c3 100644
+index c6e487a4c14e6b82533881d01f32349b9ae28728..2c747cb8a724cd25c9d724908f92b320741600de 100644
 --- a/io/papermc/paper/threadedregions/RegionizedWorldData.java
 +++ b/io/papermc/paper/threadedregions/RegionizedWorldData.java
-@@ -357,6 +357,7 @@ public final class RegionizedWorldData {
+@@ -354,6 +354,7 @@ public final class RegionizedWorldData {
      private final IteratorSafeOrderedReferenceSet<Mob> navigatingMobs = new IteratorSafeOrderedReferenceSet<>();
      public final ReferenceList<Entity> trackerEntities = new ReferenceList<>(EMPTY_ENTITY_ARRAY); // Moonrise - entity tracker
      public final ReferenceList<Entity> trackerUnloadedEntities = new ReferenceList<>(EMPTY_ENTITY_ARRAY); // Moonrise - entity tracker
@@ -20,10 +20,10 @@ index 01ea2e7133a41f1a75169c7e3edbd528b268412b..8c4d89c47fd176d584d3dbd0e3325f69
      // block ticking
      private final ObjectLinkedOpenHashSet<BlockEventData> blockEvents = new ObjectLinkedOpenHashSet<>();
 diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
-index 55f3497503e3317d765abb0bd4a9a620f63cd240..7b7c72f14ae966ef142d68615b2f88ba42a079f5 100644
+index 210eba85ac1a50d993ef6e19b65b9f8afada00ba..2763c3d87ef1f9fcbc01bdff7c0b266d46b8170a 100644
 --- a/net/minecraft/server/level/ServerLevel.java
 +++ b/net/minecraft/server/level/ServerLevel.java
-@@ -807,6 +807,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -808,6 +808,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
              }
  
              profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.ACTIVATE_ENTITIES); try { // Folia - profiler
@@ -31,7 +31,7 @@ index 55f3497503e3317d765abb0bd4a9a620f63cd240..7b7c72f14ae966ef142d68615b2f88ba
              io.papermc.paper.entity.activation.ActivationRange.activateEntities(this); // Paper - EAR
              } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.ACTIVATE_ENTITIES); } // Folia - profiler
              profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.ENTITY_TICK); try { // Folia - profiler
-@@ -828,6 +829,13 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -829,6 +830,13 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
  
                                          entity.stopRiding();
                                      }
@@ -45,7 +45,7 @@ index 55f3497503e3317d765abb0bd4a9a620f63cd240..7b7c72f14ae966ef142d68615b2f88ba
  
                                      profilerFiller.push("tick");
                                      this.guardEntityTick(this::tickNonPassenger, entity);
-@@ -837,6 +845,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -838,6 +846,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
                          }
                      }
                  );

luminol-server/minecraft-patches/features/0036-Kaiiju-Vanilla-end-portal-teleportation.patch

@@ -8,10 +8,10 @@ As part of: Kaiiju (https://github.com/KaiijuMC/Kaiiju/blob/c2b7aec8f7b418a39a2e
 Licensed under: GPL-3.0 (https://github.com/KaiijuMC/Kaiiju/blob/c2b7aec8f7b418a39a2ec408e6411e6f752379da/LICENSE)
 
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index 803cdabbcde93be8352e7370cf1f129f4663d277..e5de7480c2e025fc9a8b4845fdb959049f1afdda 100644
+index 771744d4540fcd163efcde43c27111680b25c928..2efc715857d49f69a8289bcf50f422960c00c8bd 100644
 --- a/net/minecraft/world/entity/Entity.java
 +++ b/net/minecraft/world/entity/Entity.java
-@@ -4475,14 +4475,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4291,14 +4291,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
                          targetPos, 16, // load 16 blocks to be safe from block physics
                          ca.spottedleaf.concurrentutil.util.Priority.HIGH,
                          (chunks) -> {
@@ -34,7 +34,7 @@ index 803cdabbcde93be8352e7370cf1f129f4663d277..e5de7480c2e025fc9a8b4845fdb95904
                                      TeleportTransition.PLAY_PORTAL_SOUND.then(TeleportTransition.PLACE_PORTAL_TICKET),
                                      org.bukkit.event.player.PlayerTeleportEvent.TeleportCause.END_PORTAL
                                  )
-@@ -4508,11 +4512,15 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4313,11 +4317,15 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
                          ca.spottedleaf.concurrentutil.util.Priority.HIGH,
                          (chunks) -> {
                              BlockPos adjustedSpawn = destination.getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, spawnPos);
@@ -52,10 +52,10 @@ index 803cdabbcde93be8352e7370cf1f129f4663d277..e5de7480c2e025fc9a8b4845fdb95904
                                      Relative.union(Relative.DELTA, Relative.ROTATION),
                                      TeleportTransition.PLAY_PORTAL_SOUND.then(TeleportTransition.PLACE_PORTAL_TICKET),
                                      org.bukkit.event.player.PlayerTeleportEvent.TeleportCause.END_PORTAL
-@@ -4709,6 +4717,10 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4495,6 +4503,10 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         if (!this.canPortalAsync(destination, takePassengers)) {
              return false;
          }
-         // Luminol end
 +        // Kaiiju start - sync end platform spawning & entity teleportation
 +        final java.util.function.Consumer<Entity> tpComplete = type == PortalType.END && destination.getTypeKey() == net.minecraft.world.level.dimension.LevelStem.END ?
 +              e -> net.minecraft.world.level.levelgen.feature.EndPlatformFeature.createEndPlatform(destination, ServerLevel.END_SPAWN_POINT.below(), true, null) : teleportComplete;
@@ -63,7 +63,7 @@ index 803cdabbcde93be8352e7370cf1f129f4663d277..e5de7480c2e025fc9a8b4845fdb95904
  
          Vec3 initialPosition = this.position();
          ChunkPos initialPositionChunk = new ChunkPos(
-@@ -4773,8 +4785,12 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4559,9 +4571,14 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
                          info.postTeleportTransition().onTransition(teleported);
                      }
  
@@ -75,5 +75,7 @@ index 803cdabbcde93be8352e7370cf1f129f4663d277..e5de7480c2e025fc9a8b4845fdb95904
 +                    if (tpComplete != null){
 +                        tpComplete.accept(teleported);
                      }
-                     // Kaiiju end
++                    // Kaiiju end
                  }
+             );
+         });

luminol-server/minecraft-patches/features/0037-Petal-Reduce-sensor-work.patch

@@ -8,10 +8,10 @@ As part of: Petal (https://github.com/Bloom-host/Petal/blob/cc691540fb48240f38b3
 Licensed under: GPL-3.0 (https://github.com/Bloom-host/Petal/blob/cc691540fb48240f38b376f3d94c8b0db2b60d99/LICENSE)
 
 diff --git a/net/minecraft/world/entity/Mob.java b/net/minecraft/world/entity/Mob.java
-index d9ee3b56db44687cfcc6a75f44a1abbcc8ef95a9..4c1442410f18b2ebafdb4c4d480f0f59ef656492 100644
+index 94a7b95f41c2954561f9c3cb0f61210c0c058f1d..dbe0fc0c46f66c61a2f286d521302719b28917c1 100644
 --- a/net/minecraft/world/entity/Mob.java
 +++ b/net/minecraft/world/entity/Mob.java
-@@ -753,11 +753,11 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
+@@ -866,11 +866,11 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
              return;
          }
          // Paper end - Allow nerfed mobs to jump and float

luminol-server/minecraft-patches/features/0038-Purpur-Barrels-and-enderchests-6-rows.patch

@@ -0,0 +1,175 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Thu, 20 Feb 2025 01:00:28 +0800
+Subject: [PATCH] Purpur: Barrels and enderchests 6 rows
+
+Co-authored by: William Blake Galbreath <Blake.Galbreath@GMail.com>
+As part of: Purpur (https://github.com/PurpurMC/Purpur/blob/09f547de09fc5d886f18f6d99ff389289766ec9d/purpur-server/minecraft-patches/features/0003-Barrels-and-enderchests-6-rows.patch)
+Licensed under: MIT (https://github.com/PurpurMC/Purpur/blob/09f547de09fc5d886f18f6d99ff389289766ec9d/LICENSE)
+
+diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
+index 751b011701d6ae373099226ea63ffbafcd24ce6a..e5e946462da9e56344428139768075b7bd228ec0 100644
+--- a/net/minecraft/server/players/PlayerList.java
++++ b/net/minecraft/server/players/PlayerList.java
+@@ -1103,6 +1103,10 @@ public abstract class PlayerList {
+         player.getBukkitEntity().recalculatePermissions(); // CraftBukkit
+         this.server.getCommands().sendCommands(player);
+         } // Paper - Add sendOpLevel API
++
++        // Purpur start - Barrels and enderchests 6 rows
++        player.enderChestSlotCount = me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.enderchestRows < 7 && me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.enderchestRows > 0 ? 9 * me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.enderchestRows : 27;
++        // Purpur end - Barrels and enderchests 6 rows
+     }
+ 
+     public boolean isWhiteListed(GameProfile profile) {
+diff --git a/net/minecraft/world/entity/player/Player.java b/net/minecraft/world/entity/player/Player.java
+index ae049c5c3593525b991d865fec695c00ad408a59..c6252a245e9701f69db1fe167f6590095237553a 100644
+--- a/net/minecraft/world/entity/player/Player.java
++++ b/net/minecraft/world/entity/player/Player.java
+@@ -200,6 +200,7 @@ public abstract class Player extends LivingEntity {
+     private int currentImpulseContextResetGraceTime;
+     public boolean affectsSpawning = true; // Paper - Affects Spawning API
+     public net.kyori.adventure.util.TriState flyingFallDamage = net.kyori.adventure.util.TriState.NOT_SET; // Paper - flying fall damage
++    public int enderChestSlotCount = -1; // Purpur - Barrels and enderchests 6 rows
+ 
+     // CraftBukkit start
+     public boolean fauxSleeping;
+diff --git a/net/minecraft/world/inventory/ChestMenu.java b/net/minecraft/world/inventory/ChestMenu.java
+index 280169afbd637eeb67ddf7eaeb4eecd464a128d5..461705345dd897c8304c884272531af836f8854f 100644
+--- a/net/minecraft/world/inventory/ChestMenu.java
++++ b/net/minecraft/world/inventory/ChestMenu.java
+@@ -66,10 +66,30 @@ public class ChestMenu extends AbstractContainerMenu {
+         return new ChestMenu(MenuType.GENERIC_9x6, containerId, playerInventory, 6);
+     }
+ 
++    // Purpur start - Barrels and enderchests 6 rows
++    public static ChestMenu oneRow(int syncId, Inventory playerInventory, Container inventory) {
++        return new ChestMenu(MenuType.GENERIC_9x1, syncId, playerInventory, inventory, 1);
++        }
++
++    public static ChestMenu twoRows(int syncId, Inventory playerInventory, Container inventory) {
++        return new ChestMenu(MenuType.GENERIC_9x2, syncId, playerInventory, inventory, 2);
++        }
++    // Purpur end - Barrels and enderchests 6 rows
++
+     public static ChestMenu threeRows(int containerId, Inventory playerInventory, Container container) {
+         return new ChestMenu(MenuType.GENERIC_9x3, containerId, playerInventory, container, 3);
+     }
+ 
++    // Purpur start - Barrels and enderchests 6 rows
++    public static ChestMenu fourRows(int syncId, Inventory playerInventory, Container inventory) {
++        return new ChestMenu(MenuType.GENERIC_9x4, syncId, playerInventory, inventory, 4);
++    }
++
++    public static ChestMenu fiveRows(int syncId, Inventory playerInventory, Container inventory) {
++        return new ChestMenu(MenuType.GENERIC_9x5, syncId, playerInventory, inventory, 5);
++    }
++    // Purpur end - Barrels and enderchests 6 rows
++
+     public static ChestMenu sixRows(int containerId, Inventory playerInventory, Container container) {
+         return new ChestMenu(MenuType.GENERIC_9x6, containerId, playerInventory, container, 6);
+     }
+diff --git a/net/minecraft/world/inventory/PlayerEnderChestContainer.java b/net/minecraft/world/inventory/PlayerEnderChestContainer.java
+index a6a359bab2a727f4631b633a8bb370dd40decc75..5fab998cdec92a2bd965e6b48cc6189b195dc86d 100644
+--- a/net/minecraft/world/inventory/PlayerEnderChestContainer.java
++++ b/net/minecraft/world/inventory/PlayerEnderChestContainer.java
+@@ -25,11 +25,18 @@ public class PlayerEnderChestContainer extends SimpleContainer {
+     }
+ 
+     public PlayerEnderChestContainer(Player owner) {
+-        super(27);
++        super(me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.enderchestRows < 7 && me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.enderchestRows > 0 ? 9 * me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.enderchestRows : 27);
+         this.owner = owner;
+         // CraftBukkit end
+     }
+ 
++    // Purpur start - Barrels and enderchests 6 rows
++        @Override
++    public int getContainerSize() {
++        return owner.enderChestSlotCount < 0 ? super.getContainerSize() : owner.enderChestSlotCount;
++    }
++    // Purpur end - Barrels and enderchests 6 rows
++
+     public void setActiveChest(EnderChestBlockEntity enderChestBlockEntity) {
+         this.activeChest = enderChestBlockEntity;
+     }
+diff --git a/net/minecraft/world/level/block/EnderChestBlock.java b/net/minecraft/world/level/block/EnderChestBlock.java
+index f5533960708bdbaf2eacefbc7c7c3123b7d26502..bf9801f1370c8d5e6ca459207b221ef2e92dac9e 100644
+--- a/net/minecraft/world/level/block/EnderChestBlock.java
++++ b/net/minecraft/world/level/block/EnderChestBlock.java
+@@ -85,8 +85,14 @@ public class EnderChestBlock extends AbstractChestBlock<EnderChestBlockEntity> i
+                 enderChestInventory.setActiveChest(enderChestBlockEntity); // Needs to happen before ChestMenu.threeRows as it is required for opening animations
+                 if (level instanceof ServerLevel serverLevel && player.openMenu(
+                     new SimpleMenuProvider(
+-                        (containerId, playerInventory, player1) -> ChestMenu.threeRows(containerId, playerInventory, enderChestInventory), CONTAINER_TITLE
+-                    )
++                            (containerId, playerInventory, player1) -> switch (me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.enderchestRows) {
++                    case 6 -> ChestMenu.sixRows(containerId, playerInventory, enderChestInventory);
++                    case 5 -> ChestMenu.fiveRows(containerId, playerInventory, enderChestInventory);
++                    case 4 -> ChestMenu.fourRows(containerId, playerInventory, enderChestInventory);
++                    case 2 -> ChestMenu.twoRows(containerId, playerInventory, enderChestInventory);
++                    case 1 -> ChestMenu.oneRow(containerId, playerInventory, enderChestInventory);
++                    default -> ChestMenu.threeRows(containerId, playerInventory, enderChestInventory);
++                }, CONTAINER_TITLE) // Purpur - Barrels and enderchests 6 rows
+                 ).isPresent()) {
+                 // Paper end - Fix InventoryOpenEvent cancellation - moved up;
+                     player.awardStat(Stats.OPEN_ENDERCHEST);
+diff --git a/net/minecraft/world/level/block/entity/BarrelBlockEntity.java b/net/minecraft/world/level/block/entity/BarrelBlockEntity.java
+index 0f808855f58281578c2758513787f0f7330c9291..5b6ee21c21686dad86717b87c0033149cefad142 100644
+--- a/net/minecraft/world/level/block/entity/BarrelBlockEntity.java
++++ b/net/minecraft/world/level/block/entity/BarrelBlockEntity.java
+@@ -55,7 +55,17 @@ public class BarrelBlockEntity extends RandomizableContainerBlockEntity {
+         this.maxStack = i;
+     }
+     // CraftBukkit end
+-    private NonNullList<ItemStack> items = NonNullList.withSize(27, ItemStack.EMPTY);
++    // Purpur start - Barrels and enderchests 6 rows
++    private NonNullList<ItemStack> items = NonNullList.withSize(switch (me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.barrelRows) {
++        case 6 -> 54;
++        case 5 -> 45;
++        case 4 -> 36;
++        case 2 -> 18;
++        case 1 -> 9;
++        default -> 27;
++        }, ItemStack.EMPTY);
++    // Purpur end - Barrels and enderchests 6 rows
++
+     public final ContainerOpenersCounter openersCounter = new ContainerOpenersCounter() {
+         @Override
+         protected void onOpen(Level level, BlockPos pos, BlockState state) {
+@@ -107,7 +117,16 @@ public class BarrelBlockEntity extends RandomizableContainerBlockEntity {
+ 
+     @Override
+     public int getContainerSize() {
+-        return 27;
++        // Purpur start - Barrels and enderchests 6 rows
++        return switch (me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.barrelRows) {
++            case 6 -> 54;
++            case 5 -> 45;
++            case 4 -> 36;
++            case 2 -> 18;
++            case 1 -> 9;
++            default -> 27;
++        };
++    // Purpur end - Barrels and enderchests 6 rows
+     }
+ 
+     @Override
+@@ -127,7 +146,16 @@ public class BarrelBlockEntity extends RandomizableContainerBlockEntity {
+ 
+     @Override
+     protected AbstractContainerMenu createMenu(int id, Inventory player) {
+-        return ChestMenu.threeRows(id, player, this);
++        // Purpur start - Barrels and enderchests 6 rows
++        return switch (me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.barrelRows) {
++            case 6 -> ChestMenu.sixRows(id, player, this);
++            case 5 -> ChestMenu.fiveRows(id, player, this);
++            case 4 -> ChestMenu.fourRows(id, player, this);
++            case 2 -> ChestMenu.twoRows(id, player, this);
++            case 1 -> ChestMenu.oneRow(id, player, this);
++            default -> ChestMenu.threeRows(id, player, this);
++        };
++        // Purpur end - Barrels and enderchests 6 rows
+     }
+ 
+     @Override

luminol-server/minecraft-patches/features/0039-Purpur-Lobotomize-stuck-villagers.patch

@@ -8,11 +8,11 @@ As part of: Purpur (https://github.com/PurpurMC/Purpur/blob/09f547de09fc5d886f18
 Licensed under: MIT (https://github.com/PurpurMC/Purpur/blob/09f547de09fc5d886f18f6d99ff389289766ec9d/LICENSE)
 
 diff --git a/net/minecraft/world/entity/npc/Villager.java b/net/minecraft/world/entity/npc/Villager.java
-index 3a4d349738aada9c171f01cd695987a21da3785c..6ce3d8c406f7afbc9aa8e0d6577ebf9b4724ae36 100644
+index 7ea74aeb905b95e5919d74df5fbc5e8f7a9985e3..b61da3d0d7d24b674cae155b95f7fab0669f4a20 100644
 --- a/net/minecraft/world/entity/npc/Villager.java
 +++ b/net/minecraft/world/entity/npc/Villager.java
-@@ -197,6 +197,53 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
-         this.setVillagerData(this.getVillagerData().withType(villagerType).withProfession(level.registryAccess(), VillagerProfession.NONE));
+@@ -193,6 +193,53 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+         this.setVillagerData(this.getVillagerData().setType(villagerType).setProfession(VillagerProfession.NONE));
      }
  
 +    // Purpur start
@@ -65,7 +65,7 @@ index 3a4d349738aada9c171f01cd695987a21da3785c..6ce3d8c406f7afbc9aa8e0d6577ebf9b
      @Override
      public Brain<Villager> getBrain() {
          return (Brain<Villager>)super.getBrain();
-@@ -293,11 +340,20 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+@@ -289,11 +336,21 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
          // Paper start - EAR 2
          this.customServerAiStep(level, false);
      }
@@ -74,6 +74,7 @@ index 3a4d349738aada9c171f01cd695987a21da3785c..6ce3d8c406f7afbc9aa8e0d6577ebf9b
          // Paper end - EAR 2
          ProfilerFiller profilerFiller = Profiler.get();
          profilerFiller.push("villagerBrain");
+-        if (!inactive) this.getBrain().tick(level, this); // Paper - EAR 2
 +        // Purpur start
 +        if (me.earthme.luminol.config.modules.optimizations.LobotomizeVillageConfig.villagerLobotomizeEnabled) {
 +            // treat as inactive if lobotomized
@@ -82,8 +83,9 @@ index 3a4d349738aada9c171f01cd695987a21da3785c..6ce3d8c406f7afbc9aa8e0d6577ebf9b
 +            this.isLobotomized = false;
 +        }
 +        // Purpur end
-         if (!inactive) this.getBrain().tick(level, this); // Paper - EAR 2
-+        else if (this.isLobotomized && shouldRestock()) restock(); // Purpur - Lobotomize stuck villagers
++        if (!inactive) {
++            this.getBrain().tick(level, this); // Paper - EAR 2
++        } else if (this.isLobotomized && shouldRestock()) restock(); // Purpur - Lobotomize stuck villagers
          profilerFiller.pop();
          if (this.assignProfessionWhenSpawned) {
              this.assignProfessionWhenSpawned = false;

luminol-server/minecraft-patches/features/0040-Purpur-Use-alternative-keep-alive.patch

@@ -7,10 +7,10 @@ As part of: Purpur (https://github.com/PurpurMC/Purpur/blob/09f547de09fc5d886f18
 Licensed under: MIT (https://github.com/PurpurMC/Purpur/blob/09f547de09fc5d886f18f6d99ff389289766ec9d/LICENSE)
 
 diff --git a/net/minecraft/server/network/ServerCommonPacketListenerImpl.java b/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
-index 62b00aae7d31b79356dec44ce89cf9f2ce9c9bc2..a483d3001e05649ea332f17359218b6e21d9c527 100644
+index 79fe336adf35f4f007461ed050e6301764fe7fc3..a5b805b98cf138eabfb06f4ff202462be60c2995 100644
 --- a/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
 +++ b/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
-@@ -43,6 +43,7 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+@@ -41,6 +41,7 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
      private long keepAliveChallenge;
      private long closedListenerTime;
      private boolean closed = false;
@@ -18,7 +18,7 @@ index 62b00aae7d31b79356dec44ce89cf9f2ce9c9bc2..a483d3001e05649ea332f17359218b6e
      private int latency;
      private volatile boolean suspendFlushingOnServerThread = false;
      // CraftBukkit start
-@@ -132,6 +133,16 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+@@ -130,6 +131,16 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
  
      @Override
      public void handleKeepAlive(ServerboundKeepAlivePacket packet) {
@@ -35,10 +35,11 @@ index 62b00aae7d31b79356dec44ce89cf9f2ce9c9bc2..a483d3001e05649ea332f17359218b6e
          if (this.keepAlivePending && packet.getId() == this.keepAliveChallenge) {
              int i = (int)(Util.getMillis() - this.keepAliveTime);
              this.latency = (this.latency * 3 + i) / 4;
-@@ -262,6 +273,21 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+@@ -254,7 +265,22 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
          // Paper start - give clients a longer time to respond to pings as per pre 1.12.2 timings
          // This should effectively place the keepalive handling back to "as it was" before 1.12.2
          final long elapsedTime = millis - this.keepAliveTime;
+-        if (!this.isSingleplayerOwner() && elapsedTime >= 15000L) { // use vanilla's 15000L between keep alive packets
 +        // Purpur start
 +        if (me.earthme.luminol.config.modules.optimizations.PurpurAlternativeKeepaliveConfig.useAlternateKeepAlive) {
 +            if (elapsedTime >= 1000L) { // 1 second
@@ -54,10 +55,11 @@ index 62b00aae7d31b79356dec44ce89cf9f2ce9c9bc2..a483d3001e05649ea332f17359218b6e
 +            }
 +        } else {
 +
-         if (!this.isSingleplayerOwner() && elapsedTime >= 15000L) { // use vanilla's 15000L between keep alive packets
++            if (!this.isSingleplayerOwner() && elapsedTime >= 15000L) { // use vanilla's 15000L between keep alive packets
              if (this.keepAlivePending) {
                  if (!this.processedDisconnect && elapsedTime >= KEEPALIVE_LIMIT) { // check keepalive limit, don't fire if already disconnected
-@@ -275,6 +301,7 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+                     this.disconnect(TIMEOUT_DISCONNECTION_MESSAGE, org.bukkit.event.player.PlayerKickEvent.Cause.TIMEOUT); // Paper - kick event cause
+@@ -267,6 +293,7 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
                  this.send(new ClientboundKeepAlivePacket(this.keepAliveChallenge));
              }
          }

luminol-server/minecraft-patches/features/0041-Pufferfish-Cache-climbing-check-for-activation.patch

@@ -8,23 +8,23 @@ As part of: Pufferfish (https://github.com/pufferfish-gg/Pufferfish/blob/04bc249
 Licensed under: GPL-3.0 (https://github.com/pufferfish-gg/Pufferfish/blob/04bc249f9eee6157338b6884113b6fa3192bf59b/PATCH-LICENSE)
 
 diff --git a/io/papermc/paper/entity/activation/ActivationRange.java b/io/papermc/paper/entity/activation/ActivationRange.java
-index 328cf3c11c3ad5aa2b92a6c3bd350dd37ce6041a..7e8e67a413ec5d8ca6a0ce54fba884d361acde95 100644
+index c260741a87513b89a5cc62c543fb9f990f86491e..beb9b3b3cd5ca60bd2cdada937bff8a1da639da5 100644
 --- a/io/papermc/paper/entity/activation/ActivationRange.java
 +++ b/io/papermc/paper/entity/activation/ActivationRange.java
-@@ -243,7 +243,7 @@ public final class ActivationRange {
+@@ -225,7 +225,7 @@ public final class ActivationRange {
          }
          // special cases.
          if (entity instanceof final LivingEntity living) {
 -            if (living.onClimbable() || living.jumping || living.hurtTime > 0 || !living.activeEffects.isEmpty() || living.isFreezing()) {
-+            if (living.onClimableCached() || living.onClimbable() || living.jumping || living.hurtTime > 0 || !living.activeEffects.isEmpty() || living.isFreezing()) { // Pufferfish - use cached
++            if ( living.onClimableCached() || living.onClimbable() || living.jumping || living.hurtTime > 0 || !living.activeEffects.isEmpty() || living.isFreezing()) { // Pufferfish - use cached
                  return 1;
              }
              if (entity instanceof final Mob mob && mob.getTarget() != null) {
 diff --git a/net/minecraft/world/entity/LivingEntity.java b/net/minecraft/world/entity/LivingEntity.java
-index cb02249308aa3f94b337a6413bc5b3b178f374f7..19b44e5b5c4c0b7caee7f67420ac4732da52c375 100644
+index 6258b008ad3e00d41e9f3014572d6f7a06b1847c..2293c3db45e9ecce4e0d4b2f87b8e90228e44d94 100644
 --- a/net/minecraft/world/entity/LivingEntity.java
 +++ b/net/minecraft/world/entity/LivingEntity.java
-@@ -2146,6 +2146,20 @@ public abstract class LivingEntity extends Entity implements Attackable, Waypoin
+@@ -2044,6 +2044,20 @@ public abstract class LivingEntity extends Entity implements Attackable {
          return this.lastClimbablePos;
      }
  

luminol-server/minecraft-patches/features/0042-Pufferfish-Reduce-chunk-loading-lookups.patch

@@ -8,10 +8,10 @@ As part of: Pufferfish (https://github.com/pufferfish-gg/Pufferfish/blob/04bc249
 Licensed under: GPL-3.0 (https://github.com/pufferfish-gg/Pufferfish/blob/04bc249f9eee6157338b6884113b6fa3192bf59b/PATCH-LICENSE)
 
 diff --git a/net/minecraft/world/entity/monster/EnderMan.java b/net/minecraft/world/entity/monster/EnderMan.java
-index 4edd94ac765d2ab107612504b67e6e07da609313..c0e38131da55d8a85444ef4248224d37a7271089 100644
+index 4b5ffd278e0e9d47100e5452949e8d757bbfece4..772ccc4dc66253a84a6d24d00e271d9b4916f052 100644
 --- a/net/minecraft/world/entity/monster/EnderMan.java
 +++ b/net/minecraft/world/entity/monster/EnderMan.java
-@@ -296,11 +296,18 @@ public class EnderMan extends Monster implements NeutralMob {
+@@ -309,11 +309,18 @@ public class EnderMan extends Monster implements NeutralMob {
      private boolean teleport(double x, double y, double z) {
          BlockPos.MutableBlockPos mutableBlockPos = new BlockPos.MutableBlockPos(x, y, z);
  

luminol-server/minecraft-patches/features/0043-Gale-Faster-chunk-serialization.patch

@@ -0,0 +1,219 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Bacteriawa <A3167717663@hotmail.com>
+Date: Wed, 30 Nov 2022 21:51:16 +0100
+Subject: [PATCH] Gale: Faster chunk serialization
+
+Co-authored by: Martijn Muijsers <martijnmuijsers@live.nl>, Angeline <jellysquid3@users.noreply.github.com>
+As part of: Gale (https://github.com/GaleMC/Gale/blob/276e903b2688f23b19bdc8d493c0bf87656d2400/patches/server/0096-Faster-chunk-serialization.patch), Lithium (https://github.com/CaffeineMC/lithium-fabric)
+Licensed under: LGPL-3.0 (https://www.gnu.org/licenses/lgpl-3.0.html)
+
+diff --git a/net/minecraft/util/BitStorage.java b/net/minecraft/util/BitStorage.java
+index 02502d50f0255f5bbcc0ecb965abb48cc1a112da..322a1ba06d6aed44ec67dc3f1831ac6b05c82fe0 100644
+--- a/net/minecraft/util/BitStorage.java
++++ b/net/minecraft/util/BitStorage.java
+@@ -21,6 +21,8 @@ public interface BitStorage extends ca.spottedleaf.moonrise.patches.block_counti
+ 
+     BitStorage copy();
+ 
++    <T> void compact(net.minecraft.world.level.chunk.Palette<T> srcPalette, net.minecraft.world.level.chunk.Palette<T> dstPalette, short[] out); // Gale - Lithium - faster chunk serialization
++
+     // Paper start - block counting
+     // provide default impl in case mods implement this...
+     @Override
+diff --git a/net/minecraft/util/SimpleBitStorage.java b/net/minecraft/util/SimpleBitStorage.java
+index e6306a68c8652d4c5d22d5ecb1416f5f931f76ee..2a3d34733b61c73729daa4da61f33e2c2e7b6c72 100644
+--- a/net/minecraft/util/SimpleBitStorage.java
++++ b/net/minecraft/util/SimpleBitStorage.java
+@@ -465,4 +465,36 @@ public class SimpleBitStorage implements BitStorage {
+             super(message);
+         }
+     }
++
++    // Gale start - Lithium - faster chunk serialization
++    @Override
++    public <T> void compact(net.minecraft.world.level.chunk.Palette<T> srcPalette, net.minecraft.world.level.chunk.Palette<T> dstPalette, short[] out) {
++        if (this.size >= Short.MAX_VALUE) throw new IllegalStateException("Array too large");
++        if (this.size != out.length) throw new IllegalStateException("Array size mismatch");
++
++        short[] mappings = new short[(int) (this.mask + 1)];
++
++        int idx = 0;
++
++        for (long word : this.data) {
++            long bits = word;
++
++            for (int elementIdx = 0; elementIdx < this.valuesPerLong; ++elementIdx) {
++                int value = (int) (bits & this.mask);
++                int remappedId = mappings[value];
++
++                if (remappedId == 0) {
++                    remappedId = dstPalette.idFor(srcPalette.valueFor(value)) + 1;
++                    mappings[value] = (short) remappedId;
++                }
++
++                out[idx] = (short) (remappedId - 1);
++                bits >>= this.bits;
++
++                ++idx;
++
++                if (idx >= this.size) return;
++            }
++        }
++    } // Gale end - Lithium - faster chunk serialization
+ }
+diff --git a/net/minecraft/util/ZeroBitStorage.java b/net/minecraft/util/ZeroBitStorage.java
+index 09fd99c9cbd23b5f3c899bfb00c9b89651948ed8..90a85a00c6208d2db65cafb164cd95e6128b6dc4 100644
+--- a/net/minecraft/util/ZeroBitStorage.java
++++ b/net/minecraft/util/ZeroBitStorage.java
+@@ -19,6 +19,8 @@ public class ZeroBitStorage implements BitStorage {
+         return 0;
+     }
+ 
++    @Override public <T> void compact(net.minecraft.world.level.chunk.Palette<T> srcPalette, net.minecraft.world.level.chunk.Palette<T> dstPalette, short[] out) {}  // Gale - Lithium - faster chunk serialization
++
+     @Override
+     public final void set(int index, int value) { // Paper - Perf: Optimize SimpleBitStorage
+         //Validate.inclusiveBetween(0L, (long)(this.size - 1), (long)index); // Paper - Perf: Optimize SimpleBitStorage
+diff --git a/net/minecraft/world/level/chunk/PaletteResize.java b/net/minecraft/world/level/chunk/PaletteResize.java
+index c723606fa0be811e580ba47de8c9c575583cc930..60d3176477c201643e1657751fcffad511b2994f 100644
+--- a/net/minecraft/world/level/chunk/PaletteResize.java
++++ b/net/minecraft/world/level/chunk/PaletteResize.java
+@@ -1,5 +1,5 @@
+ package net.minecraft.world.level.chunk;
+ 
+-interface PaletteResize<T> {
++public interface PaletteResize<T> {  // Gale - Lithium - faster chunk serialization - package -> public
+     int onResize(int bits, T objectAdded);
+ }
+diff --git a/net/minecraft/world/level/chunk/PalettedContainer.java b/net/minecraft/world/level/chunk/PalettedContainer.java
+index f5da433050fd3060e0335d4002d520ebe8cd691f..5a6e699df0a177ea6a919cad609a508678bff823 100644
+--- a/net/minecraft/world/level/chunk/PalettedContainer.java
++++ b/net/minecraft/world/level/chunk/PalettedContainer.java
+@@ -25,6 +25,21 @@ import net.minecraft.util.ThreadingDetector;
+ import net.minecraft.util.ZeroBitStorage;
+ 
+ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainerRO<T> {
++    // Gale start - Lithium - faster chunk serialization
++    private static final ThreadLocal<short[]> CACHED_ARRAY_4096 = ThreadLocal.withInitial(() -> new short[4096]);
++    private static final ThreadLocal<short[]> CACHED_ARRAY_64 = ThreadLocal.withInitial(() -> new short[64]);
++    private Optional<LongStream> asOptional(long[] data) {
++        return Optional.of(Arrays.stream(data));
++    }
++    private short[] getOrCreate(int size) {
++        return switch (size) {
++            case 64 -> CACHED_ARRAY_64.get();
++            case 4096 -> CACHED_ARRAY_4096.get();
++            default -> new short[size];
++        };
++    }
++    // Gale end - Lithium - faster chunk serialization
++
+     private static final int MIN_PALETTE_BITS = 0;
+     private final PaletteResize<T> dummyPaletteResize = (bits, objectAdded) -> 0;
+     public final IdMap<T> registry;
+@@ -344,28 +359,53 @@ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainer
+     public synchronized PalettedContainerRO.PackedData<T> pack(IdMap<T> registry, PalettedContainer.Strategy strategy) { // Paper - synchronize
+         this.acquire();
+ 
+-        PalettedContainerRO.PackedData var12;
++        // Gale start - Lithium - faster chunk serialization
++        Optional<LongStream> data = Optional.empty();
++        List<T> elements = null;
+         try {
+-            HashMapPalette<T> hashMapPalette = new HashMapPalette<>(registry, this.data.storage.getBits(), this.dummyPaletteResize);
+-            int size = strategy.size();
+-            int[] ints = new int[size];
+-            this.data.storage.unpack(ints);
+-            swapPalette(ints, id -> hashMapPalette.idFor(this.data.palette.valueFor(id)));
+-            int i = strategy.calculateBitsForSerialization(registry, hashMapPalette.getSize());
+-            Optional<LongStream> optional;
+-            if (i != 0) {
+-                SimpleBitStorage simpleBitStorage = new SimpleBitStorage(i, size, ints);
+-                optional = Optional.of(Arrays.stream(simpleBitStorage.getRaw()));
+-            } else {
+-                optional = Optional.empty();
++            // The palette that will be serialized
++            net.caffeinemc.mods.lithium.common.world.chunk.LithiumHashPalette<T> hashPalette = null;
++
++            final Palette<T> palette = this.data.palette();
++            final BitStorage storage = this.data.storage();
++            if (storage instanceof ZeroBitStorage || palette.getSize() == 1) {
++                // If the palette only contains one entry, don't attempt to repack it.
++                elements = List.of(palette.valueFor(0));
++            } else if (palette instanceof net.caffeinemc.mods.lithium.common.world.chunk.LithiumHashPalette<T> lithiumHashPalette) {
++                hashPalette = lithiumHashPalette;
+             }
+ 
+-            var12 = new PalettedContainerRO.PackedData<>(hashMapPalette.getEntries(), optional);
++            if (elements == null) {
++                var compactedPalette = new net.caffeinemc.mods.lithium.common.world.chunk.LithiumHashPalette<>(registry, storage.getBits(), this.dummyPaletteResize);
++                short[] array = this.getOrCreate(strategy.size());
++
++                storage.compact(this.data.palette(), compactedPalette, array);
++
++                // If the palette didn't change during compaction, do a simple copy of the data array
++                if (hashPalette != null && hashPalette.getSize() == compactedPalette.getSize() && storage.getBits() == strategy.calculateBitsForSerialization(registry, hashPalette.getSize())) { // paletteSize can de-sync from palette - see https://github.com/CaffeineMC/lithium-fabric/issues/279
++                    data = this.asOptional(storage.getRaw().clone());
++                    elements = hashPalette.getElements();
++                } else {
++                    int bits = strategy.calculateBitsForSerialization(registry, compactedPalette.getSize());
++                    if (bits != 0) {
++                        // Re-pack the integer array as the palette has changed size
++                        SimpleBitStorage copy = new SimpleBitStorage(bits, array.length);
++                        for (int i = 0; i < array.length; ++i)
++                            copy.set(i, array[i]);
++
++                        // We don't need to clone the data array as we are the sole owner of it
++                        data = this.asOptional(copy.getRaw());
++                    }
++
++                    elements = compactedPalette.getElements();
++                }
++            }
+         } finally {
+             this.release();
+         }
+ 
+-        return var12;
++        return new PalettedContainerRO.PackedData<>(elements, data);
++        // Gale end - Lithium - faster chunk serialization
+     }
+ 
+     private static <T> void swapPalette(int[] bits, IntUnaryOperator operator) {
+@@ -405,13 +445,30 @@ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainer
+ 
+     @Override
+     public void count(PalettedContainer.CountConsumer<T> countConsumer) {
+-        if (this.data.palette.getSize() == 1) {
+-            countConsumer.accept(this.data.palette.valueFor(0), this.data.storage.getSize());
+-        } else {
+-            Int2IntOpenHashMap map = new Int2IntOpenHashMap();
+-            this.data.storage.getAll(id -> map.addTo(id, 1));
+-            map.int2IntEntrySet().forEach(idEntry -> countConsumer.accept(this.data.palette.valueFor(idEntry.getIntKey()), idEntry.getIntValue()));
++        // Gale start - Lithium - faster chunk serialization
++        int len = this.data.palette().getSize();
++
++        // Do not allocate huge arrays if we're using a large palette
++        if (len > 4096) {
++            // VanillaCopy
++            if (this.data.palette.getSize() == 1) {
++                countConsumer.accept(this.data.palette.valueFor(0), this.data.storage.getSize());
++            } else {
++                Int2IntOpenHashMap map = new Int2IntOpenHashMap();
++                this.data.storage.getAll(id -> map.addTo(id, 1));
++                map.int2IntEntrySet().forEach(idEntry -> countConsumer.accept(this.data.palette.valueFor(idEntry.getIntKey()), idEntry.getIntValue()));
++            }
++        }
++        short[] counts = new short[len];
++        this.data.storage().getAll(i -> counts[i]++);
++
++        for (int i = 0; i < counts.length; i++) {
++            T obj = this.data.palette().valueFor(i);
++
++            if (obj != null)
++                countConsumer.accept(obj, counts[i]);
+         }
++        // Gale end - Lithium - faster chunk serialization
+     }
+ 
+     record Configuration<T>(Palette.Factory factory, int bits) {

luminol-server/minecraft-patches/features/0044-Gale-Optimize-noise-generation.patch

@@ -3,11 +3,9 @@ From: MrHua269 <wangxyper@163.com>
 Date: Wed, 22 Jan 2025 17:23:16 +0800
 Subject: [PATCH] Gale: Optimize noise generation
 
-Co-authored by: Martijn Muijsers <martijnmuijsers@live.nl>
-ishland <ishlandmc@yeah.net>
-As part of: Gale (https://github.com/GaleMC/Gale/blob/276e903b2688f23b19bdc8d493c0bf87656d2400/patches/server/0106-Optimize-noise-generation.patch)
-C2ME (https://github.com/RelativityMC/C2ME-fabric)
-Licensed under: MIT (https://opensource.org/licenses/MIT)
+Co-authored by: Martijn Muijsers <martijnmuijsers@live.nl>, ishland <ishlandmc@yeah.net>
+As part of: Gale (https://github.com/GaleMC/Gale/blob/276e903b2688f23b19bdc8d493c0bf87656d2400/patches/server/0106-Optimize-noise-generation.patch) and C2ME (https://github.com/RelativityMC/C2ME-fabric)
+Licensed under:  MIT (https://opensource.org/licenses/MIT)
 
 diff --git a/net/minecraft/world/level/levelgen/synth/ImprovedNoise.java b/net/minecraft/world/level/levelgen/synth/ImprovedNoise.java
 index fb11a2eea540d55e50eab59f9857ca5d99f556f8..dcc1a3f8b611c9f103b848db90b077b984b60ada 100644

luminol-server/minecraft-patches/features/0045-Gale-Replace-AI-attributes-with-optimized-collection.patch

@@ -3,20 +3,18 @@ From: MrHua269 <wangxyper@163.com>
 Date: Wed, 22 Jan 2025 17:18:00 +0800
 Subject: [PATCH] Gale: Replace AI attributes with optimized collections
 
-Co-authored by: Martijn Muijsers <martijnmuijsers@live.nl>
-2No2Name <2No2Name@web.de>
-As part of: Gale (https://github.com/GaleMC/Gale/blob/276e903b2688f23b19bdc8d493c0bf87656d2400/patches/server/0087-Replace-AI-attributes-with-optimized-collections.patch)
-Lithium (https://github.com/CaffeineMC/lithium-fabric)
+Co-authored by: Martijn Muijsers <martijnmuijsers@live.nl>, 2No2Name <2No2Name@web.de>
+As part of: Gale (https://github.com/GaleMC/Gale/blob/276e903b2688f23b19bdc8d493c0bf87656d2400/patches/server/0087-Replace-AI-attributes-with-optimized-collections.patch) and Lithium (https://github.com/CaffeineMC/lithium-fabric)
 Licensed under: LGPL-3.0 (https://www.gnu.org/licenses/lgpl-3.0.html)
 
 diff --git a/net/minecraft/world/entity/ai/attributes/AttributeMap.java b/net/minecraft/world/entity/ai/attributes/AttributeMap.java
-index fdb02fc40579866167e8cc9bcefbd961588b53a6..58d8424262db14b2dca0b2c5a40748b6c0c18e83 100644
+index 4c808c7ef336de74048f40bd1cc8b14131a9325d..8dfd32a8ec590c688dc8d64f18b6b59378c17880 100644
 --- a/net/minecraft/world/entity/ai/attributes/AttributeMap.java
 +++ b/net/minecraft/world/entity/ai/attributes/AttributeMap.java
-@@ -14,9 +14,11 @@ import net.minecraft.core.Holder;
- import net.minecraft.resources.ResourceLocation;
+@@ -19,9 +19,11 @@ import org.slf4j.Logger;
  
  public class AttributeMap {
+     private static final Logger LOGGER = LogUtils.getLogger();
 -    private final Map<Holder<Attribute>, AttributeInstance> attributes = new Object2ObjectOpenHashMap<>();
 -    private final Set<AttributeInstance> attributesToSync = new ObjectOpenHashSet<>();
 -    private final Set<AttributeInstance> attributesToUpdate = new ObjectOpenHashSet<>();

luminol-server/minecraft-patches/features/0046-Gale-Skip-entity-move-if-movement-is-zero.patch

@@ -3,19 +3,17 @@ From: MrHua269 <wangxyper@163.com>
 Date: Sun, 12 Jan 2025 15:35:15 +0800
 Subject: [PATCH] Gale: Skip entity move if movement is zero
 
-Co-authored by: Martijn Muijsers <martijnmuijsers@live.nl>
-ishland <ishlandmc@yeah.net>
-As part of: Gale (https://github.com/GaleMC/Gale/blob/276e903b2688f23b19bdc8d493c0bf87656d2400/patches/server/0103-Skip-entity-move-if-movement-is-zero.patch)
-VMP (https://github.com/RelativityMC/VMP-fabric)
+Co-authored by: Martijn Muijsers <martijnmuijsers@live.nl>, ishland <ishlandmc@yeah.net>
+As part of: Gale (https://github.com/GaleMC/Gale/blob/276e903b2688f23b19bdc8d493c0bf87656d2400/patches/server/0103-Skip-entity-move-if-movement-is-zero.patch) and VMP (https://github.com/RelativityMC/VMP-fabric)
 Licensed under: MIT (https://opensource.org/licenses/MIT)
 
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index 50b4a82a054d41ac1439f9769eaefebc103b6d94..803cdabbcde93be8352e7370cf1f129f4663d277 100644
+index 2efc715857d49f69a8289bcf50f422960c00c8bd..18e6e9fe39a559ae043fdafcf4e4db467144e309 100644
 --- a/net/minecraft/world/entity/Entity.java
 +++ b/net/minecraft/world/entity/Entity.java
-@@ -1107,7 +1107,14 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-     private double moveStartZ;
-     // Paper end - detailed watchdog information
+@@ -1104,7 +1104,14 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     private volatile boolean preventMoving = false;
+     //Luminol end
  
 +    private boolean boundingBoxChanged = false; // Gale - VMP - skip entity move if movement is zero
 +
@@ -28,7 +26,7 @@ index 50b4a82a054d41ac1439f9769eaefebc103b6d94..803cdabbcde93be8352e7370cf1f129f
          final Vec3 originalMovement = movement; // Paper - Expose pre-collision velocity
          // Paper start - detailed watchdog information
          ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread("Cannot move an entity off-main");
-@@ -5273,6 +5280,11 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -5061,6 +5068,11 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
      }
  
      public final void setBoundingBox(AABB bb) {

luminol-server/minecraft-patches/features/0047-Gale-Use-platform-math-functions.patch

@@ -3,14 +3,12 @@ From: MrHua269 <wangxyper@163.com>
 Date: Sun, 12 Jan 2025 14:15:24 +0800
 Subject: [PATCH] Gale: Use platform math functions
 
-Co-authored by: Martijn Muijsers <martijnmuijsers@live.nl>
-Xymb <xymb@endcrystal.me>
-As part of: Gale (https://github.com/GaleMC/Gale/blob/276e903b2688f23b19bdc8d493c0bf87656d2400/patches/server/0019-Use-platform-math-functions.patch)
-Kaiiju (https://github.com/KaiijuMC/Kaiiju)
+Co-authored by: Martijn Muijsers <martijnmuijsers@live.nl>, Xymb <xymb@endcrystal.me>
+As part of: Gale (https://github.com/GaleMC/Gale/blob/276e903b2688f23b19bdc8d493c0bf87656d2400/patches/server/0019-Use-platform-math-functions.patch) and Kaiiju(https://github.com/KaiijuMC/Kaiiju)
 Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
 
 diff --git a/net/minecraft/util/Mth.java b/net/minecraft/util/Mth.java
-index 73e04606e2cc5f30377550d1f2a5aa355b173257..c4d5dad5dc02534ef76d65e75e89058ced9699b0 100644
+index d5d8134da9423cec199cf44762460104677194d6..e0eed27cb33348fcb46858c40014b5fe5dbaf426 100644
 --- a/net/minecraft/util/Mth.java
 +++ b/net/minecraft/util/Mth.java
 @@ -58,18 +58,15 @@ public class Mth {

luminol-server/minecraft-patches/features/0048-Gale-Variable-entity-wake-up-duration.patch

@@ -8,10 +8,10 @@ As part of: Gale (https://github.com/GaleMC/Gale/blob/276e903b2688f23b19bdc8d493
 Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
 
 diff --git a/io/papermc/paper/entity/activation/ActivationRange.java b/io/papermc/paper/entity/activation/ActivationRange.java
-index c0d23b0b5adca79ce451da8cca16dc3aeac2c799..328cf3c11c3ad5aa2b92a6c3bd350dd37ce6041a 100644
+index beb9b3b3cd5ca60bd2cdada937bff8a1da639da5..3c9fc433155dd235668ded700d51d95434ba745f 100644
 --- a/io/papermc/paper/entity/activation/ActivationRange.java
 +++ b/io/papermc/paper/entity/activation/ActivationRange.java
-@@ -60,27 +60,39 @@ public final class ActivationRange {
+@@ -54,27 +54,39 @@ public final class ActivationRange {
          if (entity.activationType == ActivationType.VILLAGER) {
              if (inactiveFor > config.wakeUpInactiveVillagersEvery && worldData.wakeupInactiveRemainingVillagers > 0) { // Folia - threaded regions
                  worldData.wakeupInactiveRemainingVillagers--; // Folia - threaded regions

luminol-server/minecraft-patches/features/0049-Fix-entity-portal-teleport-speed.patch

@@ -1,67 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Helvetica Volubi <suisuroru@blue-millennium.fun>
-Date: Sun, 27 Apr 2025 14:26:01 +0800
-Subject: [PATCH] Fix entity portal-teleport speed
-
-
-diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
-index 7b7c72f14ae966ef142d68615b2f88ba42a079f5..87377bba2ebdc0eba5b7b212d971994c35ca0b62 100644
---- a/net/minecraft/server/level/ServerLevel.java
-+++ b/net/minecraft/server/level/ServerLevel.java
-@@ -1364,7 +1364,27 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
-         if (levelChunk != null) levelChunk.getChunkHot().startTicking(); try { // KioCG
-         try {
-         // Folia end - profiler
-+        // Luminol start - Entity portal-teleport speed fix
-         if (isActive) { // Paper - EAR 2
-+            if (!(entity instanceof Player) && entity.teleportTickType == 2) { // Luminol - after portal compensate tick
-+                entity.tick();
-+                entity.tick();
-+                entity.teleportTickType = 0;
-+                if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(entity)) {
-+                    return;
-+                }
-+                if (entity.handlePortal()) {
-+                    return;
-+                }
-+            } else if (!(entity instanceof Player) && entity.teleportTickType == 1) { // Luminol - portal teleport only
-+                entity.teleportTickType++;
-+                if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(entity)) {
-+                    return;
-+                }
-+                if (entity.handlePortal()) {
-+                    return;
-+                }
-+            } else {
-         entity.tick();
-         // Folia start - region threading
-         if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(entity)) {
-@@ -1375,6 +1395,8 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
-             // portalled
-             return;
-         }
-+        }
-+        // Luminol end - Entity portal-teleport speed fix
-         // Folia end - region threading
-         } else {entity.inactiveTick();} // Paper - EAR 2
-         profilerFiller.pop();
-diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index e5de7480c2e025fc9a8b4845fdb959049f1afdda..4d275da5772f90ed460f6aafef483c06b740c702 100644
---- a/net/minecraft/world/entity/Entity.java
-+++ b/net/minecraft/world/entity/Entity.java
-@@ -371,6 +371,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-     public long activatedTick = Integer.MIN_VALUE;
-     public boolean isTemporarilyActive;
-     public long activatedImmunityTick = Integer.MIN_VALUE;
-+    public int teleportTickType = 0;// Luminol - Entity portal-teleport speed fix
- 
-     public void inactiveTick() {
-     }
-@@ -3422,6 +3423,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-         } else {
-             if (this.portalProcess == null || !this.portalProcess.isSamePortal(portal)) {
-                 this.portalProcess = new PortalProcessor(portal, pos.immutable());
-+                this.teleportTickType = 1; // Luminol - Entity portal-teleport speed fix
-             } else if (!this.portalProcess.isInsidePortalThisTick()) {
-                 this.portalProcess.updateEntryPosition(pos.immutable());
-                 this.portalProcess.setAsInsidePortalThisTick(true);

luminol-server/minecraft-patches/features/0049-SparklyPaper-Optimize-canSee-checks.patch

@@ -7,10 +7,10 @@ Co-authored by: MrPowerGamerBR <git@mrpowergamerbr.com>
 As part of: SparklyPaper (https://github.com/SparklyPower/SparklyPaper/blob/a69d3690472c9967772ffd4d4bd1f41403b7ea6f/sparklypaper-server/paper-patches/features/0005-Optimize-canSee-checks.patch)
 
 diff --git a/net/minecraft/server/level/ChunkMap.java b/net/minecraft/server/level/ChunkMap.java
-index 4d603fafd07141a63db22f6e5a544fabbb6b9630..6868b915bf3deb85783a638d4441a15fea6da2dc 100644
+index 5c507be097051de9a43a31bbc6190c3db7688667..7eff847790394aecd058e7a61905da86163b4c6e 100644
 --- a/net/minecraft/server/level/ChunkMap.java
 +++ b/net/minecraft/server/level/ChunkMap.java
-@@ -1294,7 +1294,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+@@ -1224,7 +1224,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
                  }
                  // Folia end - region threading
                  // CraftBukkit start - respect vanish API

luminol-server/minecraft-patches/features/0050-SparklyPaper-Skip-distanceToSqr-call-in-ServerEntity.patch

@@ -8,10 +8,10 @@ Co-authored by: MrPowerGamerBR <git@mrpowergamerbr.com>
 As part of: SparklyPaper (https://github.com/SparklyPower/SparklyPaper/blob/a69d3690472c9967772ffd4d4bd1f41403b7ea6f/sparklypaper-server/minecraft-patches/features/0002-Skip-distanceToSqr-call-in-ServerEntity-sendChanges-.patch)
 
 diff --git a/net/minecraft/server/level/ServerEntity.java b/net/minecraft/server/level/ServerEntity.java
-index 2d4c68b01cc1508a1a4715a91316a7db80d4efa2..3a9293d5328ef0befa0b709169489b61a2266807 100644
+index 0fb253aa55a24b56b17f524b3261c5b75c7d7e59..1de43a4969a2a4535239b15a7bc30d99eb6934c6 100644
 --- a/net/minecraft/server/level/ServerEntity.java
 +++ b/net/minecraft/server/level/ServerEntity.java
-@@ -209,6 +209,8 @@ public class ServerEntity {
+@@ -195,6 +195,8 @@ public class ServerEntity {
  
                  if (this.entity.hasImpulse || this.trackDelta || this.entity instanceof LivingEntity && ((LivingEntity)this.entity).isFallFlying()) {
                      Vec3 deltaMovement = this.entity.getDeltaMovement();
@@ -20,7 +20,7 @@ index 2d4c68b01cc1508a1a4715a91316a7db80d4efa2..3a9293d5328ef0befa0b709169489b61
                      double d = deltaMovement.distanceToSqr(this.lastSentMovement);
                      if (d > 1.0E-7 || d > 0.0 && deltaMovement.lengthSqr() == 0.0) {
                          this.lastSentMovement = deltaMovement;
-@@ -226,6 +228,7 @@ public class ServerEntity {
+@@ -212,6 +214,7 @@ public class ServerEntity {
                              this.broadcast.accept(new ClientboundSetEntityMotionPacket(this.entity.getId(), this.lastSentMovement));
                          }
                      }

luminol-server/minecraft-patches/features/0051-Leaf-Replace-brain-maps-with-optimized-collection.patch

@@ -8,7 +8,7 @@ As part of: Leaf (https://github.com/Winds-Studio/Leaf/blob/7f3e240bbe0970683c40
 Licensed under: MIT (https://github.com/Winds-Studio/Leaf/blob/7f3e240bbe0970683c40279a7a65f0fde47503b6/licenses/MIT.txt)
 
 diff --git a/net/minecraft/world/entity/ai/Brain.java b/net/minecraft/world/entity/ai/Brain.java
-index c589e18b68e45d5991291db3a0bdd833588ce945..ff17bda274989d6b94cea280378a6e5de4f84d4b 100644
+index 52b08be8b37117edc38dddf6d1919178b1f86271..d98eae5ee8a69a89e37751594dfff636831c8016 100644
 --- a/net/minecraft/world/entity/ai/Brain.java
 +++ b/net/minecraft/world/entity/ai/Brain.java
 @@ -45,14 +45,14 @@ public class Brain<E extends LivingEntity> {

luminol-server/minecraft-patches/features/0052-Leaf-Remove-useless-creating-stats-json-bases-on-pla.patch

@@ -9,10 +9,10 @@ As part of: Leaf (https://github.com/Winds-Studio/Leaf/blob/7f3e240bbe0970683c40
 Licensed under: MIT (https://github.com/Winds-Studio/Leaf/blob/7f3e240bbe0970683c40279a7a65f0fde47503b6/licenses/MIT.txt)
 
 diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
-index dd68471549096b86ea82f2add3d3886fb054e78b..b8bd7410e3d5cd8f81f41b52a3a8732134829478 100644
+index e5e946462da9e56344428139768075b7bd228ec0..9777a5b7ba9916e426ba87d6ee7cd56f0e43c195 100644
 --- a/net/minecraft/server/players/PlayerList.java
 +++ b/net/minecraft/server/players/PlayerList.java
-@@ -1418,6 +1418,8 @@ public abstract class PlayerList {
+@@ -1420,6 +1420,8 @@ public abstract class PlayerList {
          if (serverStatsCounter == null) {
              File file = this.server.getWorldPath(LevelResource.PLAYER_STATS_DIR).toFile();
              File file1 = new File(file, uuid + ".json");
@@ -21,7 +21,7 @@ index dd68471549096b86ea82f2add3d3886fb054e78b..b8bd7410e3d5cd8f81f41b52a3a87321
              if (!file1.exists()) {
                  File file2 = new File(file, displayName + ".json"); // CraftBukkit
                  Path path = file2.toPath();
-@@ -1425,6 +1427,8 @@ public abstract class PlayerList {
+@@ -1427,6 +1429,8 @@ public abstract class PlayerList {
                      file2.renameTo(file1);
                  }
              }

luminol-server/minecraft-patches/features/0053-Leaf-Secure-seed-and-matter-seed-command.patch

@@ -8,20 +8,21 @@ As part of: Leaf (https://github.com/Winds-Studio/Leaf/blob/7f3e240bbe0970683c40
 Licensed under: GPL-3.0 (https://github.com/Winds-Studio/Leaf/blob/7f3e240bbe0970683c40279a7a65f0fde47503b6/licenses/GPL-3.0.txt)
 
 diff --git a/net/minecraft/server/commands/SeedCommand.java b/net/minecraft/server/commands/SeedCommand.java
-index 7c1e18d8362be5ae885c32b05e98b9ef45942d93..eb77dd6c009a0121e03a4041761dd2d69adcdfe9 100644
+index a65affc41a4fc299bc2281f0f53f2e075633899d..f071e469468b768bd9c063d78c222b1b3e3b13bd 100644
 --- a/net/minecraft/server/commands/SeedCommand.java
 +++ b/net/minecraft/server/commands/SeedCommand.java
-@@ -12,6 +12,16 @@ public class SeedCommand {
-             long seed = commandContext.getSource().getLevel().getSeed();
+@@ -12,6 +12,17 @@ public class SeedCommand {
+             long seed = context.getSource().getLevel().getSeed();
              Component component = ComponentUtils.copyOnClickText(String.valueOf(seed));
-             commandContext.getSource().sendSuccess(() -> Component.translatable("commands.seed.success", component), false);
+             context.getSource().sendSuccess(() -> Component.translatable("commands.seed.success", component), false);
++
 +            // Leaf start - Matter - SecureSeed Command
 +            if (me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled) {
-+                su.plo.matter.Globals.setupGlobals(commandContext.getSource().getLevel());
++                su.plo.matter.Globals.setupGlobals(context.getSource().getLevel());
 +                String seedStr = su.plo.matter.Globals.seedToString(su.plo.matter.Globals.worldSeed);
 +                Component featureSeedComponent = ComponentUtils.copyOnClickText(seedStr);
 +
-+                commandContext.getSource().sendSuccess(() -> Component.translatable(("Feature seed: %s"), featureSeedComponent), false);
++                context.getSource().sendSuccess(() -> Component.translatable(("Feature seed: %s"), featureSeedComponent), false);
 +            }
 +            // Leaf end - Matter - SecureSeed Command
 +
@@ -29,10 +30,10 @@ index 7c1e18d8362be5ae885c32b05e98b9ef45942d93..eb77dd6c009a0121e03a4041761dd2d6
          }));
      }
 diff --git a/net/minecraft/server/dedicated/DedicatedServerProperties.java b/net/minecraft/server/dedicated/DedicatedServerProperties.java
-index 4a01088da91fc6d620cb804a9ab6d6eb1630b473..3360d691cfdb8f83d6e396c83aeaa9e809d7e8db 100644
+index f6518e29f805018c72222f5aaa7b662071665b65..8d082996a0f361cfd12af6a2138efd7057732fc8 100644
 --- a/net/minecraft/server/dedicated/DedicatedServerProperties.java
 +++ b/net/minecraft/server/dedicated/DedicatedServerProperties.java
-@@ -115,7 +115,17 @@ public class DedicatedServerProperties extends Settings<DedicatedServerPropertie
+@@ -113,7 +113,17 @@ public class DedicatedServerProperties extends Settings<DedicatedServerPropertie
          String string = this.get("level-seed", "");
          boolean flag = this.get("generate-structures", true);
          long l = WorldOptions.parseSeed(string).orElse(WorldOptions.randomSeed());
@@ -52,10 +53,10 @@ index 4a01088da91fc6d620cb804a9ab6d6eb1630b473..3360d691cfdb8f83d6e396c83aeaa9e8
              this.get("generator-settings", property -> GsonHelper.parse(!property.isEmpty() ? property : "{}"), new JsonObject()),
              this.get("level-type", property -> property.toLowerCase(Locale.ROOT), WorldPresets.NORMAL.location().toString())
 diff --git a/net/minecraft/server/level/ServerChunkCache.java b/net/minecraft/server/level/ServerChunkCache.java
-index 250d09fe3c49d1d0cbfde0fc06abd16fe329f9ed..05bad0366bd36b8134290a0cceb4d4dfcbbd0544 100644
+index ac06b8a4813716a8d136be5731cbd96113976a7e..82d95005fc67336458b50c47d44ec4047fffcd1e 100644
 --- a/net/minecraft/server/level/ServerChunkCache.java
 +++ b/net/minecraft/server/level/ServerChunkCache.java
-@@ -674,6 +674,7 @@ public class ServerChunkCache extends ChunkSource implements ca.spottedleaf.moon
+@@ -680,6 +680,7 @@ public class ServerChunkCache extends ChunkSource implements ca.spottedleaf.moon
      }
  
      public ChunkGenerator getGenerator() {
@@ -64,10 +65,10 @@ index 250d09fe3c49d1d0cbfde0fc06abd16fe329f9ed..05bad0366bd36b8134290a0cceb4d4df
      }
  
 diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
-index 00482efc8e736e73ad136105ad7b9dd2cafd581f..55f3497503e3317d765abb0bd4a9a620f63cd240 100644
+index 2763c3d87ef1f9fcbc01bdff7c0b266d46b8170a..0cec31be4733ad330b09e3d2e81c696c396cac3c 100644
 --- a/net/minecraft/server/level/ServerLevel.java
 +++ b/net/minecraft/server/level/ServerLevel.java
-@@ -567,6 +567,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -620,6 +620,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
              chunkGenerator = new org.bukkit.craftbukkit.generator.CustomChunkGenerator(this, chunkGenerator, gen);
          }
          // CraftBukkit end
@@ -76,14 +77,14 @@ index 00482efc8e736e73ad136105ad7b9dd2cafd581f..55f3497503e3317d765abb0bd4a9a620
          DataFixer fixerUpper = server.getFixerUpper();
          // Paper - rewrite chunk system
 diff --git a/net/minecraft/world/entity/monster/Slime.java b/net/minecraft/world/entity/monster/Slime.java
-index 7b9105cc38380d60892647e52608787dbde28f0d..88c1880947cd9d8b3952cce3f8f3ae04ce047968 100644
+index 8db4cba1be6d7a5538295ba8da1fdaf7a77a16d0..25ef938623e2e4f65f6554731b756995638e4231 100644
 --- a/net/minecraft/world/entity/monster/Slime.java
 +++ b/net/minecraft/world/entity/monster/Slime.java
-@@ -329,7 +329,12 @@ public class Slime extends Mob implements Enemy {
+@@ -340,7 +340,12 @@ public class Slime extends Mob implements Enemy {
              }
  
              ChunkPos chunkPos = new ChunkPos(pos);
--            boolean flag = level.getMinecraftWorld().paperConfig().entities.spawning.allChunksAreSlimeChunks || WorldgenRandom.seedSlimeChunk(chunkPos.x, chunkPos.z, ((WorldGenLevel) level).getSeed(), level.getMinecraftWorld().spigotConfig.slimeSeed).nextInt(10) == 0; // Paper
+-            boolean flag = level.getMinecraftWorld().paperConfig().entities.spawning.allChunksAreSlimeChunks || WorldgenRandom.seedSlimeChunk(chunkPos.x, chunkPos.z, ((WorldGenLevel) level).getSeed(), level.getMinecraftWorld().spigotConfig.slimeSeed).nextInt(10) == 0; // Spigot // Paper
 +            // Leaf start - Matter - Secure Seed
 +            boolean isSlimeChunk = me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled
 +                ? level.getChunk(chunkPos.x, chunkPos.z).isSlimeChunk()
@@ -94,10 +95,10 @@ index 7b9105cc38380d60892647e52608787dbde28f0d..88c1880947cd9d8b3952cce3f8f3ae04
                  final double maxHeightSlimeChunk = level.getMinecraftWorld().paperConfig().entities.spawning.slimeSpawnHeight.slimeChunk.maximum;
                  if (random.nextInt(10) == 0 && flag && pos.getY() < maxHeightSlimeChunk) {
 diff --git a/net/minecraft/world/level/chunk/ChunkAccess.java b/net/minecraft/world/level/chunk/ChunkAccess.java
-index 182c14b660f8860bed627eed4e01fd4002153e9a..686c031ec73acc80683aaa39a78fe9221f0215a6 100644
+index 6d565b52552534ce9cacfc35ad1bf4adcb69eac3..3a6db5bc0c8be7d68e15317a621c1965fdc3a9bd 100644
 --- a/net/minecraft/world/level/chunk/ChunkAccess.java
 +++ b/net/minecraft/world/level/chunk/ChunkAccess.java
-@@ -88,6 +88,10 @@ public abstract class ChunkAccess implements BiomeManager.NoiseBiomeSource, Ligh
+@@ -87,6 +87,10 @@ public abstract class ChunkAccess implements BiomeManager.NoiseBiomeSource, Ligh
      public org.bukkit.craftbukkit.persistence.DirtyCraftPersistentDataContainer persistentDataContainer = new org.bukkit.craftbukkit.persistence.DirtyCraftPersistentDataContainer(ChunkAccess.DATA_TYPE_REGISTRY);
      // CraftBukkit end
      public final Registry<Biome> biomeRegistry; // CraftBukkit
@@ -108,7 +109,7 @@ index 182c14b660f8860bed627eed4e01fd4002153e9a..686c031ec73acc80683aaa39a78fe922
  
      // Paper start - rewrite chunk system
      private volatile ca.spottedleaf.moonrise.patches.starlight.light.SWMRNibbleArray[] blockNibbles;
-@@ -192,6 +196,17 @@ public abstract class ChunkAccess implements BiomeManager.NoiseBiomeSource, Ligh
+@@ -191,6 +195,17 @@ public abstract class ChunkAccess implements BiomeManager.NoiseBiomeSource, Ligh
          return GameEventListenerRegistry.NOOP;
      }
  
@@ -124,13 +125,13 @@ index 182c14b660f8860bed627eed4e01fd4002153e9a..686c031ec73acc80683aaa39a78fe922
 +    // Leaf end - Matter - Secure Seed
 +
      public abstract BlockState getBlockState(final int x, final int y, final int z); // Paper
- 
      @Nullable
+     public abstract BlockState setBlockState(BlockPos pos, BlockState state, boolean isMoving);
 diff --git a/net/minecraft/world/level/chunk/ChunkGenerator.java b/net/minecraft/world/level/chunk/ChunkGenerator.java
-index a7b0a9f9e7bb8918abc631eed0043f834646fa04..7664edaf958363701438311aa9fa3bc9f2a30874 100644
+index b85c547f281c58bf45c9062d0b886cb4ff7b386b..55df64f9069496010841bfc373887d27fc5c2162 100644
 --- a/net/minecraft/world/level/chunk/ChunkGenerator.java
 +++ b/net/minecraft/world/level/chunk/ChunkGenerator.java
-@@ -342,7 +342,11 @@ public abstract class ChunkGenerator {
+@@ -343,7 +343,11 @@ public abstract class ChunkGenerator {
              Registry<Structure> registry = level.registryAccess().lookupOrThrow(Registries.STRUCTURE);
              Map<Integer, List<Structure>> map = registry.stream().collect(Collectors.groupingBy(structure1 -> structure1.step().ordinal()));
              List<FeatureSorter.StepFeatureData> list = this.featuresPerStep.get();
@@ -143,7 +144,7 @@ index a7b0a9f9e7bb8918abc631eed0043f834646fa04..7664edaf958363701438311aa9fa3bc9
              long l = worldgenRandom.setDecorationSeed(level.getSeed(), blockPos.getX(), blockPos.getZ());
              Set<Holder<Biome>> set = new ObjectArraySet<>();
              ChunkPos.rangeClosed(sectionPos.chunk(), 1).forEach(chunkPos -> {
-@@ -551,8 +555,15 @@ public abstract class ChunkGenerator {
+@@ -556,8 +560,15 @@ public abstract class ChunkGenerator {
                          } else {
                              ArrayList<StructureSet.StructureSelectionEntry> list1 = new ArrayList<>(list.size());
                              list1.addAll(list);
@@ -325,7 +326,7 @@ index c92508741439a8d0d833ea02d0104416adb83c92..a4063fe0c8e113f0fbd751b84aefaaad
      public static OptionalLong parseSeed(String seed) {
          seed = seed.trim();
 diff --git a/net/minecraft/world/level/levelgen/feature/GeodeFeature.java b/net/minecraft/world/level/levelgen/feature/GeodeFeature.java
-index 4e72eb49dbf4c70ae7556ba6eb210fcd5ef36aaa..4404211177c7a0595851c1ca01d2aa5758f625c9 100644
+index 38475f6975533909924c8d54f438cf43cdfe31a3..db58fa5d2ee42711ae5ab8b7384fccdfe756e2dc 100644
 --- a/net/minecraft/world/level/levelgen/feature/GeodeFeature.java
 +++ b/net/minecraft/world/level/levelgen/feature/GeodeFeature.java
 @@ -41,7 +41,11 @@ public class GeodeFeature extends Feature<GeodeConfiguration> {
@@ -380,10 +381,10 @@ index ee0d9dddb36b6879fa113299e24f1aa3b2b151cc..8a93a4eb0a4935af169ff4d4108a8c6e
          int i3 = this.spreadType.evaluate(worldgenRandom, i2);
          int i4 = this.spreadType.evaluate(worldgenRandom, i2);
 diff --git a/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java b/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java
-index 1f939b325ec5291b3c4aabc4735c863f9436a6f8..e5ed4c9d59b880968cedd49d5b415c4eb22d02be 100644
+index 670335a7bbfbc9da64c389977498c22dfcd03251..d684a7c8e6455a9154b16e2c8bca5217cd1f597a 100644
 --- a/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java
 +++ b/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java
-@@ -119,8 +119,16 @@ public abstract class StructurePlacement {
+@@ -118,8 +118,16 @@ public abstract class StructurePlacement {
      public abstract StructurePlacementType<?> type();
  
      private static boolean probabilityReducer(long levelSeed, int regionX, int regionZ, int salt, float probability, @org.jetbrains.annotations.Nullable Integer saltOverride) { // Paper - Add missing structure set seed configs; ignore here
@@ -403,7 +404,7 @@ index 1f939b325ec5291b3c4aabc4735c863f9436a6f8..e5ed4c9d59b880968cedd49d5b415c4e
      }
  
 diff --git a/net/minecraft/world/level/levelgen/structure/pools/JigsawPlacement.java b/net/minecraft/world/level/levelgen/structure/pools/JigsawPlacement.java
-index 1cfa0fcd28685736fcdce4aef817e4d4cc4061cb..307999350819dfbc31cfd32438b7711a4f6d1467 100644
+index eb85edaa3b7fab4f11545b0fa8bfea882dedb67d..a5b8abc06adbfcbffccfc005a625b952d8729470 100644
 --- a/net/minecraft/world/level/levelgen/structure/pools/JigsawPlacement.java
 +++ b/net/minecraft/world/level/levelgen/structure/pools/JigsawPlacement.java
 @@ -64,7 +64,11 @@ public class JigsawPlacement {

luminol-server/minecraft-patches/features/0054-Add-missing-teleportation-apis-for-folia.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Add missing teleportation apis for folia
 
 
 diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
-index 4e3c545f6121d3846d81d776c29edc42d6204f5c..2b06a0fba825199b07febf368418af803d8c3f8c 100644
+index b5d0eb5026067080a376b9c3f902dcdf40d5dc48..62634b5c29a3333fd8f39927f4d0a3258835c891 100644
 --- a/net/minecraft/server/level/ServerPlayer.java
 +++ b/net/minecraft/server/level/ServerPlayer.java
-@@ -1701,6 +1701,9 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+@@ -1666,6 +1666,9 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
                      if (respawnComplete != null) {
                          respawnComplete.accept(ServerPlayer.this);
                      }
@@ -19,10 +19,10 @@ index 4e3c545f6121d3846d81d776c29edc42d6204f5c..2b06a0fba825199b07febf368418af80
              );
          });
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index f5f03801da03089ea1d22de1012d90a2b7b17322..50b4a82a054d41ac1439f9769eaefebc103b6d94 100644
+index 18e6e9fe39a559ae043fdafcf4e4db467144e309..2ea6160492cb23e96271dfbfd3bd35fe03109d6a 100644
 --- a/net/minecraft/world/entity/Entity.java
 +++ b/net/minecraft/world/entity/Entity.java
-@@ -4310,6 +4310,31 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4175,6 +4175,31 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
          }
  
          // TODO any events that can modify go HERE
@@ -54,7 +54,7 @@ index f5f03801da03089ea1d22de1012d90a2b7b17322..50b4a82a054d41ac1439f9769eaefebc
  
          // check for same region
          if (destination == this.level()) {
-@@ -4426,7 +4451,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4292,7 +4317,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
              // we just select the spawn position
              case END: {
                  if (destination.getTypeKey() == net.minecraft.world.level.dimension.LevelStem.END) {
@@ -74,7 +74,7 @@ index f5f03801da03089ea1d22de1012d90a2b7b17322..50b4a82a054d41ac1439f9769eaefebc
                      // need to load chunks so we can create the platform
                      destination.moonrise$loadChunksAsync(
                          targetPos, 16, // load 16 blocks to be safe from block physics
-@@ -4447,7 +4483,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4317,7 +4353,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
                          }
                      );
                  } else {
@@ -94,7 +94,7 @@ index f5f03801da03089ea1d22de1012d90a2b7b17322..50b4a82a054d41ac1439f9769eaefebc
                      // need to load chunk for heightmap
                      destination.moonrise$loadChunksAsync(
                          spawnPos, 0,
-@@ -4498,8 +4545,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4372,8 +4419,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
  
                  WorldBorder destinationBorder = destination.getWorldBorder();
                  double dimensionScale = net.minecraft.world.level.dimension.DimensionType.getTeleportationScale(origin.dimensionType(), destination.dimensionType());
@@ -114,7 +114,7 @@ index f5f03801da03089ea1d22de1012d90a2b7b17322..50b4a82a054d41ac1439f9769eaefebc
                  ca.spottedleaf.concurrentutil.completable.CallbackCompletable<BlockUtil.FoundRectangle> portalFound
                      = new ca.spottedleaf.concurrentutil.completable.CallbackCompletable<>();
  
-@@ -4636,6 +4693,15 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4510,9 +4567,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
          if (!this.canPortalAsync(destination, takePassengers)) {
              return false;
          }
@@ -127,19 +127,25 @@ index f5f03801da03089ea1d22de1012d90a2b7b17322..50b4a82a054d41ac1439f9769eaefebc
 +            return false;
 +        }
 +        // Luminol end
+         // Kaiiju start - sync end platform spawning & entity teleportation
+         final java.util.function.Consumer<Entity> tpComplete = type == PortalType.END && destination.getTypeKey() == net.minecraft.world.level.dimension.LevelStem.END ?
+-              e -> net.minecraft.world.level.levelgen.feature.EndPlatformFeature.createEndPlatform(destination, ServerLevel.END_SPAWN_POINT.below(), true, null) : teleportComplete;
++              e -> { if (new me.earthme.luminol.api.portal.EndPlatformCreateEvent().callEvent() && ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(e.level, ServerLevel.END_SPAWN_POINT.below())) net.minecraft.world.level.levelgen.feature.EndPlatformFeature.createEndPlatform(destination, ServerLevel.END_SPAWN_POINT.below(), true, null); } : teleportComplete; // Luminol - Add missing teleportation events & Fix teleportation api threading issue
+         // Kaiiju end
  
          Vec3 initialPosition = this.position();
-         ChunkPos initialPositionChunk = new ChunkPos(
-@@ -4703,6 +4769,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-                     if (teleportComplete != null) {
-                         teleportComplete.accept(teleported);
+@@ -4586,6 +4652,9 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+                         tpComplete.accept(teleported);
                      }
-+                    // Kaiiju end
+                     // Kaiiju end
++                    // Luminol start - Add missing teleportation events
++                    new me.earthme.luminol.api.entity.PostEntityPortalEvent(teleported.getBukkitEntity()).callEvent();
++                    // Luminol end
                  }
              );
          });
 diff --git a/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java b/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
-index 12b9a6c16501cb0c01983c44bb247071ce675274..2dbf5064f0353b5d60d75573dc9724c3c42a25fe 100644
+index 95e2dff6782bf7767ecb1a23e618862919ea71aa..386c38273e21ba6b48f9fad67fddc39255138e14 100644
 --- a/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
 +++ b/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
 @@ -193,6 +193,18 @@ public class TheEndGatewayBlockEntity extends TheEndPortalBlockEntity {

luminol-server/minecraft-patches/features/0054-Do-not-fire-pre-creature-spawn-event-unless-some-plu.patch

@@ -1,39 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MrHua269 <mrhua269@gmail.com>
-Date: Sun, 15 Jun 2025 16:58:05 +0800
-Subject: [PATCH] Do not fire pre creature spawn event unless some plugin is
- listening it
-
-
-diff --git a/net/minecraft/world/level/NaturalSpawner.java b/net/minecraft/world/level/NaturalSpawner.java
-index f324a74a191d3fe3e270556d07c4543ec34e0195..2fb36cba4cda3f7b84efae9cba6bed2394fb0457 100644
---- a/net/minecraft/world/level/NaturalSpawner.java
-+++ b/net/minecraft/world/level/NaturalSpawner.java
-@@ -360,16 +360,18 @@ public final class NaturalSpawner {
-     ) {
-         EntityType<?> entityType = data.type();
-         // Paper start - PreCreatureSpawnEvent
--        com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent event = new com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent(
--                org.bukkit.craftbukkit.util.CraftLocation.toBukkit(pos, level),
--                org.bukkit.craftbukkit.entity.CraftEntityType.minecraftToBukkit(entityType), org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL
--        );
--        if (!event.callEvent()) {
--            if (event.shouldAbortSpawn()) {
--                return PreSpawnStatus.ABORT;
-+        if (com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent.getHandlerList().getRegisteredListeners().length != 0) { // Luminol - Do not fire pre creature spawn event unless some plugin is listening it
-+            com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent event = new com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent(
-+                    org.bukkit.craftbukkit.util.CraftLocation.toBukkit(pos, level),
-+                    org.bukkit.craftbukkit.entity.CraftEntityType.minecraftToBukkit(entityType), org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL
-+            );
-+            if (!event.callEvent()) {
-+                if (event.shouldAbortSpawn()) {
-+                    return PreSpawnStatus.ABORT;
-+                }
-+                return PreSpawnStatus.CANCELLED;
-             }
--            return PreSpawnStatus.CANCELLED;
--        }
-+        } // Luminol - Do not fire pre creature spawn event unless some plugin is listening it
-         final boolean success = entityType.getCategory() != MobCategory.MISC
-         // Paper end - PreCreatureSpawnEvent
-             && (

luminol-server/minecraft-patches/features/0055-Cpu-affinity.patch

@@ -1,36 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: HaHaWTH <102713261+HaHaWTH@users.noreply.github.com>
-Date: Tue, 9 Nov 2077 00:00:00 +0800
-Subject: [PATCH] Cpu affinity
-
-
-diff --git a/io/papermc/paper/threadedregions/TickRegionScheduler.java b/io/papermc/paper/threadedregions/TickRegionScheduler.java
-index fa6b8d756195c1b430cc11214a901bd42eebc98d..0357792de0ed8ec9058d1847c8b45c33ff365af6 100644
---- a/io/papermc/paper/threadedregions/TickRegionScheduler.java
-+++ b/io/papermc/paper/threadedregions/TickRegionScheduler.java
-@@ -49,6 +49,25 @@ public final class TickRegionScheduler {
- 
-             @Override
-             public Thread newThread(final Runnable run) {
-+                // Luminol start - cpu affinity
-+                if (me.earthme.luminol.config.modules.misc.CpuAffinityConfig.cpuAffinityEnabled) {
-+                    Runnable affinityRunnable = new Runnable() {
-+                        private boolean affinitySet = false;
-+
-+                        @Override
-+                        public void run() {
-+                            if (!this.affinitySet) {
-+                                this.affinitySet = true;
-+                                net.openhft.affinity.Affinity.setAffinity(me.earthme.luminol.config.modules.misc.CpuAffinityConfig.tickRegionAffinityBitSet);
-+                            }
-+                            run.run();
-+                        }
-+                    };
-+                    final Thread ret = new TickThreadRunner(affinityRunnable, "Region Scheduler Thread #" + this.idGenerator.getAndIncrement());
-+                    ret.setUncaughtExceptionHandler(TickRegionScheduler.this::uncaughtException);
-+                    return ret;
-+                }
-+                // Luminol end - cpu affinity
-                 final Thread ret = new TickThreadRunner(run, "Region Scheduler Thread #" + this.idGenerator.getAndIncrement());
-                 ret.setUncaughtExceptionHandler(TickRegionScheduler.this::uncaughtException);
-                 return ret;

luminol-server/minecraft-patches/features/0055-Portal-Behavior-Modifiers.patch

@@ -0,0 +1,142 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Sun, 27 Apr 2025 14:26:01 +0800
+Subject: [PATCH] Portal Behavior Modifiers
+
+
+diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
+index 0cec31be4733ad330b09e3d2e81c696c396cac3c..de3042c1cad21c55b19ed12da0f4cbd99068540f 100644
+--- a/net/minecraft/server/level/ServerLevel.java
++++ b/net/minecraft/server/level/ServerLevel.java
+@@ -1353,7 +1353,26 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+         if (levelChunk != null) levelChunk.getChunkHot().startTicking(); try { // KioCG
+         try {
+         // Folia end - profiler
++        // Luminol start - Entity portal-teleport speed fix
+         if (isActive) { // Paper - EAR 2
++            if (!(entity instanceof Player) && entity.flag_portal && entity.flag_compensate_ticks) { // Luminol - after portal compensate tick
++                entity.tick();
++                entity.tick();
++                entity.flag_compensate_ticks = false;
++                if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(entity)) {
++                    return;
++                }
++                if (entity.handlePortal()) {
++                    return;
++                }
++            } else if (!(entity instanceof Player) && entity.flag_portal) { // Luminol - portal teleport only
++                if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(entity)) {
++                    return;
++                }
++                if (entity.handlePortal()) {
++                    return;
++                }
++            } else {
+         entity.tick();
+         // Folia start - region threading
+         if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(entity)) {
+@@ -1364,6 +1383,8 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+             // portalled
+             return;
+         }
++        }
++        // Luminol end - Entity portal-teleport speed fix
+         // Folia end - region threading
+         } else {entity.inactiveTick();} // Paper - EAR 2
+         profilerFiller.pop();
+diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
+index 2ea6160492cb23e96271dfbfd3bd35fe03109d6a..97879ba5080db09dde7cd76fe7b0ba502d8df572 100644
+--- a/net/minecraft/world/entity/Entity.java
++++ b/net/minecraft/world/entity/Entity.java
+@@ -343,6 +343,10 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     public long activatedTick = Integer.MIN_VALUE;
+     public boolean isTemporarilyActive;
+     public long activatedImmunityTick = Integer.MIN_VALUE;
++    // Luminol start - Entity portal-teleport speed fix
++    public boolean flag_portal = false;
++    public boolean flag_compensate_ticks = false;
++    // Luminol end - Entity portal-teleport speed fix
+ 
+     public void inactiveTick() {
+     }
+@@ -3305,6 +3309,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         } else {
+             if (this.portalProcess == null || !this.portalProcess.isSamePortal(portal)) {
+                 this.portalProcess = new PortalProcessor(portal, pos.immutable());
++                this.flag_portal = true; // Luminol - Entity portal-teleport speed fix
+             } else if (!this.portalProcess.isInsidePortalThisTick()) {
+                 this.portalProcess.updateEntryPosition(pos.immutable());
+                 this.portalProcess.setAsInsidePortalThisTick(true);
+@@ -3829,20 +3834,27 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+ 
+             EntityTreeNode curr;
+             while ((curr = queue.pollFirst()) != null) {
+-                EntityTreeNode[] passengers = curr.passengers;
++                restore(curr); // Luminol - EndGateway Portal Passengers Fix
++            }
++        }
++
++        // Luminol Start - EndGateway Portal Passengers Fix
++        private EntityTreeNode[] restore(EntityTreeNode entity) {
++                EntityTreeNode[] passengers = entity.passengers;
+                 if (passengers == null) {
+-                    continue;
++                    return null;
+                 }
+ 
+                 List<Entity> newPassengers = new java.util.ArrayList<>();
+                 for (EntityTreeNode passenger : passengers) {
++                    passenger.passengers = restore(passenger);
+                     newPassengers.add(passenger.root);
+-                    passenger.root.vehicle = curr.root;
++                    passenger.root.vehicle = entity.root;
+                 }
+-
+-                curr.root.passengers = ImmutableList.copyOf(newPassengers);
+-            }
++                entity.root.passengers = ImmutableList.copyOf(newPassengers);
++                return passengers;
+         }
++        // Luminol End - EndGateway Portal Passengers Fix
+ 
+         public void addTracker() {
+             for (final EntityTreeNode node : this.getFullTree()) {
+@@ -4561,6 +4573,13 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+ 
+     }
+ 
++    // Luminol start - Add afterPortalLogic
++    protected void afterPortalLogic() {
++        this.flag_compensate_ticks  = true; // Luminol - Entity portal-teleport speed fix
++        this.flag_portal = false; // Luminol - Entity portal-teleport speed fix
++    }
++    // Luminol end - Add afterPortalLogic
++
+     protected boolean portalToAsync(ServerLevel destination, BlockPos portalPos, boolean takePassengers,
+                                     PortalType type, java.util.function.Consumer<Entity> teleportComplete) {
+         ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread(this, "Cannot portal entity async");
+@@ -4644,6 +4663,8 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+                         info.postTeleportTransition().onTransition(teleported);
+                     }
+ 
++                    teleported.afterPortalLogic(); // Luminol - Add afterPortalLogic
++
+                     // Kaiiju start - vanilla end teleportation
+                     /*if (teleportComplete != null) {
+                         teleportComplete.accept(teleported);
+diff --git a/net/minecraft/world/entity/item/PrimedTnt.java b/net/minecraft/world/entity/item/PrimedTnt.java
+index 88570bb4aa02896545805d7721c45cf9599befea..f2d9ef4429b56785fd9d95abb9d734901d589828 100644
+--- a/net/minecraft/world/entity/item/PrimedTnt.java
++++ b/net/minecraft/world/entity/item/PrimedTnt.java
+@@ -251,4 +251,11 @@ public class PrimedTnt extends Entity implements TraceableEntity {
+         return !this.level().paperConfig().fixes.preventTntFromMovingInWater && super.isPushedByFluid();
+     }
+     // Paper end - Option to prevent TNT from moving in water
++
++    // Luminol start - Add afterPortalLogic
++    protected void afterPortalLogic() {
++        this.setUsedPortal(true);
++        super.afterPortalLogic();
++    }
++    // Luminol end - Add afterPortalLogic
+ }

luminol-server/minecraft-patches/features/0056-Leaves-Disable-moved-wrongly-threshold.patch

@@ -0,0 +1,50 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: adabugra <57899270+adabugra@users.noreply.github.com>
+Date: Fri, 31 Jan 2025 19:17:01 +0300
+Subject: [PATCH] Leaves: Disable moved wrongly threshold
+
+Co-authored by: violetc <58360096+s-yh-china@users.noreply.github.com>
+As part of: Leaves (https://github.com/LeavesMC/Leaves/blob/f553c53e4230aa032e54a69b6479f1959ed24a60/patches/removed/server/0099-Disable-moved-wrongly-threshold.patch)
+Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
+
+diff --git a/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index da45200818ef4f495c90517c234a41725f709b85..bf617d2ca5e66bbcd244e4f290a7b101a967d18b 100644
+--- a/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -581,7 +581,7 @@ public class ServerGamePacketListenerImpl
+                     return;
+                 }
+                 // Paper end - Prevent moving into unloaded chunks
+-                if (d7 - d6 > Math.max(100.0, Math.pow((double) (org.spigotmc.SpigotConfig.movedTooQuicklyMultiplier * (float) i * speed), 2)) && !this.isSingleplayerOwner()) {
++                if (!me.earthme.luminol.config.modules.misc.DisableMovedWronglyThreshold.enabled && d7 - d6 > Math.max(100.0, Math.pow((double) (org.spigotmc.SpigotConfig.movedTooQuicklyMultiplier * (float) i * speed), 2)) && !this.isSingleplayerOwner()) { // Leaves - disable can
+                     // CraftBukkit end
+                     LOGGER.warn(
+                         "{} (vehicle of {}) moved too quickly! {},{},{}", rootVehicle.getName().getString(), this.player.getName().getString(), d3, d4, d5
+@@ -611,7 +611,7 @@ public class ServerGamePacketListenerImpl
+                 d5 = d2 - rootVehicle.getZ();
+                 d7 = d3 * d3 + d4 * d4 + d5 * d5;
+                 boolean flag2 = false;
+-                if (d7 > org.spigotmc.SpigotConfig.movedWronglyThreshold) { // Spigot
++                if (!me.earthme.luminol.config.modules.misc.DisableMovedWronglyThreshold.enabled && d7 > org.spigotmc.SpigotConfig.movedWronglyThreshold) { // Spigot / Leaves - disable can
+                     flag2 = true; // Paper - diff on change, this should be moved wrongly
+                     LOGGER.warn("{} (vehicle of {}) moved wrongly! {}", rootVehicle.getName().getString(), this.player.getName().getString(), Math.sqrt(d7));
+                 }
+@@ -1438,7 +1438,7 @@ public class ServerGamePacketListenerImpl
+ 
+                                 if (this.shouldCheckPlayerMovement(isFallFlying)) {
+                                     float f2 = isFallFlying ? 300.0F : 100.0F;
+-                                    if (d7 - d6 > Math.max(f2, Mth.square(org.spigotmc.SpigotConfig.movedTooQuicklyMultiplier * (float) i * speed))) {
++                                    if (!me.earthme.luminol.config.modules.misc.DisableMovedWronglyThreshold.enabled && d7 - d6 > Math.max(f2, Mth.square(org.spigotmc.SpigotConfig.movedTooQuicklyMultiplier * (float) i * speed))) { // Leaves - disable can
+                                         // CraftBukkit end
+                                         // Paper start - Add fail move event
+                                         io.papermc.paper.event.player.PlayerFailMoveEvent event = fireFailMove(io.papermc.paper.event.player.PlayerFailMoveEvent.FailReason.MOVED_TOO_QUICKLY,
+@@ -1510,7 +1510,8 @@ public class ServerGamePacketListenerImpl
+                             d5 = d2 - this.player.getZ();
+                             d7 = d3 * d3 + d4 * d4 + d5 * d5;
+                             boolean movedWrongly = false; // Paper - Add fail move event; rename
+-                            if (!this.player.isChangingDimension()
++                            if (!me.earthme.luminol.config.modules.misc.DisableMovedWronglyThreshold.enabled // Leaves - disable can
++                                && !this.player.isChangingDimension()
+                                 && d7 > org.spigotmc.SpigotConfig.movedWronglyThreshold // Spigot
+                                 && !this.player.isSleeping()
+                                 && !this.player.gameMode.isCreative()

luminol-server/minecraft-patches/features/0056-Temporarily-fix-teleport-yam-and-pitch.patch

@@ -1,21 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Helvetica Volubi <suisuroru@blue-millennium.fun>
-Date: Wed, 18 Jun 2025 23:46:20 +0800
-Subject: [PATCH] Temporarily fix teleport yam and pitch
-
-
-diff --git a/net/minecraft/server/commands/TeleportCommand.java b/net/minecraft/server/commands/TeleportCommand.java
-index 178a67b24095af02e7f75e8d80abdfc7b462639a..ebb16cf81e3b8f26df72e7f63a86938f7a402f24 100644
---- a/net/minecraft/server/commands/TeleportCommand.java
-+++ b/net/minecraft/server/commands/TeleportCommand.java
-@@ -283,8 +283,8 @@ public class TeleportCommand {
-             if (true) {
-                 ServerLevel worldFinal = level;
-                 Vec3 posFinal = new Vec3(x, y, z);
--                Float yawFinal = Float.valueOf(f);
--                Float pitchFinal = Float.valueOf(f1);
-+                Float yawFinal = Float.valueOf(f + target.getYRot());
-+                Float pitchFinal = Float.valueOf(f1 + target.getXRot());
-                 target.getBukkitEntity().taskScheduler.schedule((Entity nmsEntity) -> {
-                     nmsEntity.unRide();
-                     nmsEntity.teleportAsync(

luminol-server/minecraft-patches/features/0057-Leaves-Fix-Incorrect-Collision-Behavior-for-Block-Sh.patch

@@ -0,0 +1,40 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sat, 8 Feb 2025 14:25:16 +0800
+Subject: [PATCH] Leaves: Fix Incorrect Collision Behavior for Block Shape
+
+Co-authored by: Fortern <blueten.ki@gmail.com>
+As part of: Leaves (https://github.com/LeavesMC/Leaves/blob/f553c53e4230aa032e54a69b6479f1959ed24a60/leaves-server/minecraft-patches/features/0110-Fix-Incorrect-Collision-Behavior-for-Block-Shape.patch)
+Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
+
+diff --git a/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java b/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java
+index 471b6d49d77e03665ffc269d17ab46f225e3ce1c..c574f9a23868a35ef694e432ba581d2f00e39da7 100644
+--- a/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java
++++ b/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java
+@@ -101,6 +101,14 @@ public final class CollisionUtil {
+                (box1.minZ - box2.maxZ) < -COLLISION_EPSILON && (box1.maxZ - box2.minZ) > COLLISION_EPSILON;
+     }
+ 
++    // Leaves start
++    public static boolean voxelShapeIntersectVanilla(final net.minecraft.world.phys.AABB box1, final net.minecraft.world.phys.AABB box2) {
++        return box1.minX < box2.maxX && box1.maxX > box2.minX &&
++               box1.minY < box2.maxY && box1.maxY > box2.minY &&
++               box1.minZ < box2.maxZ && box1.maxZ > box2.minZ;
++    }
++    // Leaves end
++
+     // assume !isEmpty(target) && abs(source_move) >= COLLISION_EPSILON
+     public static double collideX(final AABB target, final AABB source, final double source_move) {
+         if ((source.minY - target.maxY) < -COLLISION_EPSILON && (source.maxY - target.minY) > COLLISION_EPSILON &&
+@@ -2026,7 +2034,10 @@ public final class CollisionUtil {
+                                     AABB singleAABB = ((CollisionVoxelShape)blockCollision).moonrise$getSingleAABBRepresentation();
+                                     if (singleAABB != null) {
+                                         singleAABB = singleAABB.move((double)blockX, (double)blockY, (double)blockZ);
+-                                        if (!voxelShapeIntersect(aabb, singleAABB)) {
++                                        // Leaves start - Fix incorrect collision behavior for block shape
++                                        boolean isBlockShape = blockCollision == net.minecraft.world.phys.shapes.Shapes.block();
++                                        if (isBlockShape && !voxelShapeIntersectVanilla(aabb, singleAABB) || !isBlockShape && !voxelShapeIntersect(aabb, singleAABB)) {
++                                        // Leaves end - Fix incorrect collision behavior for block shape
+                                             continue;
+                                         }
+