Updated Upstream (Folia)

* misc: fixup count of patch

* ci: update ncipollo/release-action to 1.16.0

* docs: update CONTRIBUTING.md

* docs: update CONTRIBUTING files

* docs: update CONTRIBUTING files

* Update CONTRIBUTING.md

* docs: sync zh_cn's update to en

* docs: correct grammar errors

* docs: fixup jdk version to 21

---------

Co-authored-by: xiaoxijun <A3167717663@hotmail.com>

.github/dependabot.yml

@@ -0,0 +1,12 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  # Enable version updates for github actions
+  - package-ecosystem: "github-actions" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

.github/workflows/build_1.21.4.yml

@@ -41,13 +41,13 @@ jobs:
         uses: "actions/upload-artifact@v4"
         with:
           name: "${{ env.project_id_b }} CI Artifacts"
-          path: "luminol-server/build/libs/*.jar"
+          path: "luminol-server/build/libs/*-paperclip.jar"
       - name: SetENV
         if: github.event_name != 'pull_request'
         run: sh scripts/SetENV.sh
       - name: Create Release
         if: github.event_name != 'pull_request'
-        uses: ncipollo/release-action@v1.14.0
+        uses: ncipollo/release-action@v1.16.0
         with:
           tag: ${{ env.tag }}
           name: ${{ env.project_id_b }} ${{ env.mcversion }} - ${{ env.commit_id }}
@@ -58,7 +58,6 @@ jobs:
             ${{ env.commit_msg }}
           artifacts: |
             ${{ env.jar_dir }}
-            ${{ env.jar_dir_bundler }}
           generateReleaseNotes: true
           prerelease: ${{ env.pre }}
           makeLatest: ${{ env.make_latest }}

docs/CONTRIBUTING.md

@@ -21,23 +21,24 @@
 在开始开发之前，您首先需要拥有以下软件作为开发环境：
 
 - `git`
-- `JDK 17 或更高版本`
+- `JDK 21 或更高版本`
 
 ## 了解补丁（Patches）
 
 Luminol 使用和 Folia 一样的补丁系统，并为了针对不同部分的修改分成了两个目录：
 
 - `luminol-api` - 对 `Folia-API` / `Paper-API` / `Spigot-API` / `Bukkit` 进行的修改。
+- `luminol-server` - 对 Minecraft 标准服务器原有逻辑进行的修改。
 
 补丁系统是基于 git 的，你可以在这里了解 git 的基本内容: <https://git-scm.com/docs/gittutorial>
 
 如果你已经 Fork 了主储存库，那么下面你应该这么做：
 
 1. 将你的仓库 clone 到本地；
-2. 在你的 IDE 或 终端 内执行 Gradle 的 `applyPatches` 任务，如果是在终端内，你可以执行 `./gradlew applyPatches`；
-3. 进入 `luminol-api` 文件夹进行修改。
+2. 在你的 IDE 或 终端 内执行 Gradle 的 `applyAllPatches` 任务，如果是在终端内，你可以执行 `./gradlew applyAllPatches`；
+3. 进入 仓库根目录下的 `luminol-api` 和 `luminol-server` 文件夹进行修改。
 
-顺便一提，`luminol-api` 并不是正常的 git 仓库：
+顺便一提，仓库根目录下的 `luminol-api` 和 `luminol-server` 并不是正常的 git 仓库：
 
 - 在应用补丁前，基点将会指向未被更改的源码
 - 在基点后的每一个提交都是一个补丁
@@ -47,11 +48,12 @@ Luminol 使用和 Folia 一样的补丁系统，并为了针对不同部分的
 
 按照以下步骤增加一个补丁是非常简单的：
 
-1. 对 `luminol-api` 进行修改；
-2. 使用 git 添加你的修改，比如 `git add .`；
+1. 对 `luminol-api` 和 `luminol-server` 进行修改；
+2. 使用 git 添加你的修改，比如 `git add .`（不要提交新建的文件的修改）；
 3. 使用 `git commit -m <提交信息>` 进行提交；
-4. 运行 Gradle 任务 `rebuildPatches` 将你的提交转化为一个补丁；
-5. 将你生成的补丁文件进行推送。
+4. 运行 Gradle 任务 `rebuildAllServerPatches` 将你的提交转化为一个补丁；
+5. 运行 Gradle 任务 `fixupPaperApiFilePatches` 生成新建文件的补丁文件（注意不要提交）；
+6. 将你生成的补丁文件进行推送。
 
 这样做以后，你就可以将你的补丁文件进行 PR 提交。
 
@@ -60,8 +62,9 @@ Luminol 使用和 Folia 一样的补丁系统，并为了针对不同部分的
 你可以使用以下方法来修改一个补丁的内容：
 
 1. 在 HEAD 上直接进行修改；
-2. 使用 `git commit -a --fixup <hash>` 来进行一个更正提交；
+2. 使用 `git commit -a --fixup <hash>` 来进行一个更正提交；（不要提交对在luminol新建文件的修改）
    - 如果你想要更改提交信息，你也可以用 `--squash` 来代替 `--fixup`。
 3. 使用 `git rebase -i --autosquash base` 来进行自动变基，你只需要输入 `:q` 来关闭确认页面即可；
-4. 运行 Gradle 任务 `rebuildPatches` 来修改已被修改的补丁；
-5. 将修改后的补丁 PR 发回储存库。
+4. 运行 Gradle 任务 `rebuildAllServerPatches` 来修改已被修改的补丁；
+5. 运行 Gradle 任务 `fixupPaperApiFilePatches` 来修改已被修改的在luminol新建文件的补丁（注意不要提交）；
+6. 将修改后的补丁 PR 发回储存库。

docs/CONTRIBUTING_EN.md

@@ -10,20 +10,20 @@ And if you can follow the rules below, we can complete the review faster.
 ## Please fork using your personal account
 
 We regularly merge existing PRs.  
-If there're some small problems, we'll help you solve them by editing your PR.
+If there are some small problems, we'll help you solve them by editing your PR.
 
-But, if your PR is from a organization, we can NOT edit your PR, so we must merge your PR manually.
+But, if your PR is from an organization, we can NOT edit your PR, so we must merge your PR manually.
 
-So, don't use orgnization accounts for fork!
+So, don't use organization accounts for fork!
 
 See also [This issue](https://github.com/isaacs/github/issues/1681), and then you'll know why we can't edit PRs from organizations.
 
 ## Development Environment
 
-Before coding, you need these softwares / tools as Dev Environment.
+Before coding, you need these pieces of software / tools as Dev Environment.
 
 - `git`
-- `JDK 17 or higher`
+- `JDK 21 or higher`
 
 ## Understanding "Patches"
 
@@ -31,40 +31,43 @@ Luminol uses as the same patching system as Paper,
 and has been divided into two directories for the purpose of modifying different parts of it:
 
 - `luminol-api` - Modifications to `Folia-API` / `Paper-API` / `Spigot-API` / `Bukkit`.
+- `luminol-server` - Modifications to Minecraft Official Server's source logic.
 
 The patching system is based on git, and you can learn about it at here: <https://git-scm.com/docs/gittutorial>
 
 If you have forked the main repository, then you should follow the steps below:
 
 1. Clone your repository to local
-2. Run Gradle's `applyPatches` task in your IDE or terminal (You can run `./gradlew applyPatches` directly in terminal.)
-3. Enter `luminol-api` directory to carry out modifications.
+2. Run Gradle's `applyAllPatches` task in your IDE or terminal (You can run `./gradlew applyAllPatches` directly in terminal.)
+3. Enter `luminol-api` and `luminol-server` directory to carry out modifications.
 
-BTW, `luminol-api` and are not normal git repositories.
+BTW, `luminol-api` and `luminol-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 Paper will be considered Luminol' patches.
+- Only commits after the last commit of Paper will be considered as Luminol patches.
 
 ## Adding new patches
 
-It's very easy to to add patches by following the steps below:
+It's very easy to add patches by following the steps below:
 
-1. Modify the code of `luminol-api`
+1. Modify the code of `luminol-api` and `luminol-server`
 2. Add these changes to the local git repository (For example, `git add .`)
-3. Commit these changes using `git commit -m <Commit Message>`
-4. Run Gradle's task `rebuildPatches` to convert your commits to a new patch
-5. Push your patches to your repository
+3. Commit these changes using `git commit -m <Commit Message>` (PS: do not commit new-created files)
+4. Run Gradle's task `rebuildAllServerPatches` to convert your commits to a new patch
+5. Run Gradle's task `fixupPaperApiFilePatches` to generate newly created files to new patches (PS: do not commit again before you run this task)
+6. Push your patches to your repository
 
 After pushing, you can open a PR to submit your patches.
 
 ## Modifying patches
 
-You can modify a existing patch by following the steps below:
+You can modify an existing patch by following the steps below:
 
 1. Modify code at HEAD
-2. Run `git commit -a --fixup <hash>` in your terminal to make a fix-up commit
+2. Run `git commit -a --fixup <hash>` in your terminal to make a fix-up commit (PS: do not commit changes of luminol-created files)
     - If you want to edit the commit message, replace `--fixup` with `--squash`.
 3. Run `git rebase -i --autosquash base` to rebase automatically, then just type `:q` to close the confirm page
-4. Run Gradle's task `rebuildPatches` to modify existing patches
-5. Push and PR again
+4. Run Gradle's task `rebuildAllServerPatches` to modify existing patches 
+5. Run Gradle's task `fixupPaperApiFilePatches` to regenerate luminol-created files to patches (PS: do not commit again before you run this task)
+6. Push and PR again

gradle.properties

@@ -2,7 +2,7 @@ group = me.earthme.luminol
 version=1.21.4-R0.1-SNAPSHOT
 mcVersion=1.21.4
 
-foliaRef=d3969cdc419b84e2d94c13854d4eb94ae2e0b7be
+foliaRef=29867414449cede8010bac42dc9bf31dd21eb278
 
 org.gradle.configuration-cache=true
 org.gradle.caching=true

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

@@ -27,7 +27,7 @@ index 1fa5e6a12b943e889bde566038a632a6adcf319e..c1f6a3b3a8fa990b8e9b052341ab31bd
      }
  }
 diff --git a/net/minecraft/world/level/block/EndPortalBlock.java b/net/minecraft/world/level/block/EndPortalBlock.java
-index 177735cf744e564081e4c140a0f8210c3a07e037..7274f2d7df9228f34305a21abde6d114a495c1cb 100644
+index 554d75ac1374d7d93977a10e06fcf51259830c97..17c1ce4397c5953bb92aaa3b56c179b7c24a0736 100644
 --- a/net/minecraft/world/level/block/EndPortalBlock.java
 +++ b/net/minecraft/world/level/block/EndPortalBlock.java
 @@ -67,6 +67,11 @@ public class EndPortalBlock extends BaseEntityBlock implements Portal {

luminol-server/minecraft-patches/features/0022-Revert-RegionizedTaskQueue-referent-counter-changes.patch

@@ -0,0 +1,381 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <mrhua269@gmail.com>
+Date: Thu, 20 Mar 2025 23:12:30 +0800
+Subject: [PATCH] Revert RegionizedTaskQueue referent counter changes
+
+
+diff --git a/io/papermc/paper/threadedregions/RegionizedTaskQueue.java b/io/papermc/paper/threadedregions/RegionizedTaskQueue.java
+index 745ab870310733b569681f5280895bb9798620a4..9b8d06c77aa71acbe25151d82777e5dfa4e4a5f7 100644
+--- a/io/papermc/paper/threadedregions/RegionizedTaskQueue.java
++++ b/io/papermc/paper/threadedregions/RegionizedTaskQueue.java
+@@ -24,7 +24,7 @@ public final class RegionizedTaskQueue {
+ 
+     public PrioritisedExecutor.PrioritisedTask createChunkTask(final ServerLevel world, final int chunkX, final int chunkZ,
+                                                                final Runnable run) {
+-        return this.createChunkTask(world, chunkX, chunkZ, run, Priority.NORMAL);
++        return new PrioritisedQueue.ChunkBasedPriorityTask(world.taskQueueRegionData, chunkX, chunkZ, true, run, Priority.NORMAL);
+     }
+ 
+     public PrioritisedExecutor.PrioritisedTask createChunkTask(final ServerLevel world, final int chunkX, final int chunkZ,
+@@ -34,7 +34,7 @@ public final class RegionizedTaskQueue {
+ 
+     public PrioritisedExecutor.PrioritisedTask createTickTaskQueue(final ServerLevel world, final int chunkX, final int chunkZ,
+                                                                    final Runnable run) {
+-        return this.createTickTaskQueue(world, chunkX, chunkZ, run, Priority.NORMAL);
++        return new PrioritisedQueue.ChunkBasedPriorityTask(world.taskQueueRegionData, chunkX, chunkZ, false, run, Priority.NORMAL);
+     }
+ 
+     public PrioritisedExecutor.PrioritisedTask createTickTaskQueue(final ServerLevel world, final int chunkX, final int chunkZ,
+@@ -73,7 +73,7 @@ public final class RegionizedTaskQueue {
+     public static final class WorldRegionTaskData {
+         private final ServerLevel world;
+         private final MultiThreadedQueue<Runnable> globalChunkTask = new MultiThreadedQueue<>();
+-        private final ConcurrentLong2ReferenceChainedHashTable<ReferenceCountData> referenceCounters = new ConcurrentLong2ReferenceChainedHashTable<>();
++        private final ConcurrentLong2ReferenceChainedHashTable<AtomicLong> referenceCounters = new ConcurrentLong2ReferenceChainedHashTable<>();
+ 
+         public WorldRegionTaskData(final ServerLevel world) {
+             this.world = world;
+@@ -99,7 +99,7 @@ public final class RegionizedTaskQueue {
+         private PrioritisedQueue getQueue(final boolean synchronise, final int chunkX, final int chunkZ, final boolean isChunkTask) {
+             final ThreadedRegionizer<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> regioniser = this.world.regioniser;
+             final ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> region
+-                = synchronise ? regioniser.getRegionAtSynchronised(chunkX, chunkZ) : regioniser.getRegionAtUnsynchronised(chunkX, chunkZ);
++                    = synchronise ? regioniser.getRegionAtSynchronised(chunkX, chunkZ) : regioniser.getRegionAtUnsynchronised(chunkX, chunkZ);
+             if (region == null) {
+                 return null;
+             }
+@@ -109,13 +109,13 @@ public final class RegionizedTaskQueue {
+ 
+         private void removeTicket(final long coord) {
+             this.world.moonrise$getChunkTaskScheduler().chunkHolderManager.removeTicketAtLevel(
+-                TASK_QUEUE_TICKET, coord, ChunkHolderManager.MAX_TICKET_LEVEL, Unit.INSTANCE
++                    TASK_QUEUE_TICKET, coord, ChunkHolderManager.MAX_TICKET_LEVEL, Unit.INSTANCE
+             );
+         }
+ 
+         private void addTicket(final long coord) {
+             this.world.moonrise$getChunkTaskScheduler().chunkHolderManager.addTicketAtLevel(
+-                TASK_QUEUE_TICKET, coord, ChunkHolderManager.MAX_TICKET_LEVEL, Unit.INSTANCE
++                    TASK_QUEUE_TICKET, coord, ChunkHolderManager.MAX_TICKET_LEVEL, Unit.INSTANCE
+             );
+         }
+ 
+@@ -123,95 +123,96 @@ public final class RegionizedTaskQueue {
+             this.world.moonrise$getChunkTaskScheduler().chunkHolderManager.processTicketUpdates(CoordinateUtils.getChunkX(coord), CoordinateUtils.getChunkZ(coord));
+         }
+ 
+-        // note: only call on acquired referenceCountData
+-        private void ensureTicketAdded(final long coord, final ReferenceCountData referenceCountData) {
+-            if (!referenceCountData.addedTicket) {
+-                // fine if multiple threads do this, no removeTicket may be called for this coord due to reference count inc
+-                this.addTicket(coord);
+-                this.processTicketUpdates(coord);
+-                referenceCountData.addedTicket = true;
++        private void decrementReference(final AtomicLong reference, final long coord) {
++            final long val = reference.decrementAndGet();
++            if (val == 0L) {
++                final int chunkX = CoordinateUtils.getChunkX(coord);
++                final int chunkZ = CoordinateUtils.getChunkZ(coord);
++                final ca.spottedleaf.concurrentutil.lock.ReentrantAreaLock.Node ticketLock = this.world.moonrise$getChunkTaskScheduler().chunkHolderManager.ticketLockArea.lock(chunkX, chunkZ);
++                try {
++                    if (this.referenceCounters.remove(coord, reference) == reference) {
++                        WorldRegionTaskData.this.removeTicket(coord);
++                    } // else: race condition, something replaced our reference - not our issue anymore
++                } finally {
++                    this.world.moonrise$getChunkTaskScheduler().chunkHolderManager.ticketLockArea.unlock(ticketLock);
++                }
++            } else if (val < 0L) {
++                throw new IllegalStateException("Reference count < 0: " + val);
+             }
+         }
+ 
+-        private void decrementReference(final ReferenceCountData referenceCountData, final long coord) {
+-            if (!referenceCountData.decreaseReferenceCount()) {
+-                return;
+-            } // else: need to remove ticket
+-
+-            // note: it is possible that another thread increments and then removes the reference before we can, so
+-            //       use ifPresent
+-            this.referenceCounters.computeIfPresent(coord, (final long keyInMap, final ReferenceCountData valueInMap) -> {
+-                if (valueInMap.referenceCount.get() != 0L) {
+-                    return valueInMap;
+-                }
+-
+-                // note: valueInMap may not be referenceCountData
+-
+-                // possible to invoke this outside of the compute call, but not required and requires additional logic
+-                WorldRegionTaskData.this.removeTicket(keyInMap);
++        private AtomicLong incrementReference(final long coord) {
++            final AtomicLong ret = this.referenceCounters.get(coord);
++            if (ret != null) {
++                // try to fast acquire counter
++                int failures = 0;
++                for (long curr = ret.get();;) {
++                    if (curr == 0L) {
++                        // failed to fast acquire as reference expired
++                        break;
++                    }
+ 
+-                return null;
+-            });
+-        }
++                    for (int i = 0; i < failures; ++i) {
++                        ConcurrentUtil.backoff();
++                    }
+ 
+-        private ReferenceCountData incrementReference(final long coord) {
+-            ReferenceCountData referenceCountData = this.referenceCounters.get(coord);
++                    if (curr == (curr = ret.compareAndExchange(curr, curr + 1L))) {
++                        return ret;
++                    }
+ 
+-            if (referenceCountData != null && referenceCountData.addCount()) {
+-                this.ensureTicketAdded(coord, referenceCountData);
+-                return referenceCountData;
++                    ++failures;
++                }
+             }
+ 
+-            referenceCountData = this.referenceCounters.compute(coord, (final long keyInMap, final ReferenceCountData valueInMap) -> {
++            // slow acquire
++            final int chunkX = CoordinateUtils.getChunkX(coord);
++            final int chunkZ = CoordinateUtils.getChunkZ(coord);
++            final ca.spottedleaf.concurrentutil.lock.ReentrantAreaLock.Node ticketLock = this.world.moonrise$getChunkTaskScheduler().chunkHolderManager.ticketLockArea.lock(chunkX, chunkZ);
++            final AtomicLong ret2;
++            final boolean processTicketUpdates;
++            try {
++                final AtomicLong replace = new AtomicLong(1L);
++                final AtomicLong valueInMap = this.referenceCounters.putIfAbsent(coord, replace);
+                 if (valueInMap == null) {
+-                    // sets reference count to 1
+-                    return new ReferenceCountData();
+-                }
+-                // OK if we add from 0, the remove call will use compute() and catch this race condition
+-                valueInMap.referenceCount.getAndIncrement();
+-
+-                return valueInMap;
+-            });
+-
+-            this.ensureTicketAdded(coord, referenceCountData);
+-
+-            return referenceCountData;
+-        }
+-    }
+-
+-    private static final class ReferenceCountData {
+-
+-        public final AtomicLong referenceCount = new AtomicLong(1L);
+-        public volatile boolean addedTicket;
++                    // replaced, we should usually be here
++                    this.addTicket(coord);
++                    ret2 = replace;
++                    processTicketUpdates = true;
++                } else {
++                    processTicketUpdates = false;
++                    int failures = 0;
++                    for (long curr = valueInMap.get();;) {
++                        if (curr == 0L) {
++                            // don't need to add ticket here, since ticket is only removed during the lock
++                            // we just need to replace the value in the map so that the thread removing fails and doesn't
++                            // remove the ticket (see decrementReference)
++                            this.referenceCounters.put(coord, replace);
++                            ret2 = replace;
++                            break;
++                        }
+ 
+-        // returns false if reference count is 0, otherwise increments ref count
+-        public boolean addCount() {
+-            int failures = 0;
+-            for (long curr = this.referenceCount.get();;) {
+-                for (int i = 0; i < failures; ++i) {
+-                    Thread.onSpinWait();
+-                }
++                        for (int i = 0; i < failures; ++i) {
++                            ConcurrentUtil.backoff();
++                        }
+ 
+-                if (curr == 0L) {
+-                    return false;
+-                }
++                        if (curr == (curr = valueInMap.compareAndExchange(curr, curr + 1L))) {
++                            // acquired
++                            ret2 = valueInMap;
++                            break;
++                        }
+ 
+-                if (curr == (curr = this.referenceCount.compareAndExchange(curr, curr + 1L))) {
+-                    return true;
++                        ++failures;
++                    }
+                 }
+-
+-                ++failures;
++            } finally {
++                this.world.moonrise$getChunkTaskScheduler().chunkHolderManager.ticketLockArea.unlock(ticketLock);
+             }
+-        }
+ 
+-        // returns true if new reference count is 0
+-        public boolean decreaseReferenceCount() {
+-            final long res = this.referenceCount.decrementAndGet();
+-            if (res >= 0L) {
+-                return res == 0L;
+-            } else {
+-                throw new IllegalStateException("Negative reference count");
++            if (processTicketUpdates) {
++                this.processTicketUpdates(coord);
+             }
++
++            return ret2;
+         }
+     }
+ 
+@@ -240,10 +241,10 @@ public final class RegionizedTaskQueue {
+         void split(final ThreadedRegionizer<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> regioniser,
+                    final Long2ReferenceOpenHashMap<ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData>> into) {
+             this.tickTaskQueue.split(
+-                false, regioniser, into
++                    false, regioniser, into
+             );
+             this.chunkQueue.split(
+-                true, regioniser, into
++                    true, regioniser, into
+             );
+         }
+ 
+@@ -340,7 +341,7 @@ public final class RegionizedTaskQueue {
+                           final ThreadedRegionizer<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> regioniser,
+                           final Long2ReferenceOpenHashMap<ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData>> into) {
+             final Reference2ReferenceOpenHashMap<ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData>, ArrayDeque<ChunkBasedPriorityTask>[]>
+-                split = new Reference2ReferenceOpenHashMap<>();
++                    split = new Reference2ReferenceOpenHashMap<>();
+             final int shift = regioniser.sectionChunkShift;
+             synchronized (this) {
+                 this.isDestroyed = true;
+@@ -356,7 +357,7 @@ public final class RegionizedTaskQueue {
+                         final int sectionZ = task.chunkZ >> shift;
+                         final long sectionKey = CoordinateUtils.getChunkKey(sectionX, sectionZ);
+                         final ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData>
+-                            region = into.get(sectionKey);
++                                region = into.get(sectionKey);
+                         if (region == null) {
+                             throw new IllegalStateException();
+                         }
+@@ -378,7 +379,7 @@ public final class RegionizedTaskQueue {
+                      iterator = split.reference2ReferenceEntrySet().fastIterator();
+                      iterator.hasNext();) {
+                     final Reference2ReferenceMap.Entry<ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData>, ArrayDeque<ChunkBasedPriorityTask>[]>
+-                        entry = iterator.next();
++                            entry = iterator.next();
+                     final RegionTaskQueueData taskQueueData = entry.getKey().getData().getTaskQueueData();
+                     mergeInto(isChunkData ? taskQueueData.chunkQueue : taskQueueData.tickTaskQueue, entry.getValue());
+                 }
+@@ -408,7 +409,7 @@ public final class RegionizedTaskQueue {
+             final ArrayDeque<ChunkBasedPriorityTask>[] queues = this.queues;
+             final int max = Priority.IDLE.priority;
+             ChunkBasedPriorityTask task = null;
+-            ReferenceCountData referenceCounter = null;
++            AtomicLong referenceCounter = null;
+             synchronized (this) {
+                 if (this.isDestroyed) {
+                     throw new IllegalStateException("Attempting to poll from dead queue");
+@@ -440,10 +441,9 @@ public final class RegionizedTaskQueue {
+ 
+         private static final class ChunkBasedPriorityTask implements PrioritisedExecutor.PrioritisedTask {
+ 
+-            private static final ReferenceCountData REFERENCE_COUNTER_NOT_SET = new ReferenceCountData();
+-            static {
+-                REFERENCE_COUNTER_NOT_SET.referenceCount.set((long)Integer.MIN_VALUE);
+-            }
++            private static final AtomicLong REFERENCE_COUNTER_NOT_SET = new AtomicLong(-1L);
++
++
+ 
+             private final WorldRegionTaskData world;
+             private final int chunkX;
+@@ -451,8 +451,8 @@ public final class RegionizedTaskQueue {
+             private final long sectionLowerLeftCoord; // chunk coordinate
+             private final boolean isChunkTask;
+ 
+-            private volatile ReferenceCountData referenceCounter;
+-            private static final VarHandle REFERENCE_COUNTER_HANDLE = ConcurrentUtil.getVarHandle(ChunkBasedPriorityTask.class, "referenceCounter", ReferenceCountData.class);
++            private volatile AtomicLong referenceCounter;
++            private static final VarHandle REFERENCE_COUNTER_HANDLE = ConcurrentUtil.getVarHandle(ChunkBasedPriorityTask.class, "referenceCounter", AtomicLong.class);
+             private Runnable run;
+             private volatile Priority priority;
+             private static final VarHandle PRIORITY_HANDLE = ConcurrentUtil.getVarHandle(ChunkBasedPriorityTask.class, "priority", Priority.class);
+@@ -489,16 +489,16 @@ public final class RegionizedTaskQueue {
+                 return (Priority)PRIORITY_HANDLE.compareAndExchange(this, expect, update);
+             }
+ 
+-            private void setReferenceCounterPlain(final ReferenceCountData value) {
++            private void setReferenceCounterPlain(final AtomicLong value) {
+                 REFERENCE_COUNTER_HANDLE.set(this, value);
+             }
+ 
+-            private ReferenceCountData getReferenceCounterVolatile() {
+-                return (ReferenceCountData)REFERENCE_COUNTER_HANDLE.get(this);
++            private AtomicLong getReferenceCounterVolatile() {
++                return (AtomicLong)REFERENCE_COUNTER_HANDLE.get(this);
+             }
+ 
+-            private ReferenceCountData compareAndExchangeReferenceCounter(final ReferenceCountData expect, final ReferenceCountData update) {
+-                return (ReferenceCountData)REFERENCE_COUNTER_HANDLE.compareAndExchange(this, expect, update);
++            private AtomicLong compareAndExchangeReferenceCounter(final AtomicLong expect, final AtomicLong update) {
++                return (AtomicLong)REFERENCE_COUNTER_HANDLE.compareAndExchange(this, expect, update);
+             }
+ 
+             private void executeInternal() {
+@@ -515,7 +515,7 @@ public final class RegionizedTaskQueue {
+ 
+             private boolean tryComplete(final boolean cancel) {
+                 int failures = 0;
+-                for (ReferenceCountData curr = this.getReferenceCounterVolatile();;) {
++                for (AtomicLong curr = this.getReferenceCounterVolatile();;) {
+                     if (curr == null) {
+                         return false;
+                     }
+@@ -564,7 +564,7 @@ public final class RegionizedTaskQueue {
+                     return false;
+                 }
+ 
+-                final ReferenceCountData referenceCounter = this.world.incrementReference(this.sectionLowerLeftCoord);
++                final AtomicLong referenceCounter = this.world.incrementReference(this.sectionLowerLeftCoord);
+                 if (this.compareAndExchangeReferenceCounter(REFERENCE_COUNTER_NOT_SET, referenceCounter) != REFERENCE_COUNTER_NOT_SET) {
+                     // we don't expect race conditions here, so it is OK if we have to needlessly reference count
+                     this.world.decrementReference(referenceCounter, this.sectionLowerLeftCoord);
+@@ -614,7 +614,7 @@ public final class RegionizedTaskQueue {
+                 }
+             }
+ 
+-            private ReferenceCountData trySetCompleting(final int minPriority) {
++            private AtomicLong trySetCompleting(final int minPriority) {
+                 // first, try to set priority to EXECUTING
+                 for (Priority curr = this.getPriorityVolatile();;) {
+                     if (curr.isLowerPriority(minPriority)) {
+@@ -626,7 +626,7 @@ public final class RegionizedTaskQueue {
+                     } // else: continue
+                 }
+ 
+-                for (ReferenceCountData curr = this.getReferenceCounterVolatile();;) {
++                for (AtomicLong curr = this.getReferenceCounterVolatile();;) {
+                     if (curr == null) {
+                         // something acquired before us
+                         return null;
+@@ -639,7 +639,6 @@ public final class RegionizedTaskQueue {
+                     if (curr != (curr = this.compareAndExchangeReferenceCounter(curr, null))) {
+                         continue;
+                     }
+-
+                     return curr;
+                 }
+             }
+@@ -647,7 +646,7 @@ public final class RegionizedTaskQueue {
+             private void updatePriorityInQueue() {
+                 boolean synchronise = false;
+                 for (;;) {
+-                    final ReferenceCountData referenceCount = this.getReferenceCounterVolatile();
++                    final AtomicLong referenceCount = this.getReferenceCounterVolatile();
+                     if (referenceCount == REFERENCE_COUNTER_NOT_SET || referenceCount == null) {
+                         // cancelled or not queued
+                         return;

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

@@ -5,10 +5,10 @@ Subject: [PATCH] Leaves Disable moved wrongly threshold
 
 
 diff --git a/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 4e3cb90558533ea7ca0c838745e91ec5860c11ce..9fc72689b5021d1de2e149c1dfe5fc60048c7231 100644
+index a2fe9286d432909ba0cb3731a166514af768dc37..d60721767f94336eaba09b9bdb12a1420c264e49 100644
 --- a/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 +++ b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -579,7 +579,7 @@ public class ServerGamePacketListenerImpl
+@@ -581,7 +581,7 @@ public class ServerGamePacketListenerImpl
                      return;
                  }
                  // Paper end - Prevent moving into unloaded chunks
@@ -17,7 +17,7 @@ index 4e3cb90558533ea7ca0c838745e91ec5860c11ce..9fc72689b5021d1de2e149c1dfe5fc60
                      // CraftBukkit end
                      LOGGER.warn(
                          "{} (vehicle of {}) moved too quickly! {},{},{}", rootVehicle.getName().getString(), this.player.getName().getString(), d3, d4, d5
-@@ -609,7 +609,7 @@ public class ServerGamePacketListenerImpl
+@@ -611,7 +611,7 @@ public class ServerGamePacketListenerImpl
                  d5 = d2 - rootVehicle.getZ();
                  d7 = d3 * d3 + d4 * d4 + d5 * d5;
                  boolean flag2 = false;
@@ -26,7 +26,7 @@ index 4e3cb90558533ea7ca0c838745e91ec5860c11ce..9fc72689b5021d1de2e149c1dfe5fc60
                      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));
                  }
-@@ -1434,7 +1434,7 @@ public class ServerGamePacketListenerImpl
+@@ -1437,7 +1437,7 @@ public class ServerGamePacketListenerImpl
  
                                  if (this.shouldCheckPlayerMovement(isFallFlying)) {
                                      float f2 = isFallFlying ? 300.0F : 100.0F;
@@ -35,7 +35,7 @@ index 4e3cb90558533ea7ca0c838745e91ec5860c11ce..9fc72689b5021d1de2e149c1dfe5fc60
                                          // 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,
-@@ -1506,7 +1506,8 @@ public class ServerGamePacketListenerImpl
+@@ -1509,7 +1509,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

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

@@ -0,0 +1,21 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Kercute <A3167717663@hotmail.com>
+Date: Sun, 16 Mar 2025 23:31:41 +0800
+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 009e6405a11a391adca41a7c4ecafbf3254d799d..cfb37f2e428605965a37dc1eb83f302fe1bd6299 100644
+--- a/net/minecraft/commands/Commands.java
++++ b/net/minecraft/commands/Commands.java
+@@ -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);
+-        //DataCommands.register(this.dispatcher); // Folia - region threading - TODO
++        if(me.earthme.luminol.config.modules.experiment.CommandDataConfig.enabled) {
++            DataCommands.register(this.dispatcher); // 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/paper-patches/features/0004-Add-tpsbar-with-chunkhot-membar-and-region-bar.patch

@@ -22,10 +22,10 @@ index de8b9048c8395c05b8688bc9d984b8ad680f15b3..f42692cd4f0154705c3d5b030d281cfc
 +    // KioCG end
  }
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index c9afcd46f6a1b74b82ed68f1df6188369cf53a73..7cb95021f547c94eae7cef0bf5b2d8dff0a04937 100644
+index ac878520dc4aaa0e6a1ce8de0982d60a8397bc15..af20bc3b9cfb056beca0a341e209a4cc5e869da3 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -2404,6 +2404,15 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+@@ -2401,6 +2401,15 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
                  handle.expToDrop = data.getInt("expToDrop");
                  handle.keepLevel = data.getBoolean("keepLevel");
              }
@@ -41,7 +41,7 @@ index c9afcd46f6a1b74b82ed68f1df6188369cf53a73..7cb95021f547c94eae7cef0bf5b2d8df
          }
      }
  
-@@ -2425,6 +2434,15 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+@@ -2422,6 +2431,15 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
          data.putLong("lastPlayed", System.currentTimeMillis());
          data.putString("lastKnownName", handle.getScoreboardName());
  
@@ -57,9 +57,9 @@ index c9afcd46f6a1b74b82ed68f1df6188369cf53a73..7cb95021f547c94eae7cef0bf5b2d8df
          // Paper start - persist for use in offline save data
          if (!nbttagcompound.contains("Paper")) {
              nbttagcompound.put("Paper", new CompoundTag());
-@@ -3618,4 +3636,11 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-     public void setDeathScreenScore(final int score) {
-         getHandle().setScore(score);
+@@ -3631,4 +3649,11 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     public void setSimplifyContainerDesyncCheck(final boolean simplifyContainerDesyncCheck) {
+         this.simplifyContainerDesyncCheck = simplifyContainerDesyncCheck;
      }
 +
 +    // KioCG start - ChunkHot

luminol-server/paper-patches/features/0006-Force-disable-builtin-spark-plugin.patch

@@ -18,7 +18,7 @@ index a0b84535a9d3833d4df692b85b272f145559dd80..c2ba46408b5ad727d7a17f21d47b2898
              return;
          }
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 09853a5035a6cb2f9efa20a68644038f11065a9d..00b3db1c0c449e77cd365c70d0ce044c56b2dcf7 100644
+index 6c2d9c9621f665412f1a8ccc41083fb0e3a07ed5..fb0ba43c8102a205d1402f53d47823672d2edfbe 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 @@ -314,7 +314,7 @@ public final class CraftServer implements Server {

luminol-server/paper-patches/features/0007-SparklyPaper-Optimize-canSee-checks.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] SparklyPaper Optimize canSee checks
 
 
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index 3e4e0dcdd4e2808aef8dd41f159a358f47450f40..450350e66ae42f234bfd3016da1434e3194259e2 100644
+index af20bc3b9cfb056beca0a341e209a4cc5e869da3..91dd18a874ea83bed83983ecfa52decce2b163a5 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -214,7 +214,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+@@ -210,7 +210,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
      private boolean hasPlayedBefore = false;
      private final ConversationTracker conversationTracker = new ConversationTracker();
      private final Set<String> channels = new HashSet<String>();
@@ -17,7 +17,7 @@ index 3e4e0dcdd4e2808aef8dd41f159a358f47450f40..450350e66ae42f234bfd3016da1434e3
      private final Set<UUID> unlistedEntities = new HashSet<>(); // Paper - Add Listing API for Player
      private static final WeakHashMap<Plugin, WeakReference<Plugin>> pluginWeakReferences = new WeakHashMap<>();
      private int hash = 0;
-@@ -2268,9 +2268,16 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+@@ -2265,9 +2265,16 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
  
      @Override
      public boolean canSee(org.bukkit.entity.Entity entity) {

luminol-server/paper-patches/features/0009-Leaf-Secure-seed-and-matter-seed-command.patch

@@ -23,7 +23,7 @@ index f42692cd4f0154705c3d5b030d281cfc333803ed..39cc976f65f826a00e2e637c139f9134
  
      @Override
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 00b3db1c0c449e77cd365c70d0ce044c56b2dcf7..4e9248980ee7400d856dc30792197468559bfe9b 100644
+index fb0ba43c8102a205d1402f53d47823672d2edfbe..d8627561b5ffec33e0c42974aa5e3d421c8cfac2 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 @@ -1423,7 +1423,11 @@ public final class CraftServer implements Server {

luminol-server/paper-patches/files/src/main/java/me/earthme/luminol/config/modules/experiment/CommandDataConfig.java.patch

@@ -0,0 +1,23 @@
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/experiment/CommandDataConfig.java
+@@ -1,0 +_,20 @@
++package me.earthme.luminol.config.modules.experiment;
++
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++
++public class CommandDataConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enable")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.EXPERIMENT;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "force_the_data_command_to_be_enabled";
++    }
++}

scripts/SetENV.sh

@@ -11,13 +11,10 @@ grdversion=$(prop version)
 preVersion=$(prop preVersion)
 release_tag="$mcversion-$commitid"
 jarName="$project_id-$mcversion-paperclip.jar"
-jarName_bundler="$project_id-$mcversion-bundler.jar"
 jarName_dir="luminol-server/build/libs/$jarName"
-jarName_bundler_dir="luminol-server/build/libs/$jarName_bundler"
 make_latest=$([ $preVersion = "true" ] && echo "false" || echo "true")
 
 mv luminol-server/build/libs/$project_id-paperclip-$grdversion-mojmap.jar $jarName_dir
-mv luminol-server/build/libs/$project_id-bundler-$grdversion-mojmap.jar $jarName_bundler_dir
 
 echo "project_id=$project_id" >> $GITHUB_ENV
 echo "project_id_b=$project_id_b" >> $GITHUB_ENV
@@ -28,5 +25,4 @@ echo "pre=$preVersion" >> $GITHUB_ENV
 echo "tag=$release_tag" >> $GITHUB_ENV
 echo "jar=$jarName" >> $GITHUB_ENV
 echo "jar_dir=$jarName_dir" >> $GITHUB_ENV
-echo "jar_dir_bundler=$jarName_bundler_dir" >> $GITHUB_ENV
 echo "make_latest=$make_latest" >> $GITHUB_ENV