fix: 限制 Paper 冒烟测试退出等待

fix: 避免 Paper 冒烟测试清理竞态
fix: 清理误生成的发布元数据文件
2026-08-16 22:02:58 +08:00 · 2026-08-16 20:28:04 +08:00 · 2026-08-16 20:22:36 +08:00 · 2026-08-16 20:22:10 +08:00 · 2026-08-05 23:20:18 +08:00 · 2026-08-05 00:42:24 +08:00
81 changed files with 3708 additions and 2711 deletions
@@ -0,0 +1,28 @@
+version: 2
+updates:
+  - package-ecosystem: gradle
+    directory: /
+    schedule:
+      interval: weekly
+    open-pull-requests-limit: 5
+    groups:
+      gradle-dependencies:
+        patterns:
+          - "*"
+    ignore:
+      # 最低 Paper API 由版本兼容架构固定管理，不能自动升级为最新服务端版本。
+      - dependency-name: "io.papermc.paper:paper-api"
+      # 稳定发布不接受 paperweight 快照版本。
+      - dependency-name: "io.papermc.paperweight.userdev"
+        versions:
+          - "*-SNAPSHOT"
+
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+    open-pull-requests-limit: 5
+    groups:
+      github-actions:
+        patterns:
+          - "*"
@@ -0,0 +1,79 @@
+name: Build
+
+on:
+  push:
+    branches:
+      - main
+      - 'dev/**'
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: 检出代码
+        uses: actions/checkout@v4
+
+      - name: 设置 Java 25
+        uses: actions/setup-java@v4
+        with:
+          java-version: '25'
+          distribution: temurin
+          cache: gradle
+
+      - name: 验证 Gradle Wrapper
+        uses: gradle/actions/wrapper-validation@v4
+
+      - name: 配置 Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: 授予执行权限
+        run: chmod +x gradlew
+
+      - name: 构建插件
+        run: ./gradlew clean build --no-daemon
+
+      - name: 上传测试产物
+        uses: actions/upload-artifact@v4
+        with:
+          name: EssentialsC-test-build
+          path: build/libs/EssentialsC-*.jar
+          if-no-files-found: error
+
+  paper-smoke-test:
+    name: Paper ${{ matrix.paper }} / Java ${{ matrix.java }}
+    needs: build
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - paper: '1.21.11'
+            java: '21'
+          - paper: '26.1.2'
+            java: '25'
+          - paper: '26.2'
+            java: '25'
+
+    steps:
+      - name: 检出代码
+        uses: actions/checkout@v4
+
+      - name: 设置 Java ${{ matrix.java }}
+        uses: actions/setup-java@v4
+        with:
+          java-version: ${{ matrix.java }}
+          distribution: temurin
+
+      - name: 下载插件产物
+        uses: actions/download-artifact@v4
+        with:
+          name: EssentialsC-test-build
+          path: build/libs
+
+      - name: 启动 Paper 并验证插件
+        run: bash scripts/smoke-test-paper.sh '${{ matrix.paper }}'
@@ -16,21 +16,31 @@ jobs:
      - name: 检出代码
        uses: actions/checkout@v4

-      - name: 设置 Java 21
+      - name: 设置 Java 25
        uses: actions/setup-java@v4
        with:
-          java-version: '21'
+          java-version: '25'
          distribution: 'temurin'
          cache: gradle

      - name: 授予执行权限
        run: chmod +x gradlew

+      - name: 配置 Gradle
+        uses: gradle/actions/setup-gradle@v4
+
      - name: 构建插件
-        run: ./gradlew build
+        shell: bash
+        run: |
+          VERSION="${GITHUB_REF_NAME#v}"
+          if [[ "$VERSION" == "$GITHUB_REF_NAME" || ! "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+([.-][0-9A-Za-z.-]+)?$ ]]; then
+            echo "无效的发布标签: $GITHUB_REF_NAME" >&2
+            exit 1
+          fi
+          ./gradlew clean build --no-daemon -PpluginVersion="$VERSION"

      - name: 创建发行版
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@v2
        with:
          files: build/libs/EssentialsC*.jar
          generate_release_notes: true
@@ -0,0 +1,40 @@
+# 更新日志
+
+## 1.3.1 - 2026-08-16
+
+### 移除
+
+- 移除内置维护模式、相关命令、权限、配置和 LuckPerms 软依赖；维护功能建议使用独立的 Maintenance 插件。
+
+### 调整
+
+- GitHub 仓库迁移至 InfstarMC 组织，并同步更新项目文档与下载地址。
+
+### 升级说明
+
+- 升级时不再读取 `maintenance.yml`；为避免删除管理员数据，服务器目录中的旧文件会原样保留，可在确认迁移完成后手动删除。
+
+## 1.3.0 - 2026-08-05
+
+### 新增
+
+- 按 HuskHomes 的单服逻辑完整实现 TPA 请求、接受、拒绝、忽略、预热、冷却、位置快照、音效与相关权限。
+- 新增维护模式，包括 MOTD、BossBar、登录拦截、白名单、管理员通知和 LuckPerms 异步权限检查。
+- 新增 SkinBridge，可识别 InfstarMC、LittleSkin 与自定义 Blessing Skin Provider，并通过 MineSkin 与 Paper Profile API 同步皮肤。
+- 新增管理模式独立状态存储与玩家功能状态管理。
+
+### 优化
+
+- 按便捷方块、管理、修复与皮肤功能重新整理运行时模块。
+- 完善潜影盒会话保护、TPA 请求队列、配置迁移、数据原子写入与持久化错误处理。
+- 验证兼容 Paper `1.21.11` 与 `26.2`，最终插件保持 Java 21 字节码兼容。
+- 移除实验性的 JEI 配方同步及其版本适配子项目，插件继续通过 Paper 公共 API 兼容支持的服务端版本。
+- 迁移 Paper 弃用 API，并将弃用警告设为构建错误。
+- 统一 HuskHomes 风格的中英文消息、颜色和配置注释。
+
+### 注意事项
+
+- 最低服务端版本为 Paper `1.21.11`，不支持 Folia 或 Fabric 服务端。
+- LuckPerms 为推荐软依赖；未安装时维护模式会在玩家加入后复核绕过权限。
+- SkinBridge 默认关闭，启用前必须配置有效的 MineSkin API Key。
+- 主配置版本为 `2`。
@@ -2,8 +2,8 @@

 轻量、现代、面向 Paper 服务端的基础功能插件，灵感来自 CMI，但更聚焦于常用能力与模块化构建。

-[![Version](https://img.shields.io/github/v/release/Coldsmiles/EssentialsC?style=flat-square)](https://github.com/Coldsmiles/EssentialsC/releases)
-[![License](https://img.shields.io/github/license/Coldsmiles/EssentialsC?style=flat-square)](LICENSE)
+[![Version](https://img.shields.io/github/v/release/InfstarMC/EssentialsC?style=flat-square)](https://github.com/InfstarMC/EssentialsC/releases)
+[![License](https://img.shields.io/github/license/InfstarMC/EssentialsC?style=flat-square)](LICENSE)
 [![Paper](https://img.shields.io/badge/Paper-1.21.11%2B-blue?style=flat-square)](https://papermc.io/)
 [![Java](https://img.shields.io/badge/Java-21-orange?style=flat-square)](https://adoptium.net/)

@@ -11,8 +11,8 @@

 - 最低支持版本为 `Paper 1.21.11`
 - 已适配 `Paper 26.2`
- 构建环境固定为 `Java 21`
- 配置按职责拆分：主行为配置、模块开关、SkinBridge、菜单布局、维护模式和语言文本分别管理
+- 插件统一使用 Paper 公共 API 和 Java 21 字节码，无需按服务端版本拆分构建
+- 配置按职责拆分：主行为与 SkinBridge、模块开关、菜单布局和语言文本分别管理
 - 支持运行期模块开关，避免为不同功能组合构建多个插件版本

 ## 主要功能
@@ -43,70 +43,63 @@
 - `/seen` `(/info)`
 - `/tpsbar`
 - `/essc admin` 管理模式切换
- `/maintenance` `(/maint)` 维护模式管理
+
+### 控制台命令
+
+- `/essc help`、`/essc version`、`/essc reload`
+- `/seen [玩家]`、`/heal [玩家]`、`/feed [玩家]`、`/tpsbar [玩家]`
+- `/essc skin [status|refresh] [玩家]`
+
+依赖发送者位置、背包或玩家交互状态的命令仅允许在游戏内执行。控制台执行玩家状态命令时必须明确提供目标玩家。

 ### 其它功能

 - Shift + 右键快捷打开潜影盒
 - 潜影盒交互保护，尽量避免刷物品、吞物品和嵌套放入问题
 - 管理模式独立背包、装备栏与状态切换
- 维护模式：替换 MOTD、登录拦截、白名单放行和管理员拦截通知
 - Enderman 掉落方块控制
- JEI 配方同步修复

 ## 模块配置

-项目现在默认构建一个完整插件，功能是否启用由 `plugins/EssentialsC/modules.yml` 控制。
+项目默认构建一个完整插件。玩家常用命令、Vanish 与 TPA 属于核心功能，始终加载并通过权限控制；其他可选功能由 `plugins/EssentialsC/modules.yml` 控制。

 | 模块 | 默认状态 | 说明 |
 | --- | --- | --- |
 | `blocks` | 开启 | 便捷方块命令、`/essc blocks` 菜单、潜影盒快捷打开 |
-| `player` | 开启 | 飞行、夜视、发光、治疗、喂食、修复、帽子、自杀、隐身、查询玩家 |
 | `admin-mode` | 开启 | `/essc admin` 管理模式与独立状态保存 |
-| `tpsbar` | 开启 | 插件版 TPSBar，仍受 `config.yml` 中 `tpsbar.mode` 控制 |
-| `jei-sync` | 开启 | Fabric / NeoForge JEI 配方同步修复 |
+| `tpsbar` | 开启 | 插件版 TPSBar，检测到服务端原生命令时自动避免冲突 |
 | `mob-drops` | 关闭 | 末影人掉落控制，默认关闭以保留过去标准版行为 |
-| `maintenance` | 开启 | 维护模式命令、MOTD 替换、登录拦截、白名单和拦截通知 |
 | `skin-bridge` | 关闭 | 查询外置 Yggdrasil profile，并通过 MineSkin 与 Paper Profile API 同步皮肤 |

-修改模块开关后可先使用 `/essc reload` 刷新运行期服务与监听器状态。由于 Bukkit 命令表不适合在运行期完整热增删，若模块是在启动时关闭的，对应直连命令可能仍需重启后才会注册；通过 `/essc <子命令>` 入口通常可立即按新的模块状态执行。
+修改模块开关后使用 `/essc reload` 即可刷新运行期服务、监听器和命令门禁。可选模块命令始终注册，模块关闭时会返回统一的停用提示，因此无需为了启用命令重启服务器。

 ## 安装说明

-1. 从 [Releases](https://github.com/Coldsmiles/EssentialsC/releases) 下载所需版本。
+1. 从 [Releases](https://github.com/InfstarMC/EssentialsC/releases) 下载所需版本。
 2. 将插件放入服务端的 `plugins/` 目录。
 3. 启动一次服务端以生成配置文件。
 4. 按需修改 `plugins/EssentialsC/` 下的配置文件与 `lang/` 语言文件。
-5. 如有需要，使用权限插件为玩家授权。
+5. 使用权限插件为玩家分配所需权限。
+
+维护功能建议独立安装 [Maintenance](https://github.com/kennytv/Maintenance)。EssentialsC 不再内置维护模式，也不要求安装该插件。

 ## 配置说明

 当前配置按功能职责拆分，避免所有设置堆积在一个文件中：

-SkinBridge 默认关闭。使用前需同时启用 `modules.yml` 中的 `modules.skin-bridge.enabled` 和 `skin-bridge.yml` 中的 `enabled`，填写 `mineskin.api-key`，并至少启用一个 Provider。真实密钥只应填写在服务器运行目录的 `skin-bridge.yml` 中，不要写入源码或提交到公开仓库。该模块不要求安装 SkinsRestorer。`send-player-message` 控制是否向玩家发送检测、匹配和同步结果提示；`providers` 下的键名可自由命名，并会显示在日志和 `/essc skin status <玩家>` 中。
+SkinBridge 默认关闭。使用前需启用 `modules.yml` 中的 `modules.skin-bridge.enabled`，填写 `config.yml` 中的 `skin-bridge.mineskin.api-key`，并至少启用一个 Provider。真实密钥只应填写在服务器运行目录的 `config.yml` 中，不要写入源码或提交到公开仓库。该模块不要求安装 SkinsRestorer。默认支持 InfstarMC 与 LittleSkin；Provider 的 `name` 可自由修改，并会显示在日志和 `/essc skin status <玩家>` 中。生成后的 MineSkin 纹理会按皮肤 URL 缓存到 `skin-cache.yml`，并遵守配置的 TTL。

 - `config.yml`
  - 语言选择
  - 管理模式行为
-  - JEI 同步开关
  - 掉落控制
  - TPSBar 模式
  - TPA 请求、预热、冷却和音效
+  - SkinBridge、MineSkin、Provider 与排除名单
 - `modules.yml`
  - 功能模块开关
- `skin-bridge.yml`
-  - MineSkin API 与队列设置
-  - Provider、缓存和检测设置
 - `blocks-menu.yml`
  - 便捷菜单分区、槽位、材质和权限
- `maintenance.yml`
-  - 维护模式状态
-  - 维护 MOTD
-  - 维护踢出提示
-  - 维护 BossBar
-  - 绕过权限
-  - 维护白名单
-  - 拦截通知权限
 - `lang/zh_CN.yml`、`lang/en_US.yml`
  - 命令反馈
  - 帮助信息
@@ -114,7 +107,9 @@ SkinBridge 默认关闭。使用前需同时启用 `modules.yml` 中的 `modules
  - 管理模式文本
  - TPSBar 文本

-配置文件包含 `config-version`。从旧结构升级时，插件会备份主配置，并自动把 SkinBridge 与便捷菜单节点迁移到独立文件。
+主配置当前使用 `config-version: 2`。SkinBridge 直接配置在 `config.yml` 中，便捷菜单配置仍保存在独立文件中。
+
+版本变化与升级说明见 [CHANGELOG.md](CHANGELOG.md)。

 ## 权限示例

@@ -131,6 +126,7 @@ essentialsc.command.heal
 essentialsc.command.feed
 essentialsc.command.repair
 essentialsc.command.vanish
+essentialsc.vanish.see
 essentialsc.command.seen
 essentialsc.command.tpa
 essentialsc.command.tpahere
@@ -144,10 +140,10 @@ essentialsc.tpa.bypass-cooldown
 essentialsc.tpa.warmup.3
 essentialsc.command.admin
 essentialsc.command.tpsbar
-essentialsc.command.maintenance
 essentialsc.command.skin
-essentialsc.maintenance.bypass
-essentialsc.maintenance.notify
+essentialsc.command.skin.status
+essentialsc.command.skin.refresh
+essentialsc.command.skin.others
 essentialsc.shulkerbox.open
 essentialsc.mobdrops.enderman
 essentialsc.*
@@ -158,7 +154,7 @@ essentialsc.*
 ## 从源码构建

 ```bash
-git clone https://github.com/Coldsmiles/EssentialsC.git
+git clone https://github.com/InfstarMC/EssentialsC.git
 cd EssentialsC
 ./gradlew build
 ```
@@ -177,27 +173,28 @@ Windows 可使用：
 ./gradlew shadowJar
 ./gradlew build
 ./gradlew deployToPaper12111
-./gradlew deployToPaper2612
+./gradlew deployToPaper262
+./gradlew deployToLeaves262
 ```

 ## 本地测试服

-项目包含两个本地测试服目录：
+项目包含三个本地测试服目录：

 | 测试服 | 端口 | 部署任务 | 启动脚本 |
 | --- | --- | --- | --- |
 | Paper 1.21.11 | `25566` | `deployToPaper12111` | `test-server/paper-1.21.11/start.bat` |
-| Paper 26.1.2 | `25565` | `deployToPaper2612` | `test-server/paper-26.1.2/start.bat` |
+| Paper 26.2 | `25567` | `deployToPaper262` | `test-server/paper-26.2/start.bat` |
+| Leaves 26.2 | `25568` | `deployToLeaves262` | `test-server/leaves-26.2/start.bat` |

-IDEA 运行配置会在启动测试服前自动执行对应部署任务。部署任务会替换 `EssentialsC*.jar`，并删除 `plugins/EssentialsC` 数据目录，以便测试新增默认配置和语言文本。
+IDEA 运行配置会先构建插件，再由启动脚本复制最新 JAR，并保留插件数据以便测试升级流程。手动执行部署任务会替换 `EssentialsC*.jar` 并删除 `plugins/EssentialsC` 数据目录，用于测试全新安装及默认配置生成。

 ## 开发说明

 - 使用 `paperweight-userdev` 进行 Paper 开发
 - 使用 Paper Lifecycle Command API 注册命令，避免直接反射 Bukkit CommandMap
- 涉及 NMS 的功能通过 `compat-api` + `versions/v<版本>` 适配模块隔离，主插件只依赖稳定接口；当前包含 `1.21.11`、`26.1.2`、`26.2`
- 运行时通过 `modules.yml` 控制模块加载，命令与监听器按模块状态注册
- 发布流程基于 GitHub Actions 和 Gradle Wrapper
+- 运行时通过 `modules.yml` 控制模块加载，命令始终注册并按模块状态执行门禁
+- 普通 push/PR 会执行构建与测试，版本标签继续生成 GitHub Release

 ## 许可证

@@ -205,5 +202,5 @@ IDEA 运行配置会在启动测试服前自动执行对应部署任务。部署

 ## 仓库

- GitHub: <https://github.com/Coldsmiles/EssentialsC>
+- GitHub: <https://github.com/InfstarMC/EssentialsC>
 - Gitea: <https://git.infstar.cn/InfStarMC/EssentialsC>
@@ -1,14 +1,17 @@
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import org.gradle.language.jvm.tasks.ProcessResources
+import org.gradle.api.tasks.testing.Test
+import java.util.zip.ZipFile

 plugins {
    id 'java'
    id 'io.papermc.paperweight.userdev' version '2.0.0-beta.21'
-    id 'com.gradleup.shadow' version '8.3.6'
+    id 'com.gradleup.shadow' version '8.3.11'
 }

 group = 'cn.infstar'
-version = '1.4.0'
+def pluginVersion = providers.gradleProperty('pluginVersion').orElse('1.3.1').get()
+version = pluginVersion

 repositories {
    mavenCentral()
@@ -20,8 +23,10 @@ repositories {

 dependencies {
    paperweight.paperDevBundle('1.21.11-R0.1-SNAPSHOT')
-    implementation project(':compat-api')
    implementation 'com.google.code.gson:gson:2.11.0'
+    testImplementation platform('org.junit:junit-bom:5.13.4')
+    testImplementation 'org.junit.jupiter:junit-jupiter'
+    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 }

 java {
@@ -30,18 +35,25 @@ java {

 paperweight.reobfArtifactConfiguration = io.papermc.paperweight.userdev.ReobfArtifactConfiguration.getMOJANG_PRODUCTION()

-tasks.withType(JavaCompile).configureEach {
-    options.encoding = 'UTF-8'
+allprojects {
+    tasks.withType(JavaCompile).configureEach {
+        options.encoding = 'UTF-8'
+        options.compilerArgs.addAll(['-Xlint:deprecation', '-Werror'])
+    }
 }

 tasks.withType(ProcessResources).configureEach {
    filteringCharset = 'UTF-8'
 }

+tasks.withType(Test).configureEach {
+    useJUnitPlatform()
+}
+
 tasks.named('processResources', ProcessResources).configure {
-    inputs.property('version', project.version)
+    inputs.property('version', pluginVersion)
    filesMatching('paper-plugin.yml') {
-        expand('version': project.version)
+        expand('version': pluginVersion)
    }
 }

@@ -52,24 +64,48 @@ tasks.named('jar').configure {
 tasks.named('shadowJar', ShadowJar).configure {
    group = 'build'
    description = '构建包含全部运行期可开关模块的 EssentialsC 插件。'
-    archiveFileName.set("EssentialsC-${project.version}.jar")
+    archiveFileName.set("EssentialsC-${pluginVersion}.jar")
    configurations = [project.configurations.runtimeClasspath]
-
-    [
-        project(':versions:v1_21_11'),
-        project(':versions:v26_1_2'),
-        project(':versions:v26_2')
-    ].each { adapterProject ->
-        def adapterJar = adapterProject.tasks.named('jar')
-        dependsOn(adapterJar)
-        from(adapterJar.flatMap { it.archiveFile }.map { archiveFile -> zipTree(archiveFile) })
-    }
+    relocate 'com.google.gson', 'cn.infstar.essentialsC.libs.gson'
 }

 tasks.named('assemble').configure {
    dependsOn(tasks.named('shadowJar'))
 }

+tasks.register('verifyJava21Bytecode') {
+    group = 'verification'
+    description = '验证最终插件中的全部 class 均可由 Java 21 加载。'
+    dependsOn(tasks.named('shadowJar'))
+
+    doLast {
+        def artifact = tasks.named('shadowJar', ShadowJar).get().archiveFile.get().asFile
+        def unsupportedClasses = []
+        new ZipFile(artifact).withCloseable { zip ->
+            zip.entries().each { entry ->
+                if (!entry.directory && entry.name.endsWith('.class')) {
+                    zip.getInputStream(entry).withCloseable { input ->
+                        byte[] header = input.readNBytes(8)
+                        if (header.length == 8) {
+                            int majorVersion = ((header[6] & 0xff) << 8) | (header[7] & 0xff)
+                            if (majorVersion > 65) {
+                                unsupportedClasses.add("${entry.name} (class ${majorVersion})")
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (!unsupportedClasses.isEmpty()) {
+            throw new GradleException("检测到无法由 Java 21 加载的类:\n" + unsupportedClasses.join('\n'))
+        }
+    }
+}
+
+tasks.named('check').configure {
+    dependsOn(tasks.named('verifyJava21Bytecode'))
+}
+
 def registerTestServerDeployTask = { String taskName, String serverPath, String serverName ->
    tasks.register(taskName, Copy) {
        group = 'deployment'
@@ -90,5 +126,5 @@ def registerTestServerDeployTask = { String taskName, String serverPath, String
 }

 registerTestServerDeployTask('deployToPaper12111', 'test-server/paper-1.21.11', 'Paper 1.21.11')
-registerTestServerDeployTask('deployToPaper2612', 'test-server/paper-26.1.2', 'Paper 26.1.2')
 registerTestServerDeployTask('deployToPaper262', 'test-server/paper-26.2', 'Paper 26.2')
+registerTestServerDeployTask('deployToLeaves262', 'test-server/leaves-26.2', 'Leaves 26.2')
@@ -1,23 +0,0 @@
-plugins {
-    id 'java-library'
-}
-
-repositories {
-    mavenCentral()
-    maven {
-        name = 'papermc'
-        url = uri('https://repo.papermc.io/repository/maven-public/')
-    }
-}
-
-dependencies {
-    compileOnly 'io.papermc.paper:paper-api:1.21.11-R0.1-SNAPSHOT'
-}
-
-java {
-    toolchain.languageVersion.set(JavaLanguageVersion.of(21))
-}
-
-tasks.withType(JavaCompile).configureEach {
-    options.encoding = 'UTF-8'
-}
@@ -1,12 +0,0 @@
-package cn.infstar.essentialsC.compat.jei;
-
-import org.bukkit.entity.Player;
-
-import java.util.logging.Logger;
-
-public interface JeiRecipeSyncAdapter {
-
-    void sendFabricRecipeSync(Player player, Logger logger, boolean debug) throws Exception;
-
-    void sendNeoForgeRecipeSync(Player player, Logger logger, boolean debug) throws Exception;
-}
@@ -0,0 +1,74 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+paper_version="${1:?必须提供 Paper 版本}"
+workspace="$(mktemp -d)"
+server_pid=""
+plugin_jar="$(find build/libs -maxdepth 1 -type f -name 'EssentialsC-*.jar' -print -quit)"
+if [[ -z "$plugin_jar" ]]; then
+  echo "未找到 EssentialsC 构建产物。" >&2
+  exit 1
+fi
+plugin_filename="$(basename "$plugin_jar")"
+plugin_version="${plugin_filename#EssentialsC-}"
+plugin_version="${plugin_version%.jar}"
+
+cleanup() {
+  if [[ -n "$server_pid" ]] && kill -0 "$server_pid" 2>/dev/null; then
+    kill -TERM "$server_pid" 2>/dev/null || true
+    for _ in $(seq 1 10); do
+      if ! kill -0 "$server_pid" 2>/dev/null; then
+        break
+      fi
+      sleep 1
+    done
+    if kill -0 "$server_pid" 2>/dev/null; then
+      kill -KILL "$server_pid" 2>/dev/null || true
+    fi
+    wait "$server_pid" 2>/dev/null || true
+  fi
+  for _ in 1 2 3; do
+    if rm -rf "$workspace"; then
+      return
+    fi
+    sleep 1
+  done
+  echo "警告：无法完全清理临时测试目录 $workspace" >&2
+}
+trap cleanup EXIT
+
+metadata_url="https://fill.papermc.io/v3/projects/paper/versions/${paper_version}/builds/latest"
+download_url="$(curl --fail --silent --show-error --location "$metadata_url" \
+  | python3 -c 'import json,sys; print(json.load(sys.stdin)["downloads"]["server:default"]["url"])')"
+
+curl --fail --silent --show-error --location "$download_url" --output "$workspace/paper.jar"
+mkdir -p "$workspace/plugins"
+cp "$plugin_jar" "$workspace/plugins/EssentialsC.jar"
+printf 'eula=true\n' > "$workspace/eula.txt"
+printf 'online-mode=false\nserver-port=0\nenable-query=false\n' > "$workspace/server.properties"
+
+(
+  cd "$workspace"
+  exec java -Xms512M -Xmx1G -jar paper.jar --nogui > server.log 2>&1
+) &
+server_pid=$!
+
+for _ in $(seq 1 120); do
+  if grep -Fq "EssentialsC v${plugin_version} 已启用" "$workspace/server.log"; then
+    if grep -Eq 'UnsupportedClassVersionError|Error occurred while enabling EssentialsC|Could not load.*EssentialsC' "$workspace/server.log"; then
+      cat "$workspace/server.log"
+      exit 1
+    fi
+    echo "Paper ${paper_version} 启动验证通过。"
+    exit 0
+  fi
+  if ! kill -0 "$server_pid" 2>/dev/null; then
+    cat "$workspace/server.log"
+    exit 1
+  fi
+  sleep 1
+done
+
+cat "$workspace/server.log"
+echo "Paper ${paper_version} 启动验证超时。" >&2
+exit 1
@@ -20,8 +20,3 @@ plugins {
 }

 rootProject.name = 'EssentialsC'
-
-include 'compat-api'
-include 'versions:v1_21_11'
-include 'versions:v26_1_2'
-include 'versions:v26_2'
@@ -2,17 +2,16 @@ package cn.infstar.essentialsC;

 import cn.infstar.essentialsC.admin.AdminModeManager;
 import cn.infstar.essentialsC.commands.BaseCommand;
+import cn.infstar.essentialsC.commands.BlocksMenuCommand;
 import cn.infstar.essentialsC.commands.CommandRegistry;
 import cn.infstar.essentialsC.commands.HelpCommand;
 import cn.infstar.essentialsC.commands.PaperCommand;
 import cn.infstar.essentialsC.commands.VanishCommand;
-import cn.infstar.essentialsC.listeners.JeiRecipeSyncListener;
 import cn.infstar.essentialsC.listeners.MobDropListener;
 import cn.infstar.essentialsC.listeners.MobDropMenuListener;
 import cn.infstar.essentialsC.listeners.ShulkerBoxListener;
 import cn.infstar.essentialsC.listeners.VanishListener;
-import cn.infstar.essentialsC.maintenance.MaintenanceListener;
-import cn.infstar.essentialsC.maintenance.MaintenanceManager;
+import cn.infstar.essentialsC.player.PlayerStateManager;
 import cn.infstar.essentialsC.skinbridge.SkinBridgeManager;
 import cn.infstar.essentialsC.teleport.TeleportRequestManager;
 import cn.infstar.essentialsC.tpsbar.TpsBarManager;
@@ -21,7 +20,6 @@ import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabCompleter;
 import org.bukkit.event.HandlerList;
 import org.bukkit.event.Listener;
-import org.bukkit.plugin.messaging.Messenger;
 import org.bukkit.plugin.java.JavaPlugin;
 import io.papermc.paper.command.brigadier.BasicCommand;
 import io.papermc.paper.command.brigadier.CommandSourceStack;
@@ -38,12 +36,11 @@ public final class EssentialsC extends JavaPlugin {
    private ModuleManager moduleManager;
    private FeatureConfigManager featureConfigManager;
    private AdminModeManager adminModeManager;
-    private MaintenanceManager maintenanceManager;
    private TeleportRequestManager teleportRequestManager;
-    private MaintenanceListener maintenanceListener;
+    private PlayerStateManager playerStateManager;
    private TpsBarService tpsBarManager;
    private ShulkerBoxListener shulkerBoxListener;
-    private JeiRecipeSyncListener jeiRecipeSyncListener;
+    private BlocksMenuCommand blocksMenuCommandListener;
    private MobDropListener mobDropListener;
    private MobDropMenuListener mobDropMenuListener;
    private VanishListener vanishListener;
@@ -53,9 +50,9 @@ public final class EssentialsC extends JavaPlugin {

    @Override
    public void onEnable() {
+        featureConfigManager = new FeatureConfigManager(this);
        langManager = new LangManager(this);
        moduleManager = new ModuleManager(this);
-        featureConfigManager = new FeatureConfigManager(this);

        reloadRuntimeModules();
        registerCommands();
@@ -71,18 +68,23 @@ public final class EssentialsC extends JavaPlugin {
        if (adminModeManager != null) {
            adminModeManager.shutdown();
        }
-        if (maintenanceManager != null) {
-            maintenanceManager.shutdown();
-        }
        if (teleportRequestManager != null) {
            teleportRequestManager.shutdown();
        }
+        if (playerStateManager != null) {
+            playerStateManager.shutdown();
+        }
        if (skinBridgeManager != null) {
            skinBridgeManager.shutdown();
        }
+        if (shulkerBoxListener != null) {
+            shulkerBoxListener.shutdown();
+        }
+        if (vanishListener != null) {
+            vanishListener.shutdown();
+        }
        VanishCommand.clearAll(this);
        unregisterRuntimeListeners();
-        unregisterPluginChannels();
        getLogger().info("EssentialsC 已禁用。");
    }

@@ -102,14 +104,14 @@ public final class EssentialsC extends JavaPlugin {
        return featureConfigManager;
    }

-    public MaintenanceManager getMaintenanceManager() {
-        return maintenanceManager;
-    }
-
    public TeleportRequestManager getTeleportRequestManager() {
        return teleportRequestManager;
    }

+    public PlayerStateManager getPlayerStateManager() {
+        return playerStateManager;
+    }
+
    public TpsBarService getTpsBarManager() {
        return tpsBarManager;
    }
@@ -120,32 +122,19 @@ public final class EssentialsC extends JavaPlugin {

    public void reloadRuntimeModules() {
        moduleStatus.clear();
-        refreshPlayer();
+        refreshCorePlayerFeatures();
        refreshAdminMode();
-        refreshMaintenance();
        refreshTpsBar();
        refreshBlocks();
-        refreshJeiSync();
        refreshMobDrops();
        refreshSkinBridge();
    }

-    private void refreshPlayer() {
-        if (!moduleManager.isEnabled(ModuleManager.PLAYER)) {
-            if (teleportRequestManager != null) {
-                teleportRequestManager.shutdown();
-                HandlerList.unregisterAll(teleportRequestManager);
-                teleportRequestManager = null;
-            }
-            VanishCommand.clearAll(this);
-            if (vanishListener != null) {
-                HandlerList.unregisterAll(vanishListener);
-                vanishListener = null;
-            }
-            setModuleStatus("玩家功能", false, "已禁用");
-            return;
+    private void refreshCorePlayerFeatures() {
+        if (playerStateManager == null) {
+            playerStateManager = new PlayerStateManager(this);
+            getServer().getPluginManager().registerEvents(playerStateManager, this);
        }
-
        if (vanishListener == null) {
            vanishListener = new VanishListener(this);
            getServer().getPluginManager().registerEvents(vanishListener, this);
@@ -156,7 +145,6 @@ public final class EssentialsC extends JavaPlugin {
        } else {
            teleportRequestManager.reload();
        }
-        setModuleStatus("玩家功能", true, "命令可用");
    }

    private void refreshAdminMode() {
@@ -173,36 +161,12 @@ public final class EssentialsC extends JavaPlugin {
        if (adminModeManager == null) {
            adminModeManager = new AdminModeManager(this);
            getServer().getPluginManager().registerEvents(adminModeManager, this);
+        } else {
+            adminModeManager.reload();
        }
        setModuleStatus("管理模式", true, "监听器已注册");
    }

-    private void refreshMaintenance() {
-        if (!moduleManager.isEnabled(ModuleManager.MAINTENANCE)) {
-            if (maintenanceManager != null) {
-                maintenanceManager.shutdown();
-                maintenanceManager = null;
-            }
-            if (maintenanceListener != null) {
-                HandlerList.unregisterAll(maintenanceListener);
-                maintenanceListener = null;
-            }
-            setModuleStatus("维护模式", false, "已禁用");
-            return;
-        }
-
-        if (maintenanceManager == null) {
-            maintenanceManager = new MaintenanceManager(this);
-        } else {
-            maintenanceManager.reload();
-        }
-        if (maintenanceListener == null) {
-            maintenanceListener = new MaintenanceListener(this);
-            getServer().getPluginManager().registerEvents(maintenanceListener, this);
-        }
-        setModuleStatus("维护模式", true, maintenanceManager.isEnabled() ? "当前开启" : "当前关闭");
-    }
-
    private void refreshTpsBar() {
        if (!moduleManager.isEnabled(ModuleManager.TPSBAR)) {
            if (tpsBarManager != null) {
@@ -235,7 +199,12 @@ public final class EssentialsC extends JavaPlugin {

    private void refreshBlocks() {
        if (!moduleManager.isEnabled(ModuleManager.BLOCKS)) {
+            if (blocksMenuCommandListener != null) {
+                HandlerList.unregisterAll(blocksMenuCommandListener);
+                blocksMenuCommandListener = null;
+            }
            if (shulkerBoxListener != null) {
+                shulkerBoxListener.shutdown();
                HandlerList.unregisterAll(shulkerBoxListener);
                shulkerBoxListener = null;
            }
@@ -247,27 +216,16 @@ public final class EssentialsC extends JavaPlugin {
            shulkerBoxListener = new ShulkerBoxListener(this);
            getServer().getPluginManager().registerEvents(shulkerBoxListener, this);
        }
+        if (blocksMenuCommandListener == null) {
+            BaseCommand command = CommandRegistry.getCommand("blocks");
+            if (command instanceof BlocksMenuCommand blocksMenuCommand) {
+                blocksMenuCommandListener = blocksMenuCommand;
+                getServer().getPluginManager().registerEvents(blocksMenuCommandListener, this);
+            }
+        }
        setModuleStatus("便捷方块", true, "命令和潜影盒监听器已启用");
    }

-    private void refreshJeiSync() {
-        if (jeiRecipeSyncListener != null) {
-            HandlerList.unregisterAll(jeiRecipeSyncListener);
-            jeiRecipeSyncListener = null;
-        }
-        unregisterPluginChannels();
-
-        if (!moduleManager.isEnabled(ModuleManager.JEI_SYNC)) {
-            setModuleStatus("JEI 同步", false, "已禁用");
-            return;
-        }
-
-        registerPluginChannels();
-        jeiRecipeSyncListener = new JeiRecipeSyncListener(this);
-        getServer().getPluginManager().registerEvents(jeiRecipeSyncListener, this);
-        setModuleStatus("JEI 同步", true, "插件消息通道已注册");
-    }
-
    private void refreshMobDrops() {
        if (!moduleManager.isEnabled(ModuleManager.MOB_DROPS)) {
            if (mobDropListener != null) {
@@ -290,6 +248,7 @@ public final class EssentialsC extends JavaPlugin {
        }
        if (mobDropMenuListener == null) {
            mobDropMenuListener = new MobDropMenuListener(this);
+            getServer().getPluginManager().registerEvents(mobDropMenuListener, this);
        }
        setModuleStatus("生物掉落", true, "末影人掉落控制已启用");
    }
@@ -314,27 +273,15 @@ public final class EssentialsC extends JavaPlugin {
        setModuleStatus("皮肤桥接", true, skinBridgeManager.getModuleDetail());
    }

-    private void registerPluginChannels() {
-        Messenger messenger = getServer().getMessenger();
-        messenger.registerOutgoingPluginChannel(this, "fabric:recipe_sync");
-        messenger.registerOutgoingPluginChannel(this, "neoforge:recipe_content");
-    }
-
-    private void unregisterPluginChannels() {
-        Messenger messenger = getServer().getMessenger();
-        messenger.unregisterOutgoingPluginChannel(this, "fabric:recipe_sync");
-        messenger.unregisterOutgoingPluginChannel(this, "neoforge:recipe_content");
-    }
-
    private void unregisterRuntimeListeners() {
        unregisterListener(adminModeManager);
-        unregisterListener(maintenanceListener);
        unregisterListener(shulkerBoxListener);
-        unregisterListener(jeiRecipeSyncListener);
+        unregisterListener(blocksMenuCommandListener);
        unregisterListener(mobDropListener);
        unregisterListener(mobDropMenuListener);
        unregisterListener(vanishListener);
        unregisterListener(teleportRequestManager);
+        unregisterListener(playerStateManager);
        unregisterListener(skinBridgeManager);
        if (tpsBarManager instanceof Listener listener) {
            unregisterListener(listener);
@@ -357,7 +304,7 @@ public final class EssentialsC extends JavaPlugin {
            .count();
        long disabledCount = moduleStatus.size() - enabledCount;

-        getLogger().info("EssentialsC v" + getDescription().getVersion()
+        getLogger().info("EssentialsC v" + getPluginMeta().getVersion()
            + " 已启用 | 模块: " + enabledCount + " 启用, " + disabledCount + " 关闭");

        if (!getConfig().getBoolean("debug", false)) {
@@ -380,7 +327,7 @@ public final class EssentialsC extends JavaPlugin {
                if (!spec.standalone()) {
                    continue;
                }
-                BaseCommand executor = CommandRegistry.getCommand(spec.name());
+                BaseCommand executor = CommandRegistry.getRegisteredCommand(spec.name());
                if (executor == null) {
                    continue;
                }
@@ -426,9 +373,15 @@ public final class EssentialsC extends JavaPlugin {
        @Override
        public Collection<String> suggest(CommandSourceStack commandSourceStack, String[] args) {
            if (executor instanceof TabCompleter completer) {
-                return completer.onTabComplete(commandSourceStack.getSender(), commandAdapter, name, args);
+                String[] completionArgs = args.length == 0 ? new String[]{""} : args;
+                return completer.onTabComplete(commandSourceStack.getSender(), commandAdapter, name, completionArgs);
            }
            return List.of();
        }
+
+        @Override
+        public String permission() {
+            return "essentialsc".equals(name) ? null : executor.getPermission();
+        }
    }
 }
@@ -1,6 +1,8 @@
 package cn.infstar.essentialsC;

+import cn.infstar.essentialsC.util.AtomicYamlWriter;
 import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.InvalidConfigurationException;
 import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.configuration.file.YamlConfiguration;

@@ -9,104 +11,139 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;

 /**
- * 管理体积较大的独立功能配置，并负责从旧版 config.yml 迁移数据。
+ * 管理主配置与独立功能配置，并负责按顺序执行配置迁移。
 */
 public final class FeatureConfigManager {

    private static final int MAIN_CONFIG_VERSION = 2;

    private final EssentialsC plugin;
-    private final File skinBridgeFile;
+    private final File mainConfigFile;
    private final File blocksMenuFile;
-    private FileConfiguration skinBridgeConfig;
    private FileConfiguration blocksMenuConfig;

    public FeatureConfigManager(EssentialsC plugin) {
        this.plugin = plugin;
-        this.skinBridgeFile = new File(plugin.getDataFolder(), "skin-bridge.yml");
+        this.mainConfigFile = new File(plugin.getDataFolder(), "config.yml");
        this.blocksMenuFile = new File(plugin.getDataFolder(), "blocks-menu.yml");
        reload();
    }

    public void reload() {
-        ensureResource(skinBridgeFile, "skin-bridge.yml");
+        ensureResource(mainConfigFile, "config.yml");
        ensureResource(blocksMenuFile, "blocks-menu.yml");

-        skinBridgeConfig = loadWithDefaults(skinBridgeFile, "skin-bridge.yml");
        blocksMenuConfig = loadWithDefaults(blocksMenuFile, "blocks-menu.yml");
-        migrateLegacyMainConfig();
-        migrateLegacyDebugSettings();
-        updateMainConfigVersion();
-        saveSkinBridgeConfig();
-        saveBlocksMenuConfig();
-    }
+        YamlConfiguration loadedMainConfig = loadWithDefaults(mainConfigFile, "config.yml");
+        YamlConfiguration mainConfig = migrateMainConfigVersion(loadedMainConfig);

-    public FileConfiguration getSkinBridgeConfig() {
-        return skinBridgeConfig;
+        boolean mainChanged = mainConfig != loadedMainConfig;
+        mainChanged |= migrateLegacyMainConfig(mainConfig);
+        mainChanged |= migrateLegacyDebugSettings(mainConfig);
+        mainChanged |= removeRetiredJeiSettings(mainConfig);
+        if (mainConfig.getInt("config-version", 0) != MAIN_CONFIG_VERSION) {
+            mainConfig.set("config-version", MAIN_CONFIG_VERSION);
+            mainChanged = true;
+        }
+
+        if (mainChanged) {
+            save(mainConfig, mainConfigFile);
+        }
+        plugin.reloadConfig();
    }

    public FileConfiguration getBlocksMenuConfig() {
        return blocksMenuConfig;
    }

-    public void saveSkinBridgeConfig() {
-        save(skinBridgeConfig, skinBridgeFile);
-    }
-
    public void saveBlocksMenuConfig() {
        save(blocksMenuConfig, blocksMenuFile);
    }

-    private void migrateLegacyMainConfig() {
-        FileConfiguration mainConfig = plugin.getConfig();
-        boolean migrated = false;
-
-        if (mainConfig.contains("skin-bridge", true)) {
-            copySection(mainConfig.getConfigurationSection("skin-bridge"), skinBridgeConfig);
-            mainConfig.set("skin-bridge", null);
-            migrated = true;
+    public boolean updateMainConfigValue(String path, Object value) {
+        YamlConfiguration mainConfig = loadWithDefaults(mainConfigFile, "config.yml");
+        mainConfig.set(path, value);
+        if (!save(mainConfig, mainConfigFile)) {
+            return false;
        }
-        if (mainConfig.contains("blocks-menu", true)) {
-            copySection(mainConfig.getConfigurationSection("blocks-menu"), blocksMenuConfig);
-            mainConfig.set("blocks-menu", null);
-            migrated = true;
-        }
-
-        if (!migrated) {
-            return;
-        }
-
-        mainConfig.set("config-version", MAIN_CONFIG_VERSION);
-        plugin.saveConfig();
-        plugin.getLogger().info("已将 SkinBridge 与便捷菜单配置迁移到独立配置文件。");
+        plugin.getConfig().set(path, value);
+        return true;
    }

-    private void migrateLegacyDebugSettings() {
-        FileConfiguration mainConfig = plugin.getConfig();
+    private YamlConfiguration migrateMainConfigVersion(YamlConfiguration existingConfig) {
+        int existingVersion = existingConfig.getInt("config-version", 0);
+        if (existingVersion >= MAIN_CONFIG_VERSION) {
+            return existingConfig;
+        }
+
+        File backupFile = new File(plugin.getDataFolder(),
+            "config.v" + existingVersion + ".bak-" + System.currentTimeMillis() + ".yml");
+        try {
+            Files.copy(mainConfigFile.toPath(), backupFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
+            YamlConfiguration migratedConfig = loadResource("config.yml");
+            if (migratedConfig == null) {
+                existingConfig.set("config-version", MAIN_CONFIG_VERSION);
+                return existingConfig;
+            }
+
+            for (String path : existingConfig.getKeys(true)) {
+                boolean legacyFeaturePath = path.startsWith("skin-bridge.") || path.startsWith("blocks-menu.");
+                if (!existingConfig.isConfigurationSection(path)
+                    && (migratedConfig.contains(path) || legacyFeaturePath)) {
+                    migratedConfig.set(path, existingConfig.get(path));
+                }
+            }
+            migratedConfig.set("config-version", MAIN_CONFIG_VERSION);
+            plugin.getLogger().info("已将 config.yml 从版本 " + existingVersion
+                + " 迁移到 " + MAIN_CONFIG_VERSION + "，备份文件: " + backupFile.getName());
+            return migratedConfig;
+        } catch (IOException exception) {
+            plugin.getLogger().severe("迁移 config.yml 失败: " + exception.getMessage());
+            return existingConfig;
+        }
+    }
+
+    private boolean migrateLegacyMainConfig(FileConfiguration mainConfig) {
+        if (!mainConfig.contains("blocks-menu", true)) {
+            return false;
+        }
+
+        copySection(mainConfig.getConfigurationSection("blocks-menu"), blocksMenuConfig);
+        mainConfig.set("blocks-menu", null);
+        saveBlocksMenuConfig();
+        plugin.getLogger().info("已将便捷菜单配置迁移到 blocks-menu.yml。");
+        return true;
+    }
+
+    private boolean migrateLegacyDebugSettings(FileConfiguration mainConfig) {
        boolean hasJeiDebug = mainConfig.contains("jei-sync.debug", true);
-        boolean hasSkinBridgeDebug = skinBridgeConfig.contains("debug", true);
+        boolean hasSkinBridgeDebug = mainConfig.contains("skin-bridge.debug", true);
        if (!hasJeiDebug && !hasSkinBridgeDebug) {
-            return;
+            return false;
        }

        boolean debugEnabled = mainConfig.getBoolean("debug", false)
            || mainConfig.getBoolean("jei-sync.debug", false)
-            || skinBridgeConfig.getBoolean("debug", false);
+            || mainConfig.getBoolean("skin-bridge.debug", false);
        mainConfig.set("debug", debugEnabled);
        mainConfig.set("jei-sync.debug", null);
-        skinBridgeConfig.set("debug", null);
-        plugin.saveConfig();
+        mainConfig.set("skin-bridge.debug", null);
        plugin.getLogger().info("已将独立功能调试开关合并到 config.yml 的全局 debug。");
+        return true;
    }

-    private void updateMainConfigVersion() {
-        if (plugin.getConfig().getInt("config-version", 0) >= MAIN_CONFIG_VERSION) {
-            return;
+    private boolean removeRetiredJeiSettings(FileConfiguration mainConfig) {
+        if (!mainConfig.contains("jei-sync", true)) {
+            return false;
        }
-        plugin.getConfig().set("config-version", MAIN_CONFIG_VERSION);
-        plugin.saveConfig();
+
+        mainConfig.set("jei-sync", null);
+        plugin.getLogger().info("已从 config.yml 移除停用的 JEI 配方同步配置。");
+        return true;
    }

    private void copySection(ConfigurationSection source, FileConfiguration target) {
@@ -120,30 +157,59 @@ public final class FeatureConfigManager {
        }
    }

-    private FileConfiguration loadWithDefaults(File file, String resourcePath) {
-        YamlConfiguration config = YamlConfiguration.loadConfiguration(file);
-        InputStream defaultsStream = plugin.getResource(resourcePath);
-        if (defaultsStream != null) {
-            YamlConfiguration defaults = YamlConfiguration.loadConfiguration(
-                new InputStreamReader(defaultsStream, StandardCharsets.UTF_8)
-            );
+    private YamlConfiguration loadWithDefaults(File file, String resourcePath) {
+        YamlConfiguration config = loadFile(file);
+        YamlConfiguration defaults = loadResource(resourcePath);
+        if (defaults != null) {
            config.setDefaults(defaults);
            config.options().copyDefaults(true);
        }
        return config;
    }

+    private YamlConfiguration loadFile(File file) {
+        YamlConfiguration config = new YamlConfiguration();
+        config.options().parseComments(true);
+        try {
+            config.load(file);
+        } catch (IOException | InvalidConfigurationException exception) {
+            plugin.getLogger().severe("加载 " + file.getName() + " 失败: " + exception.getMessage());
+            throw new IllegalStateException("无法加载 " + file.getName() + "，请修复配置格式后重试。", exception);
+        }
+        return config;
+    }
+
+    private YamlConfiguration loadResource(String resourcePath) {
+        InputStream resource = plugin.getResource(resourcePath);
+        if (resource == null) {
+            return null;
+        }
+
+        YamlConfiguration config = new YamlConfiguration();
+        config.options().parseComments(true);
+        try (InputStream input = resource;
+             InputStreamReader reader = new InputStreamReader(input, StandardCharsets.UTF_8)) {
+            config.load(reader);
+            return config;
+        } catch (IOException | InvalidConfigurationException exception) {
+            plugin.getLogger().severe("加载内置资源 " + resourcePath + " 失败: " + exception.getMessage());
+            return null;
+        }
+    }
+
    private void ensureResource(File file, String resourcePath) {
        if (!file.exists()) {
            plugin.saveResource(resourcePath, false);
        }
    }

-    private void save(FileConfiguration config, File file) {
+    private boolean save(FileConfiguration config, File file) {
        try {
-            config.save(file);
-        } catch (IOException exception) {
+            AtomicYamlWriter.save(config, file);
+            return true;
+        } catch (Exception exception) {
            plugin.getLogger().warning("保存 " + file.getName() + " 失败: " + exception.getMessage());
+            return false;
        }
    }
 }
@@ -3,7 +3,6 @@ package cn.infstar.essentialsC;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
-import org.bukkit.ChatColor;
 import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.plugin.java.JavaPlugin;
@@ -13,8 +12,6 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.StandardCopyOption;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -23,9 +20,13 @@ import java.util.regex.Pattern;

 public class LangManager {

-    private static final int CURRENT_CONFIG_VERSION = 3;
    private static final Pattern HEX_COLOR_PATTERN = Pattern.compile("(?i)&#([0-9a-f]{6})");
+    private static final Pattern MINI_MESSAGE_TAG_PATTERN = Pattern.compile(
+        "(?<!\\\\)(</?)([A-Za-z][A-Za-z0-9_-]*)(?=[:>])"
+    );
    private static final MiniMessage MINI_MESSAGE = MiniMessage.miniMessage();
+    private static final LegacyComponentSerializer LEGACY_AMPERSAND = LegacyComponentSerializer.legacyAmpersand();
+    private static final LegacyComponentSerializer LEGACY_SECTION = LegacyComponentSerializer.legacySection();
    private static final Map<String, String> THEME_COLORS = Map.of(
        "&a", "&#00fb9a",
        "&b", "&#5286ff",
@@ -36,13 +37,11 @@ public class LangManager {
    );

    private final JavaPlugin plugin;
-    private FileConfiguration config;
    private FileConfiguration langFile;
    private String currentLanguage;

    public LangManager(JavaPlugin plugin) {
        this.plugin = plugin;
-        loadConfig();
        loadLanguage();
    }

@@ -73,8 +72,7 @@ public class LangManager {
    public Component getComponent(String path, Map<String, String> placeholders) {
        String value = langFile.getString(path);
        if (value == null) {
-            return LegacyComponentSerializer.legacySection()
-                .deserialize(translateColorCodes("&c缺少语言文本: " + path));
+            return LEGACY_SECTION.deserialize(translateColorCodes("&c缺少语言文本: " + path));
        }

        return renderToComponent(applyPlaceholders(value, placeholders));
@@ -87,8 +85,7 @@ public class LangManager {
    public Component getPrefixedComponent(String path, Map<String, String> placeholders) {
        String value = langFile.getString(path);
        if (value == null) {
-            return LegacyComponentSerializer.legacySection()
-                .deserialize(getPrefix() + translateColorCodes("&c缺少语言文本: " + path));
+            return LEGACY_SECTION.deserialize(getPrefix() + translateColorCodes("&c缺少语言文本: " + path));
        }
        return renderToComponent(langFile.getString("prefix", "") + applyPlaceholders(value, placeholders));
    }
@@ -115,7 +112,6 @@ public class LangManager {
    }

    public void reload() {
-        loadConfig();
        loadLanguage();
    }

@@ -123,71 +119,8 @@ public class LangManager {
        return currentLanguage;
    }

-    private void loadConfig() {
-        File configFile = new File(plugin.getDataFolder(), "config.yml");
-        if (!configFile.exists()) {
-            plugin.saveResource("config.yml", false);
-        }
-
-        migrateConfigIfNeeded(configFile);
-        config = YamlConfiguration.loadConfiguration(configFile);
-        config.addDefault("config-version", CURRENT_CONFIG_VERSION);
-        config.addDefault("language", "zh_CN");
-        config.addDefault("debug", false);
-        config.options().copyDefaults(true);
-
-        try {
-            config.save(configFile);
-        } catch (Exception e) {
-            plugin.getLogger().severe("保存 config.yml 失败: " + e.getMessage());
-        }
-    }
-
-    private void migrateConfigIfNeeded(File configFile) {
-        FileConfiguration existingConfig = YamlConfiguration.loadConfiguration(configFile);
-        int existingVersion = existingConfig.getInt("config-version", 0);
-        if (existingVersion >= CURRENT_CONFIG_VERSION) {
-            return;
-        }
-
-        File backupFile = new File(plugin.getDataFolder(),
-            "config.v" + existingVersion + ".bak-" + System.currentTimeMillis() + ".yml");
-
-        try {
-            Files.copy(configFile.toPath(), backupFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
-            InputStream defaultConfigStream = plugin.getResource("config.yml");
-            if (defaultConfigStream != null) {
-                YamlConfiguration migratedConfig = YamlConfiguration.loadConfiguration(
-                    new InputStreamReader(defaultConfigStream, StandardCharsets.UTF_8)
-                );
-                for (String path : existingConfig.getKeys(true)) {
-                    boolean migratedFeaturePath = path.startsWith("skin-bridge.") || path.startsWith("blocks-menu.");
-                    if (!existingConfig.isConfigurationSection(path)
-                        && (migratedConfig.contains(path) || migratedFeaturePath)) {
-                        migratedConfig.set(path, existingConfig.get(path));
-                    }
-                }
-                boolean debugEnabled = existingConfig.getBoolean("debug", false)
-                    || existingConfig.getBoolean("jei-sync.debug", false)
-                    || existingConfig.getBoolean("skin-bridge.debug", false);
-                migratedConfig.set("debug", debugEnabled);
-                migratedConfig.set("jei-sync.debug", null);
-                migratedConfig.set("config-version", CURRENT_CONFIG_VERSION);
-                migratedConfig.save(configFile);
-            } else {
-                existingConfig.set("config-version", CURRENT_CONFIG_VERSION);
-                existingConfig.save(configFile);
-            }
-
-            plugin.getLogger().info("已将 config.yml 从版本 " + existingVersion
-                + " 迁移到 " + CURRENT_CONFIG_VERSION + "，备份文件: " + backupFile.getName());
-        } catch (IOException e) {
-            plugin.getLogger().severe("迁移 config.yml 失败: " + e.getMessage());
-        }
-    }
-
    private void loadLanguage() {
-        currentLanguage = config.getString("language", "zh_CN");
+        currentLanguage = plugin.getConfig().getString("language", "zh_CN");

        File langFolder = new File(plugin.getDataFolder(), "lang");
        if (!langFolder.exists() && !langFolder.mkdirs()) {
@@ -231,18 +164,25 @@ public class LangManager {
        langFile.setDefaults(selectedDefaults);
    }

-    private String applyPlaceholders(String value, Map<String, String> placeholders) {
+    static String applyPlaceholders(String value, Map<String, String> placeholders) {
        String result = value;
+        boolean miniMessage = looksLikeMiniMessage(value);
        for (Map.Entry<String, String> entry : placeholders.entrySet()) {
-            result = result.replace("{" + entry.getKey() + "}", escapeMiniMessageReplacement(entry.getValue()));
+            String replacement = miniMessage
+                ? escapeMiniMessageReplacement(entry.getValue())
+                : entry.getValue();
+            result = result.replace("{" + entry.getKey() + "}", replacement == null ? "" : replacement);
        }
        return result;
    }

-    private String escapeMiniMessageReplacement(String value) {
+    static String escapeMiniMessageReplacement(String value) {
        if (value == null) {
            return "";
        }
+        if (value.indexOf('§') >= 0) {
+            return MINI_MESSAGE.serialize(LEGACY_SECTION.deserialize(value));
+        }
        return value.replace("\\", "\\\\").replace("<", "\\<");
    }

@@ -255,7 +195,7 @@ public class LangManager {
        for (Map.Entry<String, String> color : THEME_COLORS.entrySet()) {
            themedText = themedText.replace(color.getKey(), color.getValue());
        }
-        return ChatColor.translateAlternateColorCodes('&', expandHexColors(themedText));
+        return LEGACY_SECTION.serialize(LEGACY_AMPERSAND.deserialize(expandHexColors(themedText)));
    }

    private String expandHexColors(String text) {
@@ -274,7 +214,7 @@ public class LangManager {
    }

    private String renderToLegacy(String text) {
-        return LegacyComponentSerializer.legacySection().serialize(renderToComponent(text));
+        return LEGACY_SECTION.serialize(renderToComponent(text));
    }

    private Component renderToComponent(String text) {
@@ -283,16 +223,28 @@ public class LangManager {
        }
        if (looksLikeMiniMessage(text)) {
            try {
-                return MINI_MESSAGE.deserialize(text);
+                return MINI_MESSAGE.deserialize(normalizeMiniMessageTags(text));
            } catch (RuntimeException ignored) {
                // 配置中 MiniMessage 语法错误时回退到旧颜色码解析，避免消息完全不可用。
            }
        }
-        return LegacyComponentSerializer.legacySection().deserialize(translateColorCodes(text));
+        return LEGACY_SECTION.deserialize(translateColorCodes(text));
    }

-    private boolean looksLikeMiniMessage(String text) {
+    private static boolean looksLikeMiniMessage(String text) {
        int open = text.indexOf('<');
        return open >= 0 && text.indexOf('>', open) > open;
    }
+
+    static String normalizeMiniMessageTags(String text) {
+        Matcher matcher = MINI_MESSAGE_TAG_PATTERN.matcher(text);
+        StringBuilder result = new StringBuilder();
+        while (matcher.find()) {
+            matcher.appendReplacement(result, Matcher.quoteReplacement(
+                matcher.group(1) + matcher.group(2).toLowerCase(java.util.Locale.ROOT)
+            ));
+        }
+        matcher.appendTail(result);
+        return result.toString();
+    }
 }
@@ -1,6 +1,8 @@
 package cn.infstar.essentialsC;

+import cn.infstar.essentialsC.util.AtomicYamlWriter;
 import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.InvalidConfigurationException;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.plugin.java.JavaPlugin;

@@ -14,24 +16,18 @@ public final class ModuleManager {
    private static final int CURRENT_CONFIG_VERSION = 1;

    public static final String BLOCKS = "blocks";
-    public static final String PLAYER = "player";
    public static final String ADMIN_MODE = "admin-mode";
    public static final String TPSBAR = "tpsbar";
-    public static final String JEI_SYNC = "jei-sync";
    public static final String MOB_DROPS = "mob-drops";
-    public static final String MAINTENANCE = "maintenance";
    public static final String SKIN_BRIDGE = "skin-bridge";

    private static final Map<String, Boolean> DEFAULT_MODULES = new LinkedHashMap<>();

    static {
        DEFAULT_MODULES.put(BLOCKS, true);
-        DEFAULT_MODULES.put(PLAYER, true);
        DEFAULT_MODULES.put(ADMIN_MODE, true);
        DEFAULT_MODULES.put(TPSBAR, true);
-        DEFAULT_MODULES.put(JEI_SYNC, true);
        DEFAULT_MODULES.put(MOB_DROPS, false);
-        DEFAULT_MODULES.put(MAINTENANCE, true);
        DEFAULT_MODULES.put(SKIN_BRIDGE, false);
    }

@@ -50,13 +46,36 @@ public final class ModuleManager {
            plugin.saveResource("modules.yml", false);
        }

-        modulesConfig = YamlConfiguration.loadConfiguration(modulesFile);
+        YamlConfiguration loaded = new YamlConfiguration();
+        loaded.options().parseComments(true);
+        try {
+            loaded.load(modulesFile);
+        } catch (IOException | InvalidConfigurationException exception) {
+            plugin.getLogger().severe("加载 modules.yml 失败: " + exception.getMessage());
+            throw new IllegalStateException("无法加载 modules.yml，请修复配置格式后重试。", exception);
+        }
+        modulesConfig = loaded;
+        boolean removedRetiredModules = false;
+        for (String retiredModule : new String[]{"jei-sync", "maintenance"}) {
+            String retiredPath = "modules." + retiredModule;
+            if (modulesConfig.contains(retiredPath, true)) {
+                modulesConfig.set(retiredPath, null);
+                removedRetiredModules = true;
+            }
+        }
        modulesConfig.addDefault("config-version", CURRENT_CONFIG_VERSION);
        for (Map.Entry<String, Boolean> module : DEFAULT_MODULES.entrySet()) {
            modulesConfig.addDefault(path(module.getKey()), module.getValue());
        }
        modulesConfig.options().copyDefaults(true);
-        save();
+        if (removedRetiredModules) {
+            try {
+                AtomicYamlWriter.save(modulesConfig, modulesFile);
+                plugin.getLogger().info("已从 modules.yml 移除退役功能的配置项。");
+            } catch (IOException exception) {
+                plugin.getLogger().warning("清理 modules.yml 中的退役配置失败: " + exception.getMessage());
+            }
+        }
    }

    public boolean isEnabled(String moduleKey) {
@@ -70,11 +89,4 @@ public final class ModuleManager {
        return "modules." + moduleKey + ".enabled";
    }

-    private void save() {
-        try {
-            modulesConfig.save(modulesFile);
-        } catch (IOException e) {
-            plugin.getLogger().warning("保存 modules.yml 失败: " + e.getMessage());
-        }
-    }
 }
@@ -14,8 +14,6 @@ import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.PlayerInventory;
 import org.bukkit.scheduler.BukkitTask;

-import java.io.File;
-import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashSet;
@@ -28,8 +26,7 @@ public final class AdminModeManager implements Listener {
    private static final float VANILLA_FLY_SPEED = 0.1F;

    private final EssentialsC plugin;
-    private final File dataFile;
-    private final YamlConfiguration data;
+    private final AdminModeStore store;
    private final Set<UUID> activePlayers = new HashSet<>();

    private BukkitTask actionBarTask;
@@ -37,8 +34,24 @@ public final class AdminModeManager implements Listener {
    public AdminModeManager(EssentialsC plugin) {
        this.plugin = plugin;
        addConfigDefaults();
-        this.dataFile = new File(plugin.getDataFolder(), "admin-mode.yml");
-        this.data = YamlConfiguration.loadConfiguration(dataFile);
+        this.store = new AdminModeStore(plugin);
+    }
+
+    public void reload() {
+        if (actionBarTask != null) {
+            actionBarTask.cancel();
+            actionBarTask = null;
+        }
+        float flySpeed = getAdminFlySpeed();
+        for (UUID uuid : new ArrayList<>(activePlayers)) {
+            Player player = plugin.getServer().getPlayer(uuid);
+            if (player != null && player.isOnline()) {
+                player.setFlySpeed(flySpeed);
+            }
+        }
+        if (!activePlayers.isEmpty()) {
+            startActionBarTask();
+        }
    }

    public boolean isAdminMode(Player player) {
@@ -65,21 +78,37 @@ public final class AdminModeManager implements Listener {
            actionBarTask.cancel();
            actionBarTask = null;
        }
-        saveData();
    }

    @EventHandler
    public void onPlayerJoin(PlayerJoinEvent event) {
        Player player = event.getPlayer();
-        String playerPath = getPlayerPath(player);
-        if (!data.getBoolean(playerPath + ".active", false)) {
+        YamlConfiguration data = store.load(player.getUniqueId());
+        if (data == null) {
+            sendLangMessage(player, "admin-mode.messages.save-failed");
+            return;
+        }
+        if (!data.getBoolean("active", false)) {
            return;
        }

-        saveProfile(player, playerPath + ".admin");
-        restoreNormalProfile(player);
-        data.set(playerPath + ".active", false);
-        saveData();
+        saveProfile(player, data, "admin");
+        if (!saveData(player, data)) {
+            activePlayers.add(player.getUniqueId());
+            startActionBarTask();
+            sendLangMessage(player, "admin-mode.messages.save-failed");
+            return;
+        }
+        restoreNormalProfile(player, data);
+        data.set("active", false);
+        if (!saveData(player, data)) {
+            data.set("active", true);
+            loadProfile(player, data, "admin");
+            activePlayers.add(player.getUniqueId());
+            startActionBarTask();
+            sendLangMessage(player, "admin-mode.messages.save-failed");
+            return;
+        }
        sendLangMessage(player, "admin-mode.messages.crash-restored");
    }

@@ -92,47 +121,77 @@ public final class AdminModeManager implements Listener {
    }

    private void enable(Player player) {
-        String playerPath = getPlayerPath(player);
+        YamlConfiguration data = store.load(player.getUniqueId());
+        if (data == null) {
+            sendLangMessage(player, "admin-mode.messages.save-failed");
+            return;
+        }
        player.closeInventory();
-        saveProfile(player, playerPath + ".normal");
+        saveProfile(player, data, "normal");
+        data.set("active", true);
+        if (!saveData(player, data)) {
+            sendLangMessage(player, "admin-mode.messages.save-failed");
+            data.set("active", false);
+            return;
+        }

-        if (!loadProfile(player, playerPath + ".admin")) {
+        if (!loadProfile(player, data, "admin")) {
            clearInventory(player);
        }

        activePlayers.add(player.getUniqueId());
-        data.set(playerPath + ".active", true);

        player.setGameMode(GameMode.CREATIVE);
        player.setAllowFlight(true);
        player.setFlying(true);
        player.setFlySpeed(getAdminFlySpeed());
-        saveData();

        sendLangMessage(player, "admin-mode.messages.enabled");
        sendActionBar(player);
        startActionBarTask();
    }

-    private void disable(Player player, boolean notify) {
-        String playerPath = getPlayerPath(player);
+    private boolean disable(Player player, boolean notify) {
+        YamlConfiguration data = store.load(player.getUniqueId());
+        if (data == null) {
+            if (notify) {
+                sendLangMessage(player, "admin-mode.messages.save-failed");
+            }
+            return false;
+        }
        player.closeInventory();
-        saveProfile(player, playerPath + ".admin");
-        restoreNormalProfile(player);
+        saveProfile(player, data, "admin");
+        data.set("active", true);
+        if (!saveData(player, data)) {
+            if (notify) {
+                sendLangMessage(player, "admin-mode.messages.save-failed");
+            }
+            return false;
+        }
+        restoreNormalProfile(player, data);
+
+        data.set("active", false);
+        if (!saveData(player, data)) {
+            data.set("active", true);
+            loadProfile(player, data, "admin");
+            activePlayers.add(player.getUniqueId());
+            if (notify) {
+                sendLangMessage(player, "admin-mode.messages.save-failed");
+            }
+            return false;
+        }

        activePlayers.remove(player.getUniqueId());
-        data.set(playerPath + ".active", false);
-        saveData();

        if (notify) {
            sendLangMessage(player, "admin-mode.messages.disabled");
        }
        stopActionBarTaskIfIdle();
+        return true;
    }

-    private void restoreNormalProfile(Player player) {
-        String playerPath = getPlayerPath(player);
-        if (!loadProfile(player, playerPath + ".normal")) {
+    private void restoreNormalProfile(Player player, YamlConfiguration data) {
+        if (!loadProfile(player, data, "normal")) {
            clearInventory(player);
            player.setGameMode(GameMode.SURVIVAL);
            player.setAllowFlight(false);
@@ -141,7 +200,7 @@ public final class AdminModeManager implements Listener {
        }
    }

-    private void saveProfile(Player player, String path) {
+    private void saveProfile(Player player, YamlConfiguration data, String path) {
        PlayerInventory inventory = player.getInventory();
        data.set(path + ".storage", Arrays.asList(inventory.getStorageContents()));
        data.set(path + ".armor", Arrays.asList(inventory.getArmorContents()));
@@ -162,24 +221,24 @@ public final class AdminModeManager implements Listener {
        data.set(path + ".fire-ticks", player.getFireTicks());
    }

-    private boolean loadProfile(Player player, String path) {
+    private boolean loadProfile(Player player, YamlConfiguration data, String path) {
        if (!data.contains(path)) {
            return false;
        }

        PlayerInventory inventory = player.getInventory();
        clearInventory(player);
-        inventory.setStorageContents(readItemArray(path + ".storage", inventory.getStorageContents().length));
-        inventory.setArmorContents(readItemArray(path + ".armor", inventory.getArmorContents().length));
-        inventory.setExtraContents(readItemArray(path + ".extra", inventory.getExtraContents().length));
+        inventory.setStorageContents(readItemArray(data, path + ".storage", inventory.getStorageContents().length));
+        inventory.setArmorContents(readItemArray(data, path + ".armor", inventory.getArmorContents().length));
+        inventory.setExtraContents(readItemArray(data, path + ".extra", inventory.getExtraContents().length));
        inventory.setHeldItemSlot(clampHeldSlot(data.getInt(path + ".held-slot", inventory.getHeldItemSlot())));
-        player.setItemOnCursor(readItem(path + ".cursor"));
+        player.setItemOnCursor(readItem(data, path + ".cursor"));

-        player.setGameMode(readGameMode(path + ".game-mode", player.getGameMode()));
+        player.setGameMode(readGameMode(data, path + ".game-mode", player.getGameMode()));
        player.setAllowFlight(data.getBoolean(path + ".allow-flight", player.getAllowFlight()));
        player.setFlying(data.getBoolean(path + ".flying", false) && player.getAllowFlight());
        player.setFlySpeed(clampFlySpeed(data.getDouble(path + ".fly-speed", VANILLA_FLY_SPEED)));
-        player.setHealth(readHealth(player, path + ".health"));
+        player.setHealth(readHealth(player, data, path + ".health"));
        player.setFoodLevel(clampFoodLevel(data.getInt(path + ".food-level", player.getFoodLevel())));
        player.setSaturation(clampSaturation(data.getDouble(path + ".saturation", player.getSaturation())));
        player.setExhaustion(clampExhaustion(data.getDouble(path + ".exhaustion", player.getExhaustion())));
@@ -190,7 +249,7 @@ public final class AdminModeManager implements Listener {
        return true;
    }

-    private ItemStack[] readItemArray(String path, int size) {
+    private ItemStack[] readItemArray(YamlConfiguration data, String path, int size) {
        ItemStack[] items = new ItemStack[size];
        List<?> list = data.getList(path);
        if (list == null) {
@@ -206,7 +265,7 @@ public final class AdminModeManager implements Listener {
        return items;
    }

-    private GameMode readGameMode(String path, GameMode fallback) {
+    private GameMode readGameMode(YamlConfiguration data, String path, GameMode fallback) {
        try {
            return GameMode.valueOf(data.getString(path, fallback.name()));
        } catch (IllegalArgumentException ignored) {
@@ -214,7 +273,7 @@ public final class AdminModeManager implements Listener {
        }
    }

-    private double readHealth(Player player, String path) {
+    private double readHealth(Player player, YamlConfiguration data, String path) {
        double maxHealth = player.getAttribute(Attribute.MAX_HEALTH) != null
            ? player.getAttribute(Attribute.MAX_HEALTH).getValue()
            : player.getHealth();
@@ -225,7 +284,7 @@ public final class AdminModeManager implements Listener {
        return Math.min(Math.max(1.0D, health), maxHealth);
    }

-    private ItemStack readItem(String path) {
+    private ItemStack readItem(YamlConfiguration data, String path) {
        Object value = data.get(path);
        if (value instanceof ItemStack itemStack) {
            return itemStack;
@@ -312,26 +371,17 @@ public final class AdminModeManager implements Listener {
        return (float) Math.max(0.0D, Math.min(1.0D, exp));
    }

-    private String getPlayerPath(Player player) {
-        return "players." + player.getUniqueId();
-    }
-
    private void sendLangMessage(Player player, String path) {
        player.sendMessage(EssentialsC.getLangManager().getPrefixedString(path));
    }

-    private void saveData() {
-        try {
-            data.save(dataFile);
-        } catch (IOException e) {
-            plugin.getLogger().warning("保存 admin-mode.yml 失败: " + e.getMessage());
-        }
+    private boolean saveData(Player player, YamlConfiguration data) {
+        return store.save(player.getUniqueId(), data);
    }

    private void addConfigDefaults() {
        plugin.getConfig().addDefault("admin-mode.fly-speed", 0.2D);
        plugin.getConfig().addDefault("admin-mode.actionbar.interval-ticks", 40);
        plugin.getConfig().options().copyDefaults(true);
-        plugin.saveConfig();
    }
 }
@@ -0,0 +1,119 @@
+package cn.infstar.essentialsC.admin;
+
+import cn.infstar.essentialsC.EssentialsC;
+import cn.infstar.essentialsC.util.AtomicYamlWriter;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.util.UUID;
+import java.util.logging.Logger;
+
+final class AdminModeStore {
+
+    private final File directory;
+    private final File legacyFile;
+    private final Logger logger;
+
+    AdminModeStore(EssentialsC plugin) {
+        this(new File(plugin.getDataFolder(), "admin-mode"),
+            new File(plugin.getDataFolder(), "admin-mode.yml"), plugin.getLogger());
+    }
+
+    AdminModeStore(File directory, File legacyFile, Logger logger) {
+        this.directory = directory;
+        this.legacyFile = legacyFile;
+        this.logger = logger;
+        migrateLegacyFile();
+    }
+
+    YamlConfiguration load(UUID playerId) {
+        File playerFile = getPlayerFile(playerId);
+        YamlConfiguration data = new YamlConfiguration();
+        if (!playerFile.exists()) {
+            return data;
+        }
+        try {
+            data.load(playerFile);
+        } catch (IOException | InvalidConfigurationException exception) {
+            logger.warning("加载管理模式玩家存档失败 (" + playerId + "): " + exception.getMessage());
+            return null;
+        }
+        return data;
+    }
+
+    boolean save(UUID playerId, YamlConfiguration data) {
+        try {
+            AtomicYamlWriter.save(data, getPlayerFile(playerId));
+            return true;
+        } catch (IOException exception) {
+            logger.warning("保存管理模式玩家存档失败 (" + playerId + "): " + exception.getMessage());
+            return false;
+        }
+    }
+
+    private void migrateLegacyFile() {
+        if (!legacyFile.exists()) {
+            return;
+        }
+
+        YamlConfiguration legacy = new YamlConfiguration();
+        try {
+            legacy.load(legacyFile);
+        } catch (IOException | InvalidConfigurationException exception) {
+            logger.warning("加载旧 admin-mode.yml 失败，已保留原文件: " + exception.getMessage());
+            return;
+        }
+
+        ConfigurationSection players = legacy.getConfigurationSection("players");
+        if (players != null) {
+            for (String playerIdText : players.getKeys(false)) {
+                UUID playerId;
+                try {
+                    playerId = UUID.fromString(playerIdText);
+                } catch (IllegalArgumentException exception) {
+                    logger.warning("忽略 admin-mode.yml 中无效的玩家 UUID: " + playerIdText);
+                    continue;
+                }
+
+                if (getPlayerFile(playerId).exists()) {
+                    continue;
+                }
+                YamlConfiguration migrated = new YamlConfiguration();
+                copySection(players.getConfigurationSection(playerIdText), migrated);
+                if (!save(playerId, migrated)) {
+                    logger.warning("admin-mode.yml 迁移未完成，已保留原文件供下次重试。");
+                    return;
+                }
+            }
+        }
+
+        File backup = new File(legacyFile.getParentFile(),
+            "admin-mode.legacy-" + System.currentTimeMillis() + ".yml");
+        try {
+            Files.move(legacyFile.toPath(), backup.toPath(), StandardCopyOption.REPLACE_EXISTING);
+            logger.info("已将 admin-mode.yml 拆分为每玩家存档，旧文件已备份为 " + backup.getName());
+        } catch (IOException exception) {
+            logger.warning("备份旧 admin-mode.yml 失败: " + exception.getMessage());
+        }
+    }
+
+    private void copySection(ConfigurationSection source, YamlConfiguration target) {
+        if (source == null) {
+            return;
+        }
+        for (String path : source.getKeys(true)) {
+            if (!source.isConfigurationSection(path)) {
+                target.set(path, source.get(path));
+            }
+        }
+    }
+
+    private File getPlayerFile(UUID playerId) {
+        return new File(directory, playerId + ".yml");
+    }
+}
@@ -0,0 +1,59 @@
+package cn.infstar.essentialsC.api.event;
+
+import cn.infstar.essentialsC.teleport.TeleportRequestManager.TeleportRequest;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public final class TeleportEvent extends Event implements Cancellable {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    private final Player player;
+    private final TeleportRequest request;
+    private Location destination;
+    private boolean cancelled;
+
+    public TeleportEvent(Player player, TeleportRequest request, Location destination) {
+        this.player = player;
+        this.request = request;
+        this.destination = destination.clone();
+    }
+
+    public Player getPlayer() {
+        return player;
+    }
+
+    public TeleportRequest getRequest() {
+        return request;
+    }
+
+    public Location getDestination() {
+        return destination.clone();
+    }
+
+    public void setDestination(Location destination) {
+        this.destination = destination.clone();
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    @Override
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    public static HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+}
@@ -0,0 +1,48 @@
+package cn.infstar.essentialsC.api.event;
+
+import cn.infstar.essentialsC.teleport.TeleportRequestManager.TeleportRequest;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public final class TeleportRequestReceiveEvent extends Event implements Cancellable {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    private final Player recipient;
+    private final TeleportRequest request;
+    private boolean cancelled;
+
+    public TeleportRequestReceiveEvent(Player recipient, TeleportRequest request) {
+        this.recipient = recipient;
+        this.request = request;
+    }
+
+    public Player getRecipient() {
+        return recipient;
+    }
+
+    public TeleportRequest getRequest() {
+        return request;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    @Override
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    public static HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+}
@@ -0,0 +1,52 @@
+package cn.infstar.essentialsC.api.event;
+
+import cn.infstar.essentialsC.teleport.TeleportRequestManager.TeleportRequest;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public final class TeleportRequestReplyEvent extends Event implements Cancellable {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    private final Player recipient;
+    private final TeleportRequest request;
+    private boolean cancelled;
+
+    public TeleportRequestReplyEvent(Player recipient, TeleportRequest request) {
+        this.recipient = recipient;
+        this.request = request;
+    }
+
+    public Player getRecipient() {
+        return recipient;
+    }
+
+    public TeleportRequest getRequest() {
+        return request;
+    }
+
+    public boolean isAccepted() {
+        return request.status() == TeleportRequest.Status.ACCEPTED;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    @Override
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    public static HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+}
@@ -0,0 +1,48 @@
+package cn.infstar.essentialsC.api.event;
+
+import cn.infstar.essentialsC.teleport.TeleportRequestManager.TeleportRequest;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public final class TeleportRequestSendEvent extends Event implements Cancellable {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    private final Player sender;
+    private final TeleportRequest request;
+    private boolean cancelled;
+
+    public TeleportRequestSendEvent(Player sender, TeleportRequest request) {
+        this.sender = sender;
+        this.request = request;
+    }
+
+    public Player getSender() {
+        return sender;
+    }
+
+    public TeleportRequest getRequest() {
+        return request;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    @Override
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    public static HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+}
@@ -0,0 +1,62 @@
+package cn.infstar.essentialsC.api.event;
+
+import cn.infstar.essentialsC.teleport.TeleportRequestManager.TeleportRequest;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public final class TeleportWarmupCancelledEvent extends Event {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    private final Player player;
+    private final TeleportRequest request;
+    private final int durationSeconds;
+    private final int elapsedSeconds;
+    private final Reason reason;
+
+    public TeleportWarmupCancelledEvent(Player player, TeleportRequest request, int durationSeconds,
+                                        int elapsedSeconds, Reason reason) {
+        this.player = player;
+        this.request = request;
+        this.durationSeconds = durationSeconds;
+        this.elapsedSeconds = elapsedSeconds;
+        this.reason = reason;
+    }
+
+    public Player getPlayer() {
+        return player;
+    }
+
+    public TeleportRequest getRequest() {
+        return request;
+    }
+
+    public int getDurationSeconds() {
+        return durationSeconds;
+    }
+
+    public int getElapsedSeconds() {
+        return elapsedSeconds;
+    }
+
+    public Reason getReason() {
+        return reason;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    public static HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+
+    public enum Reason {
+        PLAYER_MOVE,
+        PLAYER_DAMAGE,
+        PLAYER_QUIT,
+        PLUGIN_SHUTDOWN
+    }
+}
@@ -0,0 +1,54 @@
+package cn.infstar.essentialsC.api.event;
+
+import cn.infstar.essentialsC.teleport.TeleportRequestManager.TeleportRequest;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public final class TeleportWarmupEvent extends Event implements Cancellable {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    private final Player player;
+    private final TeleportRequest request;
+    private final int durationSeconds;
+    private boolean cancelled;
+
+    public TeleportWarmupEvent(Player player, TeleportRequest request, int durationSeconds) {
+        this.player = player;
+        this.request = request;
+        this.durationSeconds = durationSeconds;
+    }
+
+    public Player getPlayer() {
+        return player;
+    }
+
+    public TeleportRequest getRequest() {
+        return request;
+    }
+
+    public int getDurationSeconds() {
+        return durationSeconds;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    @Override
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    public static HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+}
@@ -3,6 +3,7 @@ package cn.infstar.essentialsC.commands;
 import org.bukkit.Material;
 import org.bukkit.Sound;
 import org.bukkit.entity.Player;
+import org.bukkit.inventory.MenuType;

 public class AnvilCommand extends BaseCommand {

@@ -12,7 +13,7 @@ public class AnvilCommand extends BaseCommand {

    @Override
    protected boolean execute(Player player, String[] args) {
-        player.openAnvil(null, true);
+        player.openInventory(MenuType.ANVIL.builder().checkReachable(false).build(player));
        playBlockShortcutSound(player, Material.ANVIL, Sound.BLOCK_ANVIL_USE);
        return true;
    }
@@ -49,12 +49,17 @@ public abstract class BaseCommand implements CommandExecutor {

    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        return dispatch(sender, args);
+    }
+
+    final boolean dispatch(CommandSender sender, String[] args) {
+        if (!sender.hasPermission(permission)) {
+            sender.sendMessage(getLang().getPrefixedString("messages.no-permission",
+                Map.of("permission", permission)));
+            return true;
+        }
+
        if (sender instanceof Player player) {
-            if (!player.hasPermission(permission)) {
-                player.sendMessage(getLang().getPrefixedString("messages.no-permission",
-                    Map.of("permission", permission)));
-                return true;
-            }
            return execute(player, args);
        }

@@ -1,7 +1,6 @@
 package cn.infstar.essentialsC.commands;

 import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
 import org.bukkit.Material;
 import org.bukkit.NamespacedKey;
 import org.bukkit.Sound;
@@ -16,6 +15,8 @@ import org.bukkit.inventory.InventoryHolder;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
 import org.bukkit.persistence.PersistentDataType;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;

 import java.util.ArrayList;
 import java.util.List;
@@ -25,14 +26,12 @@ public class BlocksMenuCommand extends BaseCommand implements Listener {

    private static final int MENU_SIZE = 36;
    private static final int[] DIVIDER_SLOTS = {4, 13, 22, 31};
-    private static boolean listenerRegistered = false;
-
    private final NamespacedKey blockKey;

    private static final class BlocksMenuHolder implements InventoryHolder {
        private final Inventory inventory;

-        private BlocksMenuHolder(String title) {
+        private BlocksMenuHolder(Component title) {
            this.inventory = Bukkit.createInventory(this, MENU_SIZE, title);
        }

@@ -45,10 +44,6 @@ public class BlocksMenuCommand extends BaseCommand implements Listener {
    public BlocksMenuCommand() {
        super("essentialsc.command.blocks");
        addConfigDefaults();
-        if (!listenerRegistered) {
-            plugin.getServer().getPluginManager().registerEvents(this, plugin);
-            listenerRegistered = true;
-        }
        this.blockKey = new NamespacedKey(plugin, "block_key");
    }

@@ -59,7 +54,7 @@ public class BlocksMenuCommand extends BaseCommand implements Listener {
    }

    private void openMenu(Player player) {
-        Inventory menu = new BlocksMenuHolder(getLang().getString("blocks-menu.title")).getInventory();
+        Inventory menu = new BlocksMenuHolder(getLang().getComponent("blocks-menu.title")).getInventory();

        FileConfiguration menuConfig = plugin.getFeatureConfigManager().getBlocksMenuConfig();
        var sectionsConfig = menuConfig.getConfigurationSection("sections");
@@ -170,8 +165,10 @@ public class BlocksMenuCommand extends BaseCommand implements Listener {
        ItemStack item = new ItemStack(menuItem.material());
        ItemMeta meta = item.getItemMeta();
        if (meta != null) {
-            meta.setDisplayName(menuItem.name());
-            meta.setLore(menuItem.lore().isEmpty() ? null : menuItem.lore());
+            meta.displayName(legacyComponent(menuItem.name()));
+            meta.lore(menuItem.lore().isEmpty() ? null : menuItem.lore().stream()
+                .map(this::legacyComponent)
+                .toList());
            if (menuItem.commandKey() != null && !menuItem.commandKey().isBlank()) {
                meta.getPersistentDataContainer().set(blockKey, PersistentDataType.STRING, menuItem.commandKey());
            }
@@ -184,7 +181,7 @@ public class BlocksMenuCommand extends BaseCommand implements Listener {
        ItemStack divider = new ItemStack(Material.GRAY_STAINED_GLASS_PANE);
        ItemMeta meta = divider.getItemMeta();
        if (meta != null) {
-            meta.setDisplayName(" ");
+            meta.displayName(Component.text(" "));
            divider.setItemMeta(meta);
        }

@@ -250,8 +247,8 @@ public class BlocksMenuCommand extends BaseCommand implements Listener {
        }
    }

-    private String translateColor(String text) {
-        return text == null ? "" : ChatColor.translateAlternateColorCodes('&', text);
+    private Component legacyComponent(String text) {
+        return LegacyComponentSerializer.legacySection().deserialize(text == null ? "" : text);
    }

    private void addConfigDefaults() {
@@ -3,6 +3,7 @@ package cn.infstar.essentialsC.commands;
 import org.bukkit.Material;
 import org.bukkit.Sound;
 import org.bukkit.entity.Player;
+import org.bukkit.inventory.MenuType;

 public class CartographyTableCommand extends BaseCommand {

@@ -12,7 +13,7 @@ public class CartographyTableCommand extends BaseCommand {

    @Override
    protected boolean execute(Player player, String[] args) {
-        player.openCartographyTable(null, true);
+        player.openInventory(MenuType.CARTOGRAPHY_TABLE.builder().checkReachable(false).build(player));
        playBlockShortcutSound(player, Material.CARTOGRAPHY_TABLE, Sound.ENTITY_VILLAGER_WORK_CARTOGRAPHER);
        return true;
    }
@@ -4,7 +4,6 @@ import cn.infstar.essentialsC.EssentialsC;
 import cn.infstar.essentialsC.ModuleManager;
 import cn.infstar.essentialsC.tpsbar.TpsBarService;

-import java.lang.reflect.Constructor;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
@@ -12,6 +11,7 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.function.Supplier;

 public final class CommandRegistry {

@@ -21,52 +21,56 @@ public final class CommandRegistry {
    private static final Set<String> UNAVAILABLE_COMMANDS = new java.util.HashSet<>();

    static {
-        register("workbench", "essentialsc.command.workbench", ModuleManager.BLOCKS, "cn.infstar.essentialsC.commands.WorkbenchCommand", "wb");
-        register("anvil", "essentialsc.command.anvil", ModuleManager.BLOCKS, "cn.infstar.essentialsC.commands.AnvilCommand");
-        register("cartographytable", "essentialsc.command.cartographytable", ModuleManager.BLOCKS, "cn.infstar.essentialsC.commands.CartographyTableCommand", "ct", "cartography");
-        register("grindstone", "essentialsc.command.grindstone", ModuleManager.BLOCKS, "cn.infstar.essentialsC.commands.GrindstoneCommand", "gs");
-        register("loom", "essentialsc.command.loom", ModuleManager.BLOCKS, "cn.infstar.essentialsC.commands.LoomCommand");
-        register("smithingtable", "essentialsc.command.smithingtable", ModuleManager.BLOCKS, "cn.infstar.essentialsC.commands.SmithingTableCommand", "st", "smithing");
-        register("stonecutter", "essentialsc.command.stonecutter", ModuleManager.BLOCKS, "cn.infstar.essentialsC.commands.StonecutterCommand", "sc");
-        register("enderchest", "essentialsc.command.enderchest", ModuleManager.BLOCKS, "cn.infstar.essentialsC.commands.EnderChestCommand", "ec");
-        register("blocks", "essentialsc.command.blocks", ModuleManager.BLOCKS, "cn.infstar.essentialsC.commands.BlocksMenuCommand");
-        register("hat", "essentialsc.command.hat", ModuleManager.PLAYER, "cn.infstar.essentialsC.commands.HatCommand");
-        register("suicide", "essentialsc.command.suicide", ModuleManager.PLAYER, "cn.infstar.essentialsC.commands.SuicideCommand", "die");
-        register("fly", "essentialsc.command.fly", ModuleManager.PLAYER, "cn.infstar.essentialsC.commands.FlyCommand");
-        register("nightvision", "essentialsc.command.nightvision", ModuleManager.PLAYER, "cn.infstar.essentialsC.commands.NightVisionCommand", "nv");
-        register("glow", "essentialsc.command.glow", ModuleManager.PLAYER, "cn.infstar.essentialsC.commands.GlowCommand");
-        register("heal", "essentialsc.command.heal", ModuleManager.PLAYER, "cn.infstar.essentialsC.commands.HealCommand");
-        register("vanish", "essentialsc.command.vanish", ModuleManager.PLAYER, "cn.infstar.essentialsC.commands.VanishCommand", "v");
-        register("seen", "essentialsc.command.seen", ModuleManager.PLAYER, "cn.infstar.essentialsC.commands.SeenCommand", "info");
-        register("feed", "essentialsc.command.feed", ModuleManager.PLAYER, "cn.infstar.essentialsC.commands.FeedCommand");
-        register("repair", "essentialsc.command.repair", ModuleManager.PLAYER, "cn.infstar.essentialsC.commands.RepairCommand", "rep");
-        register("tpa", "essentialsc.command.tpa", ModuleManager.PLAYER, "cn.infstar.essentialsC.commands.TpaCommand");
-        register("tpahere", "essentialsc.command.tpahere", ModuleManager.PLAYER, "cn.infstar.essentialsC.commands.TpaHereCommand");
-        register("tpaall", "essentialsc.command.tpaall", ModuleManager.PLAYER, "cn.infstar.essentialsC.commands.TpaAllCommand");
-        register("tpaccept", "essentialsc.command.tpaccept", ModuleManager.PLAYER, "cn.infstar.essentialsC.commands.TpAcceptCommand", "tpyes");
-        register("tpdeny", "essentialsc.command.tpdeny", ModuleManager.PLAYER, "cn.infstar.essentialsC.commands.TpDenyCommand", "tpdecline", "tpno");
-        register("tpignore", "essentialsc.command.tpignore", ModuleManager.PLAYER, "cn.infstar.essentialsC.commands.TpIgnoreCommand");
-        register("tpsbar", "essentialsc.command.tpsbar", ModuleManager.TPSBAR, "cn.infstar.essentialsC.commands.TpsBarCommand");
-        register("mobdrops", "essentialsc.mobdrops.enderman", ModuleManager.MOB_DROPS, "cn.infstar.essentialsC.commands.MobDropCommand");
-        register("maintenance", "essentialsc.command.maintenance", ModuleManager.MAINTENANCE, "cn.infstar.essentialsC.commands.MaintenanceCommand", "maint");
-        registerSubCommand("admin", "essentialsc.command.admin", ModuleManager.ADMIN_MODE, "cn.infstar.essentialsC.commands.AdminCommand");
-        registerSubCommand("skin", "essentialsc.command.skin", ModuleManager.SKIN_BRIDGE, "cn.infstar.essentialsC.commands.SkinBridgeCommand");
+        register("workbench", "essentialsc.command.workbench", ModuleManager.BLOCKS, WorkbenchCommand::new, "wb");
+        register("anvil", "essentialsc.command.anvil", ModuleManager.BLOCKS, AnvilCommand::new);
+        register("cartographytable", "essentialsc.command.cartographytable", ModuleManager.BLOCKS, CartographyTableCommand::new, "ct", "cartography");
+        register("grindstone", "essentialsc.command.grindstone", ModuleManager.BLOCKS, GrindstoneCommand::new, "gs");
+        register("loom", "essentialsc.command.loom", ModuleManager.BLOCKS, LoomCommand::new);
+        register("smithingtable", "essentialsc.command.smithingtable", ModuleManager.BLOCKS, SmithingTableCommand::new, "st", "smithing");
+        register("stonecutter", "essentialsc.command.stonecutter", ModuleManager.BLOCKS, StonecutterCommand::new, "sc");
+        register("enderchest", "essentialsc.command.enderchest", ModuleManager.BLOCKS, EnderChestCommand::new, "ec");
+        register("blocks", "essentialsc.command.blocks", ModuleManager.BLOCKS, BlocksMenuCommand::new);
+        registerCore("hat", "essentialsc.command.hat", HatCommand::new);
+        registerCore("suicide", "essentialsc.command.suicide", SuicideCommand::new, "die");
+        registerCore("fly", "essentialsc.command.fly", FlyCommand::new);
+        registerCore("nightvision", "essentialsc.command.nightvision", NightVisionCommand::new, "nv");
+        registerCore("glow", "essentialsc.command.glow", GlowCommand::new);
+        registerCore("heal", "essentialsc.command.heal", HealCommand::new);
+        registerCore("vanish", "essentialsc.command.vanish", VanishCommand::new, "v");
+        registerCore("seen", "essentialsc.command.seen", SeenCommand::new, "info");
+        registerCore("feed", "essentialsc.command.feed", FeedCommand::new);
+        registerCore("repair", "essentialsc.command.repair", RepairCommand::new, "rep");
+        registerCore("tpa", "essentialsc.command.tpa", TpaCommand::new);
+        registerCore("tpahere", "essentialsc.command.tpahere", TpaHereCommand::new);
+        registerCore("tpaall", "essentialsc.command.tpaall", TpaAllCommand::new);
+        registerCore("tpaccept", "essentialsc.command.tpaccept", TpAcceptCommand::new, "tpyes");
+        registerCore("tpdeny", "essentialsc.command.tpdeny", TpDenyCommand::new, "tpdecline", "tpno");
+        registerCore("tpignore", "essentialsc.command.tpignore", TpIgnoreCommand::new);
+        register("tpsbar", "essentialsc.command.tpsbar", ModuleManager.TPSBAR, TpsBarCommand::new);
+        register("mobdrops", "essentialsc.mobdrops.enderman", ModuleManager.MOB_DROPS, MobDropCommand::new);
+        registerSubCommand("admin", "essentialsc.command.admin", ModuleManager.ADMIN_MODE, AdminCommand::new);
+        registerSubCommand("skin", "essentialsc.command.skin", ModuleManager.SKIN_BRIDGE, SkinBridgeCommand::new);
    }

    private CommandRegistry() {
    }

-    private static void register(String name, String permission, String moduleKey, String className, String... aliases) {
-        register(name, permission, moduleKey, className, true, aliases);
+    private static void registerCore(String name, String permission, Supplier<BaseCommand> factory, String... aliases) {
+        register(name, permission, null, factory, aliases);
    }

-    private static void registerSubCommand(String name, String permission, String moduleKey, String className, String... aliases) {
-        register(name, permission, moduleKey, className, false, aliases);
+    private static void register(String name, String permission, String moduleKey, Supplier<BaseCommand> factory, String... aliases) {
+        register(name, permission, moduleKey, factory, true, aliases);
    }

-    private static void register(String name, String permission, String moduleKey, String className, boolean standalone, String... aliases) {
+    private static void registerSubCommand(String name, String permission, String moduleKey, Supplier<BaseCommand> factory, String... aliases) {
+        register(name, permission, moduleKey, factory, false, aliases);
+    }
+
+    private static void register(String name, String permission, String moduleKey, Supplier<BaseCommand> factory,
+                                 boolean standalone, String... aliases) {
        List<String> aliasList = List.of(aliases);
-        CommandSpec spec = new CommandSpec(name, permission, moduleKey, className, aliasList, standalone);
+        CommandSpec spec = new CommandSpec(name, permission, moduleKey, factory, aliasList, standalone);
        COMMANDS.put(name, spec);
        ALIAS_TO_COMMAND.put(name, name);
        for (String alias : aliasList) {
@@ -86,7 +90,8 @@ public final class CommandRegistry {
    }

    public static boolean isAvailable(String name) {
-        return getCommand(name) != null;
+        String resolvedName = resolveCommandName(name);
+        return resolvedName != null && !isRuntimeDisabled(resolvedName) && getRegisteredCommand(resolvedName) != null;
    }

    public static String getPermission(String name) {
@@ -104,6 +109,15 @@ public final class CommandRegistry {
            return null;
        }

+        return getRegisteredCommand(resolvedName);
+    }
+
+    public static BaseCommand getRegisteredCommand(String name) {
+        String resolvedName = resolveCommandName(name);
+        if (resolvedName == null) {
+            return null;
+        }
+
        BaseCommand cached = COMMAND_CACHE.get(resolvedName);
        if (cached != null) {
            return cached;
@@ -118,18 +132,16 @@ public final class CommandRegistry {
        }

        try {
-            Class<?> rawClass = Class.forName(spec.className());
-            if (!BaseCommand.class.isAssignableFrom(rawClass)) {
-                UNAVAILABLE_COMMANDS.add(resolvedName);
-                return null;
-            }
-
-            Constructor<? extends BaseCommand> constructor = rawClass.asSubclass(BaseCommand.class).getDeclaredConstructor();
-            BaseCommand command = constructor.newInstance();
+            BaseCommand command = spec.factory().get();
            COMMAND_CACHE.put(resolvedName, command);
            return command;
-        } catch (ReflectiveOperationException | LinkageError ignored) {
+        } catch (RuntimeException | LinkageError exception) {
            UNAVAILABLE_COMMANDS.add(resolvedName);
+            try {
+                EssentialsC.getPlugin(EssentialsC.class).getLogger()
+                    .warning("初始化命令 /" + resolvedName + " 失败: " + exception.getMessage());
+            } catch (IllegalStateException ignored) {
+            }
            return null;
        }
    }
@@ -163,11 +175,11 @@ public final class CommandRegistry {
        }
    }

-    public static void clearCache() {
-        COMMAND_CACHE.clear();
+    public static void clearInitializationFailures() {
        UNAVAILABLE_COMMANDS.clear();
    }

-    public record CommandSpec(String name, String permission, String moduleKey, String className, List<String> aliases, boolean standalone) {
+    public record CommandSpec(String name, String permission, String moduleKey, Supplier<BaseCommand> factory,
+                               List<String> aliases, boolean standalone) {
    }
 }
@@ -1,6 +1,7 @@
 package cn.infstar.essentialsC.commands;

 import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;

 import java.util.Map;
@@ -24,7 +25,7 @@ public class FeedCommand extends BaseCommand {
            return true;
        }

-        Player target = Bukkit.getPlayer(args[0]);
+        Player target = Bukkit.getPlayerExact(args[0]);
        if (target == null) {
            player.sendMessage(getLang().getPrefixedString("messages.player-not-found", Map.of("player", args[0])));
            return true;
@@ -36,6 +37,30 @@ public class FeedCommand extends BaseCommand {
        return true;
    }

+    @Override
+    protected boolean executeConsole(CommandSender sender, String[] args) {
+        if (args.length != 1) {
+            sender.sendMessage(getLang().getPrefixedString("messages.feed-usage-console"));
+            return true;
+        }
+        if (!sender.hasPermission("essentialsc.command.feed.others")) {
+            sender.sendMessage(getLang().getPrefixedString("messages.no-permission-others"));
+            return true;
+        }
+
+        Player target = Bukkit.getPlayerExact(args[0]);
+        if (target == null) {
+            sender.sendMessage(getLang().getPrefixedString("messages.player-not-found", Map.of("player", args[0])));
+            return true;
+        }
+
+        feedPlayer(target);
+        sender.sendMessage(getLang().getPrefixedString("messages.feed-other", Map.of("player", target.getName())));
+        target.sendMessage(getLang().getPrefixedString("messages.feed-by-other",
+            Map.of("admin", getLang().getString("messages.console-name"))));
+        return true;
+    }
+
    private void feedPlayer(Player player) {
        player.setFoodLevel(20);
        player.setSaturation(20f);
@@ -10,15 +10,13 @@ public class FlyCommand extends BaseCommand {
    
    @Override
    protected boolean execute(Player player, String[] args) {
-        boolean currentFlyState = player.getAllowFlight();
+        boolean currentFlyState = plugin.getPlayerStateManager().isFlyEnabled(player);
        
        if (currentFlyState) {
-            player.setAllowFlight(false);
-            player.setFlying(false);
+            plugin.getPlayerStateManager().disableFly(player);
            player.sendMessage(getLang().getPrefixedString("messages.fly-disabled"));
        } else {
-            player.setAllowFlight(true);
-            player.setFlying(true);
+            plugin.getPlayerStateManager().enableFly(player);
            player.sendMessage(getLang().getPrefixedString("messages.fly-enabled"));
        }
        
@@ -1,17 +1,12 @@
 package cn.infstar.essentialsC.commands;

-import org.bukkit.NamespacedKey;
 import org.bukkit.Sound;
 import org.bukkit.entity.Player;
-import org.bukkit.persistence.PersistentDataType;

 public class GlowCommand extends BaseCommand {

-    private final NamespacedKey enabledKey;
-
    public GlowCommand() {
        super("essentialsc.command.glow");
-        this.enabledKey = new NamespacedKey(plugin, "glow_enabled");
    }

    @Override
@@ -24,15 +19,11 @@ public class GlowCommand extends BaseCommand {
        }

        if (targetState) {
-            player.setGlowing(true);
-            player.getPersistentDataContainer().set(enabledKey, PersistentDataType.BYTE, (byte) 1);
+            plugin.getPlayerStateManager().enableGlow(player);
            playShortcutSound(player, Sound.BLOCK_AMETHYST_BLOCK_CHIME);
            player.sendMessage(getLang().getPrefixedString("messages.glow-enabled"));
        } else {
-            if (currentState) {
-                player.setGlowing(false);
-                player.getPersistentDataContainer().remove(enabledKey);
-            }
+            plugin.getPlayerStateManager().disableGlow(player);
            playShortcutSound(player, Sound.BLOCK_AMETHYST_CLUSTER_FALL);
            player.sendMessage(getLang().getPrefixedString("messages.glow-disabled"));
        }
@@ -53,7 +44,6 @@ public class GlowCommand extends BaseCommand {
    }

    private boolean isPluginGlowEnabled(Player player) {
-        Byte value = player.getPersistentDataContainer().get(enabledKey, PersistentDataType.BYTE);
-        return value != null && value == (byte) 1;
+        return plugin.getPlayerStateManager().isGlowEnabled(player);
    }
 }
@@ -3,6 +3,7 @@ package cn.infstar.essentialsC.commands;
 import org.bukkit.Material;
 import org.bukkit.Sound;
 import org.bukkit.entity.Player;
+import org.bukkit.inventory.MenuType;

 public class GrindstoneCommand extends BaseCommand {

@@ -12,7 +13,7 @@ public class GrindstoneCommand extends BaseCommand {

    @Override
    protected boolean execute(Player player, String[] args) {
-        player.openGrindstone(null, true);
+        player.openInventory(MenuType.GRINDSTONE.builder().checkReachable(false).build(player));
        playBlockShortcutSound(player, Material.GRINDSTONE, Sound.BLOCK_GRINDSTONE_USE);
        return true;
    }
@@ -1,6 +1,9 @@
 package cn.infstar.essentialsC.commands;

 import org.bukkit.Bukkit;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.attribute.AttributeInstance;
+import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;

 import java.util.Map;
@@ -24,7 +27,7 @@ public class HealCommand extends BaseCommand {
            return true;
        }

-        Player target = Bukkit.getPlayer(args[0]);
+        Player target = Bukkit.getPlayerExact(args[0]);
        if (target == null) {
            player.sendMessage(getLang().getPrefixedString("messages.player-not-found", Map.of("player", args[0])));
            return true;
@@ -36,8 +39,33 @@ public class HealCommand extends BaseCommand {
        return true;
    }

+    @Override
+    protected boolean executeConsole(CommandSender sender, String[] args) {
+        if (args.length != 1) {
+            sender.sendMessage(getLang().getPrefixedString("messages.heal-usage-console"));
+            return true;
+        }
+        if (!sender.hasPermission("essentialsc.command.heal.others")) {
+            sender.sendMessage(getLang().getPrefixedString("messages.no-permission-others"));
+            return true;
+        }
+
+        Player target = Bukkit.getPlayerExact(args[0]);
+        if (target == null) {
+            sender.sendMessage(getLang().getPrefixedString("messages.player-not-found", Map.of("player", args[0])));
+            return true;
+        }
+
+        healPlayer(target);
+        sender.sendMessage(getLang().getPrefixedString("messages.heal-other", Map.of("player", target.getName())));
+        target.sendMessage(getLang().getPrefixedString("messages.heal-by-other",
+            Map.of("admin", getLang().getString("messages.console-name"))));
+        return true;
+    }
+
    private void healPlayer(Player player) {
-        player.setHealth(player.getMaxHealth());
+        AttributeInstance maxHealth = player.getAttribute(Attribute.MAX_HEALTH);
+        player.setHealth(maxHealth == null ? player.getHealth() : maxHealth.getValue());
        player.setFoodLevel(20);
        player.setSaturation(20f);
        player.clearActivePotionEffects();
@@ -20,6 +20,17 @@ public class HelpCommand extends BaseCommand implements TabCompleter {
        super("essentialsc.command.help");
    }

+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (args.length > 0) {
+            if (sender instanceof Player player) {
+                return handleCommand(sender, player, args);
+            }
+            return executeConsole(sender, args);
+        }
+        return super.onCommand(sender, command, label, args);
+    }
+
    @Override
    protected boolean execute(Player player, String[] args) {
        return handleCommand(player, player, args);
@@ -27,24 +38,76 @@ public class HelpCommand extends BaseCommand implements TabCompleter {

    @Override
    protected boolean executeConsole(CommandSender sender, String[] args) {
-        if (args.length > 0 && args[0].equalsIgnoreCase("reload")) {
+        if (args.length == 0 || args[0].equalsIgnoreCase("help")) {
+            sendConsoleHelp(sender);
+            return true;
+        }
+
+        if (args[0].equalsIgnoreCase("reload")) {
            if (!sender.hasPermission("essentialsc.command.reload")) {
                sendNoPermission(sender, "essentialsc.command.reload");
                return true;
            }
-            plugin.reloadConfig();
-            EssentialsC.getLangManager().reload();
            plugin.getFeatureConfigManager().reload();
+            EssentialsC.getLangManager().reload();
            plugin.getModuleManager().reload();
-            CommandRegistry.clearCache();
+            CommandRegistry.clearInitializationFailures();
            plugin.reloadRuntimeModules();
            sender.sendMessage(getLang().getPrefixedString("messages.config-reloaded"));
            return true;
        }
-        sender.sendMessage(getLang().getPrefixedString("messages.player-only"));
+
+        if (args[0].equalsIgnoreCase("version") || args[0].equalsIgnoreCase("v")) {
+            sender.sendMessage(getLang().getPrefixedString("messages.version",
+                Map.of("version", plugin.getPluginMeta().getVersion())));
+            sender.sendMessage(getLang().getPrefixedString("messages.paper-version",
+                Map.of("version", Bukkit.getVersion())));
+            return true;
+        }
+
+        String actualCommand = getActualCommand(args[0]);
+        BaseCommand targetCommand = CommandRegistry.getCommand(actualCommand);
+        if (actualCommand != null && targetCommand != null) {
+            return targetCommand.dispatch(sender, Arrays.copyOfRange(args, 1, args.length));
+        }
+
+        sender.sendMessage(getLang().getPrefixedString("messages.unknown-subcommand",
+            Map.of("command", args[0])));
+        sender.sendMessage(getLang().getPrefixedString("messages.help-usage"));
        return true;
    }

+    private void sendConsoleHelp(CommandSender sender) {
+        LangManager lang = getLang();
+        sendPrefixed(sender, lang.getString("help.title"));
+        sendPrefixed(sender, lang.getString("help.version",
+            Map.of("version", plugin.getPluginMeta().getVersion())));
+        sender.sendMessage("");
+
+        sendPrefixed(sender, lang.getString("help.section-other"));
+        if (sender.hasPermission("essentialsc.command.reload")) {
+            sendPrefixed(sender, lang.getString("help.commands.reload"));
+        }
+        sendPrefixed(sender, lang.getString("help.commands.version"));
+        if (CommandRegistry.isAvailable("seen") && sender.hasPermission("essentialsc.command.seen")) {
+            sendPrefixed(sender, lang.getString("help.commands.seen"));
+        }
+        if (CommandRegistry.isAvailable("heal") && sender.hasPermission("essentialsc.command.heal")) {
+            sendPrefixed(sender, lang.getString("help.commands.heal"));
+        }
+        if (CommandRegistry.isAvailable("feed") && sender.hasPermission("essentialsc.command.feed")) {
+            sendPrefixed(sender, lang.getString("help.commands.feed"));
+        }
+        if (CommandRegistry.isAvailable("skin") && sender.hasPermission("essentialsc.command.skin")) {
+            sendPrefixed(sender, lang.getString("help.commands.skin"));
+        }
+        if (CommandRegistry.isAvailable("tpsbar") && sender.hasPermission("essentialsc.command.tpsbar")) {
+            sendPrefixed(sender, lang.getString("help.commands.tpsbar"));
+        }
+        sender.sendMessage("");
+        sendPrefixed(sender, lang.getString("help.footer"));
+    }
+
    private boolean handleCommand(CommandSender sender, Player player, String[] args) {
        if (args.length > 0) {
            String subCommand = args[0].toLowerCase();
@@ -54,11 +117,10 @@ public class HelpCommand extends BaseCommand implements TabCompleter {
                    sendNoPermission(sender, "essentialsc.command.reload");
                    return true;
                }
-                plugin.reloadConfig();
-                EssentialsC.getLangManager().reload();
                plugin.getFeatureConfigManager().reload();
+                EssentialsC.getLangManager().reload();
                plugin.getModuleManager().reload();
-                CommandRegistry.clearCache();
+                CommandRegistry.clearInitializationFailures();
                plugin.reloadRuntimeModules();
                sender.sendMessage(getLang().getPrefixedString("messages.config-reloaded"));
                return true;
@@ -84,7 +146,7 @@ public class HelpCommand extends BaseCommand implements TabCompleter {

            if (subCommand.equals("version") || subCommand.equals("v")) {
                player.sendMessage(getLang().getPrefixedString("messages.version",
-                    Map.of("version", plugin.getDescription().getVersion())));
+                    Map.of("version", plugin.getPluginMeta().getVersion())));
                player.sendMessage(getLang().getPrefixedString("messages.paper-version",
                    Map.of("version", Bukkit.getVersion())));
                return true;
@@ -97,7 +159,7 @@ public class HelpCommand extends BaseCommand implements TabCompleter {
        }

        LangManager lang = getLang();
-        String version = plugin.getDescription().getVersion();
+        String version = plugin.getPluginMeta().getVersion();

        sendPrefixed(player, lang.getString("help.title"));
        sendPrefixed(player, lang.getString("help.version", Map.of("version", version)));
@@ -216,10 +278,6 @@ public class HelpCommand extends BaseCommand implements TabCompleter {
            otherCommands.append(lang.getString("help.commands.tpsbar")).append("\n");
            hasOtherCommands = true;
        }
-        if (CommandRegistry.isAvailable("maintenance") && player.hasPermission("essentialsc.command.maintenance")) {
-            otherCommands.append(lang.getString("help.commands.maintenance")).append("\n");
-            hasOtherCommands = true;
-        }

        if (hasOtherCommands) {
            sendPrefixed(player, lang.getString("help.section-other"));
@@ -237,7 +295,7 @@ public class HelpCommand extends BaseCommand implements TabCompleter {
    }

    private void sendPrefixed(CommandSender sender, String message) {
-        sender.sendMessage(message);
+        sender.sendMessage(getLang().getPrefix() + message);
    }

    private void sendPrefixedLines(CommandSender sender, String message) {
@@ -301,8 +359,6 @@ public class HelpCommand extends BaseCommand implements TabCompleter {
                {"tpignore", "essentialsc.command.tpignore"},
                {"skin", "essentialsc.command.skin"},
                {"tpsbar", "essentialsc.command.tpsbar"},
-                {"maintenance", "essentialsc.command.maintenance"},
-                {"maint", "essentialsc.command.maintenance"},
                {"mobdrops", "essentialsc.mobdrops.enderman"},
                {"admin", "essentialsc.command.admin"},
                {"version", null},
@@ -354,7 +410,14 @@ public class HelpCommand extends BaseCommand implements TabCompleter {

            if (subCmd.equals("skin") && sender.hasPermission("essentialsc.command.skin")) {
                String partial = args[1].toLowerCase();
-                return List.of("status", "refresh").stream()
+                List<String> actions = new ArrayList<>();
+                if (sender.hasPermission("essentialsc.command.skin.status")) {
+                    actions.add("status");
+                }
+                if (sender.hasPermission("essentialsc.command.skin.refresh")) {
+                    actions.add("refresh");
+                }
+                return actions.stream()
                    .filter(option -> option.startsWith(partial))
                    .toList();
            }
@@ -378,15 +441,14 @@ public class HelpCommand extends BaseCommand implements TabCompleter {
                return players;
            }

-            if ((subCmd.equals("maintenance") || subCmd.equals("maint"))
-                && sender.hasPermission("essentialsc.command.maintenance")) {
-                return completeMaintenanceArgs(args[1]);
-            }
        }

        if (args.length == 3 && args[0].equalsIgnoreCase("skin")
            && (args[1].equalsIgnoreCase("status") || args[1].equalsIgnoreCase("refresh"))
-            && sender.hasPermission("essentialsc.command.skin")) {
+            && sender.hasPermission("essentialsc.command.skin.others")
+            && sender.hasPermission(args[1].equalsIgnoreCase("status")
+                ? "essentialsc.command.skin.status"
+                : "essentialsc.command.skin.refresh")) {
            List<String> players = new ArrayList<>();
            String partial = args[2].toLowerCase();
            for (Player player : Bukkit.getOnlinePlayers()) {
@@ -423,14 +485,4 @@ public class HelpCommand extends BaseCommand implements TabCompleter {
        return completions;
    }

-    private List<String> completeMaintenanceArgs(String partialInput) {
-        List<String> completions = new ArrayList<>();
-        String partial = partialInput.toLowerCase();
-        for (String option : List.of("on", "off", "status", "reload", "add", "remove", "list")) {
-            if (option.startsWith(partial)) {
-                completions.add(option);
-            }
-        }
-        return completions;
-    }
 }
@@ -3,6 +3,7 @@ package cn.infstar.essentialsC.commands;
 import org.bukkit.Material;
 import org.bukkit.Sound;
 import org.bukkit.entity.Player;
+import org.bukkit.inventory.MenuType;

 public class LoomCommand extends BaseCommand {

@@ -12,7 +13,7 @@ public class LoomCommand extends BaseCommand {

    @Override
    protected boolean execute(Player player, String[] args) {
-        player.openLoom(null, true);
+        player.openInventory(MenuType.LOOM.builder().checkReachable(false).build(player));
        playBlockShortcutSound(player, Material.LOOM, Sound.UI_LOOM_SELECT_PATTERN);
        return true;
    }
@@ -1,163 +0,0 @@
-package cn.infstar.essentialsC.commands;
-
-import cn.infstar.essentialsC.maintenance.MaintenanceManager;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandSender;
-import org.bukkit.command.TabCompleter;
-import org.bukkit.entity.Player;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-
-public class MaintenanceCommand extends BaseCommand implements TabCompleter {
-
-    public MaintenanceCommand() {
-        super("essentialsc.command.maintenance");
-    }
-
-    @Override
-    protected boolean execute(Player player, String[] args) {
-        return executeCommand(player, args);
-    }
-
-    @Override
-    protected boolean executeConsole(CommandSender sender, String[] args) {
-        return executeCommand(sender, args);
-    }
-
-    private boolean executeCommand(CommandSender sender, String[] args) {
-        MaintenanceManager maintenanceManager = plugin.getMaintenanceManager();
-        if (maintenanceManager == null) {
-            sender.sendMessage(getLang().getPrefixedString("messages.module-disabled"));
-            return true;
-        }
-
-        if (args.length == 0 || args[0].equalsIgnoreCase("status")) {
-            sendStatus(sender, maintenanceManager);
-            return true;
-        }
-
-        switch (args[0].toLowerCase(Locale.ROOT)) {
-            case "on", "enable", "enabled" -> {
-                maintenanceManager.setEnabled(true);
-                sender.sendMessage(getLang().getPrefixedString("maintenance.messages.enabled"));
-                return true;
-            }
-            case "off", "disable", "disabled" -> {
-                maintenanceManager.setEnabled(false);
-                sender.sendMessage(getLang().getPrefixedString("maintenance.messages.disabled"));
-                return true;
-            }
-            case "reload" -> {
-                maintenanceManager.reload();
-                sender.sendMessage(getLang().getPrefixedString("maintenance.messages.reloaded"));
-                return true;
-            }
-            case "add" -> {
-                if (args.length < 2) {
-                    sender.sendMessage(getLang().getPrefixedString("maintenance.messages.add-usage"));
-                    return true;
-                }
-
-                String target = args[1];
-                if (maintenanceManager.addWhitelistEntry(target)) {
-                    sender.sendMessage(getLang().getPrefixedString("maintenance.messages.whitelist-added",
-                        Map.of("player", target)));
-                } else {
-                    sender.sendMessage(getLang().getPrefixedString("maintenance.messages.whitelist-exists",
-                        Map.of("player", target)));
-                }
-                return true;
-            }
-            case "remove" -> {
-                if (args.length < 2) {
-                    sender.sendMessage(getLang().getPrefixedString("maintenance.messages.remove-usage"));
-                    return true;
-                }
-
-                String target = args[1];
-                if (maintenanceManager.removeWhitelistEntry(target)) {
-                    sender.sendMessage(getLang().getPrefixedString("maintenance.messages.whitelist-removed",
-                        Map.of("player", target)));
-                } else {
-                    sender.sendMessage(getLang().getPrefixedString("maintenance.messages.whitelist-missing",
-                        Map.of("player", target)));
-                }
-                return true;
-            }
-            case "list" -> {
-                sendWhitelist(sender, maintenanceManager);
-                return true;
-            }
-            default -> {
-                sender.sendMessage(getLang().getPrefixedString("maintenance.messages.usage"));
-                return true;
-            }
-        }
-    }
-
-    private void sendStatus(CommandSender sender, MaintenanceManager maintenanceManager) {
-        String status = getLang().getString(maintenanceManager.isEnabled()
-            ? "maintenance.status.enabled"
-            : "maintenance.status.disabled");
-        sender.sendMessage(getLang().getPrefixedString("maintenance.messages.status",
-            Map.of(
-                "status", status,
-                "whitelist_count", String.valueOf(maintenanceManager.getWhitelistCount())
-            )));
-    }
-
-    private void sendWhitelist(CommandSender sender, MaintenanceManager maintenanceManager) {
-        List<String> entries = maintenanceManager.getWhitelistEntries();
-        if (entries.isEmpty()) {
-            sender.sendMessage(getLang().getPrefixedString("maintenance.messages.whitelist-empty"));
-            return;
-        }
-
-        sender.sendMessage(getLang().getPrefixedString("maintenance.messages.whitelist-list",
-            Map.of(
-                "count", String.valueOf(entries.size()),
-                "entries", String.join(", ", entries)
-            )));
-    }
-
-    @Override
-    public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
-        if (!sender.hasPermission(getPermission())) {
-            return List.of();
-        }
-
-        if (args.length == 1) {
-            return complete(args[0], List.of("on", "off", "status", "reload", "add", "remove", "list"));
-        }
-
-        if (args.length == 2 && args[0].equalsIgnoreCase("add")) {
-            return complete(args[1], plugin.getServer().getOnlinePlayers().stream()
-                .map(Player::getName)
-                .toList());
-        }
-
-        if (args.length == 2 && args[0].equalsIgnoreCase("remove")) {
-            MaintenanceManager maintenanceManager = plugin.getMaintenanceManager();
-            if (maintenanceManager == null) {
-                return List.of();
-            }
-            return complete(args[1], maintenanceManager.getWhitelistEntries());
-        }
-
-        return List.of();
-    }
-
-    private List<String> complete(String input, List<String> options) {
-        String partial = input.toLowerCase(Locale.ROOT);
-        List<String> completions = new ArrayList<>();
-        for (String option : options) {
-            if (option.toLowerCase(Locale.ROOT).startsWith(partial)) {
-                completions.add(option);
-            }
-        }
-        return completions;
-    }
-}
@@ -8,6 +8,8 @@ import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.InventoryHolder;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;

 import java.util.List;
 import java.util.Map;
@@ -20,7 +22,7 @@ public class MobDropCommand extends BaseCommand {
    public static final class MobDropMenuHolder implements InventoryHolder {
        private final Inventory inventory;

-        public MobDropMenuHolder(String title) {
+        public MobDropMenuHolder(Component title) {
            this.inventory = Bukkit.createInventory(this, MENU_SIZE, title);
        }

@@ -42,22 +44,22 @@ public class MobDropCommand extends BaseCommand {

    public static void openMobDropMenu(EssentialsC plugin, Player player) {
        var lang = EssentialsC.getLangManager();
-        boolean endermanEnabled = plugin.getConfig().getBoolean("mob-drops.enderman.enabled", true);
-        String status = lang.getString(endermanEnabled
+        boolean endermanDropsAllowed = plugin.getConfig().getBoolean("mob-drops.enderman.allow-drops", true);
+        String status = lang.getString(endermanDropsAllowed
            ? "mobdrops-menu.status.enabled"
            : "mobdrops-menu.status.disabled");

-        Inventory menu = new MobDropMenuHolder(lang.getString("mobdrops-menu.title")).getInventory();
+        Inventory menu = new MobDropMenuHolder(lang.getComponent("mobdrops-menu.title")).getInventory();

        ItemStack endermanItem = new ItemStack(Material.ENDER_PEARL);
        ItemMeta endermanMeta = endermanItem.getItemMeta();
        if (endermanMeta != null) {
-            endermanMeta.setDisplayName(lang.getString("mobdrops-menu.enderman.name"));
-            endermanMeta.setLore(List.of(
+            endermanMeta.displayName(legacyComponent(lang.getString("mobdrops-menu.enderman.name")));
+            endermanMeta.lore(List.of(
                lang.getString("mobdrops-menu.enderman.status", Map.of("status", status)),
                "",
                lang.getString("mobdrops-menu.enderman.toggle")
-            ));
+            ).stream().map(MobDropCommand::legacyComponent).toList());
            endermanItem.setItemMeta(endermanMeta);
        }
        menu.setItem(ENDERMAN_SLOT, endermanItem);
@@ -65,7 +67,7 @@ public class MobDropCommand extends BaseCommand {
        ItemStack glass = new ItemStack(Material.BLACK_STAINED_GLASS_PANE);
        ItemMeta glassMeta = glass.getItemMeta();
        if (glassMeta != null) {
-            glassMeta.setDisplayName(" ");
+            glassMeta.displayName(Component.text(" "));
            glass.setItemMeta(glassMeta);
        }

@@ -82,6 +84,10 @@ public class MobDropCommand extends BaseCommand {
        return ENDERMAN_SLOT;
    }

+    private static Component legacyComponent(String text) {
+        return LegacyComponentSerializer.legacySection().deserialize(text == null ? "" : text);
+    }
+
    private void openMobDropMenu(Player player) {
        openMobDropMenu(plugin, player);
    }
@@ -1,19 +1,12 @@
 package cn.infstar.essentialsC.commands;

-import org.bukkit.NamespacedKey;
 import org.bukkit.Sound;
 import org.bukkit.entity.Player;
-import org.bukkit.potion.PotionEffect;
-import org.bukkit.potion.PotionEffectType;
-import org.bukkit.persistence.PersistentDataType;

 public class NightVisionCommand extends BaseCommand {

-    private final NamespacedKey enabledKey;
-
    public NightVisionCommand() {
        super("essentialsc.command.nightvision");
-        this.enabledKey = new NamespacedKey(plugin, "nightvision_enabled");
    }

    @Override
@@ -26,15 +19,11 @@ public class NightVisionCommand extends BaseCommand {
        }

        if (targetState) {
-            player.addPotionEffect(new PotionEffect(PotionEffectType.NIGHT_VISION, Integer.MAX_VALUE, 0, false, false, false));
-            player.getPersistentDataContainer().set(enabledKey, PersistentDataType.BYTE, (byte) 1);
+            plugin.getPlayerStateManager().enableNightVision(player);
            playShortcutSound(player, Sound.BLOCK_BEACON_POWER_SELECT);
            player.sendMessage(getLang().getPrefixedString("messages.nightvision-enabled"));
        } else {
-            if (currentState) {
-                player.removePotionEffect(PotionEffectType.NIGHT_VISION);
-                player.getPersistentDataContainer().remove(enabledKey);
-            }
+            plugin.getPlayerStateManager().disableNightVision(player);
            playShortcutSound(player, Sound.BLOCK_BEACON_DEACTIVATE);
            player.sendMessage(getLang().getPrefixedString("messages.nightvision-disabled"));
        }
@@ -55,7 +44,6 @@ public class NightVisionCommand extends BaseCommand {
    }

    private boolean isPluginNightVisionEnabled(Player player) {
-        Byte value = player.getPersistentDataContainer().get(enabledKey, PersistentDataType.BYTE);
-        return value != null && value == (byte) 1;
+        return plugin.getPlayerStateManager().isNightVisionEnabled(player);
    }
 }
@@ -1,8 +1,8 @@
 package cn.infstar.essentialsC.commands;

 import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
 import org.bukkit.OfflinePlayer;
+import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;

 import java.text.SimpleDateFormat;
@@ -17,42 +17,57 @@ public class SeenCommand extends BaseCommand {

    @Override
    protected boolean execute(Player player, String[] args) {
+        return executeCommand(player, player, args);
+    }
+
+    @Override
+    protected boolean executeConsole(CommandSender sender, String[] args) {
+        return executeCommand(sender, null, args);
+    }
+
+    private boolean executeCommand(CommandSender sender, Player viewer, String[] args) {
        if (args.length == 0) {
-            player.sendMessage(getLang().getPrefixedString("messages.seen-usage"));
+            sender.sendMessage(getLang().getPrefixedString(viewer == null
+                ? "messages.seen-usage-console"
+                : "messages.seen-usage"));
+            return true;
+        }
+
+        Player onlineTarget = Bukkit.getPlayerExact(args[0]);
+        if (onlineTarget != null && VanishCommand.isVanished(onlineTarget)
+            && viewer != null && !viewer.hasPermission(VanishCommand.SEE_PERMISSION)) {
+            sender.sendMessage(getLang().getPrefixedString("messages.player-not-found", Map.of("player", args[0])));
            return true;
        }

        OfflinePlayer target = Bukkit.getOfflinePlayer(args[0]);
        if (!target.hasPlayedBefore() && !target.isOnline()) {
-            player.sendMessage(getLang().getPrefixedString("messages.player-not-found", Map.of("player", args[0])));
+            sender.sendMessage(getLang().getPrefixedString("messages.player-not-found", Map.of("player", args[0])));
            return true;
        }

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
-        StringBuilder info = new StringBuilder();
-        info.append(getLang().getPrefix()).append(ChatColor.GOLD).append("玩家信息: ")
-            .append(ChatColor.WHITE).append(target.getName()).append("\n");
+        sender.sendMessage(getLang().getPrefixedComponent("messages.seen-header",
+            Map.of("player", String.valueOf(target.getName()))));

        if (target.isOnline()) {
-            info.append(ChatColor.GRAY).append("状态: ").append(ChatColor.GREEN).append("在线").append("\n");
+            sender.sendMessage(getLang().getComponent("messages.seen-status-online"));
            Player onlinePlayer = target.getPlayer();
            if (onlinePlayer != null) {
-                info.append(ChatColor.GRAY).append("所在世界: ").append(ChatColor.WHITE)
-                    .append(onlinePlayer.getWorld().getName()).append("\n");
+                sender.sendMessage(getLang().getComponent("messages.seen-world",
+                    Map.of("world", onlinePlayer.getWorld().getName())));
            }
        } else {
-            info.append(ChatColor.GRAY).append("状态: ").append(ChatColor.RED).append("离线").append("\n");
+            sender.sendMessage(getLang().getComponent("messages.seen-status-offline"));
            long lastSeen = target.getLastSeen();
            if (lastSeen > 0) {
-                info.append(ChatColor.GRAY).append("最后在线: ").append(ChatColor.WHITE)
-                    .append(format.format(new Date(lastSeen))).append("\n");
+                sender.sendMessage(getLang().getComponent("messages.seen-last-online",
+                    Map.of("time", format.format(new Date(lastSeen)))));
            }
        }

-        info.append(ChatColor.GRAY).append("首次加入: ").append(ChatColor.WHITE)
-            .append(format.format(new Date(target.getFirstPlayed())));
-
-        player.sendMessage(info.toString());
+        sender.sendMessage(getLang().getComponent("messages.seen-first-joined",
+            Map.of("time", format.format(new Date(target.getFirstPlayed())))));
        return true;
    }
 }
@@ -14,6 +14,10 @@ import java.util.Map;

 public final class SkinBridgeCommand extends BaseCommand implements TabCompleter {

+    private static final String STATUS_PERMISSION = "essentialsc.command.skin.status";
+    private static final String REFRESH_PERMISSION = "essentialsc.command.skin.refresh";
+    private static final String OTHERS_PERMISSION = "essentialsc.command.skin.others";
+
    public SkinBridgeCommand() {
        super("essentialsc.command.skin");
    }
@@ -54,11 +58,29 @@ public final class SkinBridgeCommand extends BaseCommand implements TabCompleter
        }

        String action = args[0].toLowerCase(Locale.ROOT);
+        boolean targetsOther = sender instanceof Player playerSender
+            && !playerSender.getUniqueId().equals(target.getUniqueId());
        if (action.equals("status")) {
+            if (!hasPermission(sender, STATUS_PERMISSION)) {
+                sendNoPermission(sender, STATUS_PERMISSION);
+                return true;
+            }
+            if (targetsOther && !hasPermission(sender, OTHERS_PERMISSION)) {
+                sendNoPermission(sender, OTHERS_PERMISSION);
+                return true;
+            }
            sendStatus(sender, target, manager);
            return true;
        }
        if (action.equals("refresh")) {
+            if (!hasPermission(sender, REFRESH_PERMISSION)) {
+                sendNoPermission(sender, REFRESH_PERMISSION);
+                return true;
+            }
+            if (targetsOther && !hasPermission(sender, OTHERS_PERMISSION)) {
+                sendNoPermission(sender, OTHERS_PERMISSION);
+                return true;
+            }
            sendRefreshResult(sender, target, manager.queueSync(target, true));
            return true;
        }
@@ -67,11 +89,15 @@ public final class SkinBridgeCommand extends BaseCommand implements TabCompleter
        return true;
    }

+    private boolean hasPermission(CommandSender sender, String permission) {
+        return !(sender instanceof Player) || sender.hasPermission(permission);
+    }
+
+    private void sendNoPermission(CommandSender sender, String permission) {
+        sender.sendMessage(getLang().getPrefixedString("messages.no-permission", Map.of("permission", permission)));
+    }
+
    private void sendStatus(CommandSender sender, Player target, SkinBridgeManager manager) {
-        if (!manager.isEnabled()) {
-            sender.sendMessage(getLang().getPrefixedString("skin-bridge.messages.feature-disabled"));
-            return;
-        }
        if (!manager.isSkinGatewayAvailable()) {
            sender.sendMessage(getLang().getPrefixedString("skin-bridge.messages.dependency-missing"));
            return;
@@ -85,6 +111,7 @@ public final class SkinBridgeCommand extends BaseCommand implements TabCompleter
        Map<String, String> placeholders = Map.of("player", target.getName(), "provider", String.valueOf(status.providerId()));
        switch (status.state()) {
            case EXTERNAL -> sender.sendMessage(getLang().getPrefixedString("skin-bridge.messages.status-external", placeholders));
+            case EXCLUDED -> sender.sendMessage(getLang().getPrefixedString("skin-bridge.messages.status-excluded", placeholders));
            case NOT_EXTERNAL -> sender.sendMessage(getLang().getPrefixedString("skin-bridge.messages.status-not-external", placeholders));
            case PENDING -> sender.sendMessage(getLang().getPrefixedString("skin-bridge.messages.status-pending", placeholders));
            case UNKNOWN -> sender.sendMessage(getLang().getPrefixedString("skin-bridge.messages.status-unknown", placeholders));
@@ -97,10 +124,18 @@ public final class SkinBridgeCommand extends BaseCommand implements TabCompleter
            case QUEUED -> "skin-bridge.messages.refresh-queued";
            case CACHED -> "skin-bridge.messages.refresh-cached";
            case ALREADY_RUNNING -> "skin-bridge.messages.refresh-running";
-            case FEATURE_DISABLED -> "skin-bridge.messages.feature-disabled";
+            case EXCLUDED -> "skin-bridge.messages.refresh-excluded";
+            case QUEUE_FULL -> "skin-bridge.messages.queue-full";
            case DEPENDENCY_MISSING -> "skin-bridge.messages.dependency-missing";
            case NO_PROVIDERS -> "skin-bridge.messages.no-providers";
+            case REFRESH_COOLDOWN -> "skin-bridge.messages.refresh-cooldown";
        };
+        if (result == SkinBridgeManager.SyncResult.REFRESH_COOLDOWN) {
+            placeholders = Map.of(
+                "player", target.getName(),
+                "seconds", String.valueOf(plugin.getSkinBridgeManager().getRemainingForceRefreshCooldownSeconds(target))
+            );
+        }
        sender.sendMessage(getLang().getPrefixedString(messagePath, placeholders));
    }

@@ -108,11 +143,20 @@ public final class SkinBridgeCommand extends BaseCommand implements TabCompleter
    public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
        if (args.length == 1) {
            String partial = args[0].toLowerCase(Locale.ROOT);
-            return List.of("status", "refresh").stream()
+            List<String> actions = new ArrayList<>();
+            if (hasPermission(sender, STATUS_PERMISSION)) {
+                actions.add("status");
+            }
+            if (hasPermission(sender, REFRESH_PERMISSION)) {
+                actions.add("refresh");
+            }
+            return actions.stream()
                .filter(option -> option.startsWith(partial))
                .toList();
        }
-        if (args.length == 2 && (args[0].equalsIgnoreCase("status") || args[0].equalsIgnoreCase("refresh"))) {
+        if (args.length == 2 && hasPermission(sender, OTHERS_PERMISSION)
+            && ((args[0].equalsIgnoreCase("status") && hasPermission(sender, STATUS_PERMISSION))
+            || (args[0].equalsIgnoreCase("refresh") && hasPermission(sender, REFRESH_PERMISSION)))) {
            String partial = args[1].toLowerCase(Locale.ROOT);
            List<String> players = new ArrayList<>();
            for (Player onlinePlayer : Bukkit.getOnlinePlayers()) {
@@ -3,6 +3,7 @@ package cn.infstar.essentialsC.commands;
 import org.bukkit.Material;
 import org.bukkit.Sound;
 import org.bukkit.entity.Player;
+import org.bukkit.inventory.MenuType;

 public class SmithingTableCommand extends BaseCommand {

@@ -12,7 +13,7 @@ public class SmithingTableCommand extends BaseCommand {

    @Override
    protected boolean execute(Player player, String[] args) {
-        player.openSmithingTable(null, true);
+        player.openInventory(MenuType.SMITHING.builder().checkReachable(false).build(player));
        playBlockShortcutSound(player, Material.SMITHING_TABLE, Sound.BLOCK_SMITHING_TABLE_USE);
        return true;
    }
@@ -3,6 +3,7 @@ package cn.infstar.essentialsC.commands;
 import org.bukkit.Material;
 import org.bukkit.Sound;
 import org.bukkit.entity.Player;
+import org.bukkit.inventory.MenuType;

 public class StonecutterCommand extends BaseCommand {

@@ -12,7 +13,7 @@ public class StonecutterCommand extends BaseCommand {

    @Override
    protected boolean execute(Player player, String[] args) {
-        player.openStonecutter(null, true);
+        player.openInventory(MenuType.STONECUTTER.builder().checkReachable(false).build(player));
        playBlockShortcutSound(player, Material.STONECUTTER, Sound.UI_STONECUTTER_SELECT_RECIPE);
        return true;
    }
@@ -17,10 +17,13 @@ public final class TpIgnoreCommand extends BaseCommand {
            return true;
        }

-        boolean ignoring = manager.toggleIgnoringRequests(player);
-        player.sendMessage(getLang().getPrefixedComponent(ignoring
-            ? "tpa.messages.ignore-enabled"
-            : "tpa.messages.ignore-disabled"));
+        TeleportRequestManager.ToggleIgnoreResult result = manager.toggleIgnoringRequests(player);
+        String messagePath = switch (result) {
+            case ENABLED -> "tpa.messages.ignore-enabled";
+            case DISABLED -> "tpa.messages.ignore-disabled";
+            case SAVE_FAILED -> "tpa.messages.ignore-save-failed";
+        };
+        player.sendMessage(getLang().getPrefixedComponent(messagePath));
        return true;
    }
 }
@@ -66,6 +66,9 @@ public class TpaCommand extends BaseCommand implements TabCompleter {
                Map.of("seconds", String.valueOf(createdRequest.cooldownSeconds()))));
            return true;
        }
+        if (createdRequest.status() == TeleportRequestManager.CreateRequestStatus.CANCELLED) {
+            return true;
+        }

        TeleportRequestManager.TeleportRequest request = createdRequest.request();
        Map<String, String> placeholders = manager.placeholders(request);
@@ -63,17 +63,37 @@ public class TpsBarCommand extends BaseCommand implements TabCompleter {

    @Override
    protected boolean executeConsole(CommandSender sender, String[] args) {
-        sender.sendMessage(getLang().getPrefixedString("messages.player-only"));
+        TpsBarService tpsBarService = plugin.getTpsBarManager();
+        if (tpsBarService == null) {
+            sender.sendMessage(getLang().getPrefixedString("messages.module-disabled"));
+            return true;
+        }
+        if (args.length != 1) {
+            sender.sendMessage(tpsBarService.getUsageMessage());
+            return true;
+        }
+        if (!sender.hasPermission("essentialsc.command.tpsbar.others")) {
+            sender.sendMessage(getLang().getPrefixedString("messages.no-permission",
+                Map.of("permission", "essentialsc.command.tpsbar.others")));
+            return true;
+        }
+
+        Player target = Bukkit.getPlayerExact(args[0]);
+        if (target == null) {
+            sender.sendMessage(tpsBarService.getPlayerNotFoundMessage(args[0]));
+            return true;
+        }
+
+        boolean enabled = tpsBarService.toggle(target);
+        sender.sendMessage(getLang().getPrefixedString(enabled
+            ? "tpsbar.messages.enabled-other"
+            : "tpsbar.messages.disabled-other", Map.of("player", target.getName())));
        return true;
    }

    @Override
    public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
-        if (args.length != 1 || !(sender instanceof Player player)) {
-            return List.of();
-        }
-
-        if (!player.hasPermission("essentialsc.command.tpsbar.others")) {
+        if (args.length != 1 || !sender.hasPermission("essentialsc.command.tpsbar.others")) {
            return List.of();
        }

@@ -1,8 +1,14 @@
 package cn.infstar.essentialsC.commands;

 import cn.infstar.essentialsC.EssentialsC;
+import cn.infstar.essentialsC.util.AtomicYamlWriter;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.entity.Player;

+import java.io.File;
+import java.io.IOException;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.UUID;
@@ -10,6 +16,8 @@ import java.util.UUID;
 public class VanishCommand extends BaseCommand {

    private static final Set<UUID> vanishedPlayers = new HashSet<>();
+    public static final String SEE_PERMISSION = "essentialsc.vanish.see";
+    private static File stateFile;

    public VanishCommand() {
        super("essentialsc.command.vanish");
@@ -21,17 +29,52 @@ public class VanishCommand extends BaseCommand {

        if (vanishedPlayers.contains(uuid)) {
            vanishedPlayers.remove(uuid);
+            if (!saveState(plugin)) {
+                vanishedPlayers.add(uuid);
+                player.sendMessage(getLang().getPrefixedString("messages.vanish-save-failed"));
+                return true;
+            }
            showPlayerToAll(plugin, player);
            player.sendMessage(getLang().getPrefixedString("messages.vanish-disabled"));
        } else {
            vanishedPlayers.add(uuid);
+            if (!saveState(plugin)) {
+                vanishedPlayers.remove(uuid);
+                player.sendMessage(getLang().getPrefixedString("messages.vanish-save-failed"));
+                return true;
+            }
            hidePlayerFromAll(plugin, player);
            player.sendMessage(getLang().getPrefixedString("messages.vanish-enabled"));
        }
        return true;
    }

+    public static void loadState(EssentialsC plugin) {
+        stateFile = new File(plugin.getDataFolder(), "vanished-players.yml");
+        vanishedPlayers.clear();
+        if (!stateFile.exists()) {
+            return;
+        }
+        YamlConfiguration state = new YamlConfiguration();
+        try {
+            state.load(stateFile);
+        } catch (IOException | InvalidConfigurationException exception) {
+            plugin.getLogger().severe("加载 vanished-players.yml 失败: " + exception.getMessage());
+            throw new IllegalStateException("无法加载 vanished-players.yml，请修复文件格式后重试。", exception);
+        }
+        for (String value : state.getStringList("players")) {
+            try {
+                vanishedPlayers.add(UUID.fromString(value));
+            } catch (IllegalArgumentException ignored) {
+                plugin.getLogger().warning("忽略无效的隐身玩家 UUID: " + value);
+            }
+        }
+    }
+
    public static void hideVanishedPlayersFrom(EssentialsC plugin, Player observer) {
+        if (observer.hasPermission(SEE_PERMISSION)) {
+            return;
+        }
        for (Player vanished : plugin.getServer().getOnlinePlayers()) {
            if (!observer.equals(vanished) && isVanished(vanished)) {
                observer.hidePlayer(plugin, vanished);
@@ -39,8 +82,28 @@ public class VanishCommand extends BaseCommand {
        }
    }

-    public static void removeVanished(Player player) {
-        vanishedPlayers.remove(player.getUniqueId());
+    public static boolean restoreVisibility(EssentialsC plugin, Player player, boolean notify) {
+        if (!vanishedPlayers.remove(player.getUniqueId())) {
+            return true;
+        }
+        if (!saveState(plugin)) {
+            vanishedPlayers.add(player.getUniqueId());
+            if (notify) {
+                player.sendMessage(EssentialsC.getLangManager().getPrefixedString("messages.vanish-save-failed"));
+            }
+            return false;
+        }
+        showPlayerToAll(plugin, player);
+        if (notify) {
+            player.sendMessage(EssentialsC.getLangManager().getPrefixedString("messages.vanish-permission-removed"));
+        }
+        return true;
+    }
+
+    public static void applyHiddenState(EssentialsC plugin, Player player) {
+        if (isVanished(player)) {
+            hidePlayerFromAll(plugin, player);
+        }
    }

    public static void clearAll(EssentialsC plugin) {
@@ -54,7 +117,7 @@ public class VanishCommand extends BaseCommand {

    private static void hidePlayerFromAll(EssentialsC plugin, Player player) {
        for (Player online : player.getServer().getOnlinePlayers()) {
-            if (online != player) {
+            if (online != player && !online.hasPermission(SEE_PERMISSION)) {
                online.hidePlayer(plugin, player);
            }
        }
@@ -71,4 +134,19 @@ public class VanishCommand extends BaseCommand {
    public static boolean isVanished(Player player) {
        return vanishedPlayers.contains(player.getUniqueId());
    }
+
+    private static boolean saveState(EssentialsC plugin) {
+        if (stateFile == null) {
+            stateFile = new File(plugin.getDataFolder(), "vanished-players.yml");
+        }
+        FileConfiguration state = new YamlConfiguration();
+        state.set("players", vanishedPlayers.stream().map(UUID::toString).sorted().toList());
+        try {
+            AtomicYamlWriter.save(state, stateFile);
+            return true;
+        } catch (Exception exception) {
+            plugin.getLogger().warning("保存 vanished-players.yml 失败: " + exception.getMessage());
+            return false;
+        }
+    }
 }
@@ -3,6 +3,7 @@ package cn.infstar.essentialsC.commands;
 import org.bukkit.Material;
 import org.bukkit.Sound;
 import org.bukkit.entity.Player;
+import org.bukkit.inventory.MenuType;

 public class WorkbenchCommand extends BaseCommand {

@@ -12,7 +13,7 @@ public class WorkbenchCommand extends BaseCommand {

    @Override
    protected boolean execute(Player player, String[] args) {
-        player.openWorkbench(null, true);
+        player.openInventory(MenuType.CRAFTING.builder().checkReachable(false).build(player));
        playBlockShortcutSound(player, Material.CRAFTING_TABLE, Sound.UI_BUTTON_CLICK);
        return true;
    }
@@ -1,161 +0,0 @@
-package cn.infstar.essentialsC.listeners;
-
-import cn.infstar.essentialsC.EssentialsC;
-import cn.infstar.essentialsC.compat.jei.JeiRecipeSyncAdapter;
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerJoinEvent;
-
-import java.util.Locale;
-import java.util.logging.Level;
-
-/**
- * 为 Fabric / NeoForge 客户端补发配方同步数据，修复 1.21.2+ 的 JEI 配方显示问题。
- */
-public class JeiRecipeSyncListener implements Listener {
-
-    private final EssentialsC plugin;
-    private final boolean enabled;
-    private final boolean debug;
-    private final boolean sendPlayerMessage;
-    private final int brandCheckDelayTicks;
-    private final JeiRecipeSyncAdapter adapter;
-
-    public JeiRecipeSyncListener(EssentialsC plugin) {
-        this.plugin = plugin;
-
-        FileConfiguration config = plugin.getConfig();
-        config.addDefault("jei-sync.brand-check-delay-ticks", 20);
-        config.options().copyDefaults(true);
-        plugin.saveConfig();
-
-        this.enabled = config.getBoolean("jei-sync.enabled", true);
-        this.debug = config.getBoolean("debug", false);
-        this.sendPlayerMessage = config.getBoolean("jei-sync.send-player-message", true);
-        this.brandCheckDelayTicks = Math.max(0, config.getInt("jei-sync.brand-check-delay-ticks", 20));
-        this.adapter = loadAdapter();
-    }
-
-    @EventHandler
-    public void onPlayerJoin(PlayerJoinEvent event) {
-        if (!enabled) {
-            return;
-        }
-        if (adapter == null) {
-            if (debug) {
-                plugin.getLogger().warning("当前服务端版本没有可用的 JEI 配方同步适配器。");
-            }
-            return;
-        }
-
-        Player player = event.getPlayer();
-        plugin.getServer().getScheduler().runTaskLater(plugin, () -> detectAndSync(player), brandCheckDelayTicks);
-    }
-
-    private void detectAndSync(Player player) {
-        if (!player.isOnline()) {
-            return;
-        }
-
-        String clientBrand = player.getClientBrandName();
-
-        if (debug) {
-            plugin.getLogger().info("JEI 客户端检测: player=" + player.getName()
-                + ", brand=" + (clientBrand == null || clientBrand.isBlank() ? "unknown" : clientBrand)
-                + ", delayTicks=" + brandCheckDelayTicks);
-        }
-
-        if (clientBrand == null || clientBrand.isEmpty()) {
-            if (debug) {
-                plugin.getLogger().info("跳过 " + player.getName() + "：客户端品牌为空");
-            }
-            return;
-        }
-
-        String brandLower = clientBrand.toLowerCase(Locale.ROOT);
-        if (brandLower.contains("fabric")) {
-            if (debug) {
-                plugin.getLogger().info("检测到 Fabric 客户端，开始发送配方同步...");
-            }
-            sendPlayerMessage(player, "Fabric");
-            sendFabricRecipeSync(player);
-            return;
-        }
-
-        if (brandLower.contains("neoforge") || brandLower.contains("forge")) {
-            if (debug) {
-                plugin.getLogger().info("检测到 NeoForge/Forge 客户端，开始发送配方同步...");
-            }
-            sendPlayerMessage(player, "NeoForge");
-            sendNeoForgeRecipeSync(player);
-            return;
-        }
-
-        if (debug) {
-            plugin.getLogger().info("跳过 " + player.getName() + "：不支持的客户端类型 '" + clientBrand + "'");
-        }
-    }
-
-    private void sendPlayerMessage(Player player, String clientType) {
-        if (!sendPlayerMessage) {
-            return;
-        }
-
-        String messageKey;
-        if (clientType.equalsIgnoreCase("fabric")) {
-            messageKey = "messages.jei-sync-fabric";
-        } else if (clientType.equalsIgnoreCase("neoforge")) {
-            messageKey = "messages.jei-sync-neoforge";
-        } else {
-            return;
-        }
-
-        player.sendMessage(EssentialsC.getLangManager().getPrefixedComponent(messageKey));
-    }
-
-    private void sendFabricRecipeSync(Player player) {
-        try {
-            adapter.sendFabricRecipeSync(player, plugin.getLogger(), debug);
-        } catch (Exception e) {
-            plugin.getLogger().warning("发送 Fabric 配方同步失败: " + e.getMessage());
-            if (debug) {
-                plugin.getLogger().log(Level.WARNING, "Fabric 配方同步异常详情", e);
-            }
-        }
-    }
-
-    private void sendNeoForgeRecipeSync(Player player) {
-        try {
-            adapter.sendNeoForgeRecipeSync(player, plugin.getLogger(), debug);
-        } catch (Exception e) {
-            plugin.getLogger().warning("发送 NeoForge 配方同步失败: " + e.getMessage());
-            if (debug) {
-                plugin.getLogger().log(Level.WARNING, "NeoForge 配方同步异常详情", e);
-            }
-        }
-    }
-
-    private JeiRecipeSyncAdapter loadAdapter() {
-        String versionKey = plugin.getServer().getBukkitVersion().split("-")[0]
-            .replace('.', '_');
-        String className = "cn.infstar.essentialsC.v" + versionKey + ".jei.JeiRecipeSyncAdapterImpl";
-        try {
-            Class<?> adapterClass = Class.forName(className);
-            Object instance = adapterClass.getDeclaredConstructor().newInstance();
-            if (instance instanceof JeiRecipeSyncAdapter jeiRecipeSyncAdapter) {
-                if (debug) {
-                    plugin.getLogger().info("已加载 JEI 配方同步适配器: " + className);
-                }
-                return jeiRecipeSyncAdapter;
-            }
-            plugin.getLogger().warning("JEI 配方同步适配器类型无效: " + className);
-        } catch (ReflectiveOperationException | LinkageError e) {
-            if (debug) {
-                plugin.getLogger().warning("加载 JEI 配方同步适配器失败: " + className + " (" + e.getMessage() + ")");
-            }
-        }
-        return null;
-    }
-}
@@ -10,7 +10,7 @@ import org.bukkit.event.entity.EntityDeathEvent;
 public class MobDropListener implements Listener {

    private final EssentialsC plugin;
-    private boolean endermanDropEnabled;
+    private boolean endermanDropsAllowed;

    public MobDropListener(EssentialsC plugin) {
        this.plugin = plugin;
@@ -19,16 +19,10 @@ public class MobDropListener implements Listener {

    private void loadConfig() {
        FileConfiguration config = plugin.getConfig();
-        config.addDefault("mob-drops.enderman.enabled", true);
+        config.addDefault("mob-drops.enderman.allow-drops", true);
        config.options().copyDefaults(true);

-        try {
-            config.save(plugin.getDataFolder().toPath().resolve("config.yml").toFile());
-        } catch (Exception e) {
-            plugin.getLogger().warning("无法保存配置文件: " + e.getMessage());
-        }
-
-        this.endermanDropEnabled = config.getBoolean("mob-drops.enderman.enabled", true);
+        this.endermanDropsAllowed = config.getBoolean("mob-drops.enderman.allow-drops", true);
    }

    @EventHandler
@@ -37,13 +31,13 @@ public class MobDropListener implements Listener {
            return;
        }

-        if (!plugin.getConfig().getBoolean("mob-drops.enderman.enabled", true)) {
+        if (!plugin.getConfig().getBoolean("mob-drops.enderman.allow-drops", true)) {
            event.getDrops().clear();
        }
    }

    public void reload() {
        loadConfig();
-        plugin.getLogger().info("生物掉落配置已重载（末影人: " + (endermanDropEnabled ? "开启" : "关闭") + "）");
+        plugin.getLogger().info("生物掉落配置已重载（末影人掉落: " + (endermanDropsAllowed ? "允许" : "禁止") + "）");
    }
 }
@@ -18,7 +18,6 @@ public class MobDropMenuListener implements Listener {

    public MobDropMenuListener(EssentialsC plugin) {
        this.plugin = plugin;
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
    }

    @EventHandler
@@ -39,6 +38,12 @@ public class MobDropMenuListener implements Listener {
        }

        if (event.getRawSlot() == MobDropCommand.getEndermanSlot()) {
+            if (!player.hasPermission("essentialsc.mobdrops.enderman")) {
+                player.sendMessage(EssentialsC.getLangManager().getPrefixedString("messages.no-permission",
+                    Map.of("permission", "essentialsc.mobdrops.enderman")));
+                player.closeInventory();
+                return;
+            }
            toggleEndermanDrops(player);
            Bukkit.getScheduler().runTaskLater(plugin, () -> MobDropCommand.openMobDropMenu(plugin, player), 2L);
        }
@@ -46,14 +51,11 @@ public class MobDropMenuListener implements Listener {

    private void toggleEndermanDrops(Player player) {
        FileConfiguration config = plugin.getConfig();
-        boolean newValue = !config.getBoolean("mob-drops.enderman.enabled", true);
-        config.set("mob-drops.enderman.enabled", newValue);
-
-        try {
-            config.save(plugin.getDataFolder().toPath().resolve("config.yml").toFile());
-        } catch (Exception e) {
+        boolean newValue = !config.getBoolean("mob-drops.enderman.allow-drops", true);
+        if (!plugin.getFeatureConfigManager().updateMainConfigValue(
+            "mob-drops.enderman.allow-drops", newValue)) {
            player.sendMessage(EssentialsC.getLangManager().getPrefixedString("messages.mobdrop-save-failed",
-                Map.of("error", e.getMessage())));
+                Map.of("error", "无法写入 config.yml")));
            return;
        }

@@ -1,8 +1,10 @@
 package cn.infstar.essentialsC.listeners;

 import cn.infstar.essentialsC.EssentialsC;
+import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
 import org.bukkit.Sound;
 import org.bukkit.block.ShulkerBox;
 import org.bukkit.entity.Player;
@@ -10,13 +12,18 @@ import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.PlayerDeathEvent;
 import org.bukkit.event.inventory.ClickType;
 import org.bukkit.event.inventory.InventoryClickEvent;
 import org.bukkit.event.inventory.InventoryCloseEvent;
 import org.bukkit.event.inventory.InventoryDragEvent;
+import org.bukkit.event.inventory.InventoryType;
+import org.bukkit.event.player.PlayerDropItemEvent;
 import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerKickEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.player.PlayerSwapHandItemsEvent;
 import org.bukkit.event.server.PluginDisableEvent;
 import org.bukkit.inventory.EquipmentSlot;
 import org.bukkit.inventory.Inventory;
@@ -26,18 +33,20 @@ import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.PlayerInventory;
 import org.bukkit.inventory.meta.BlockStateMeta;
 import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.persistence.PersistentDataType;

-import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
-
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
+import java.util.function.Consumer;

 public class ShulkerBoxListener implements Listener {

    private static final int SHULKER_SIZE = 27;
+    private static final int OFF_HAND_SLOT = 40;

    private static final Set<Material> SHULKER_BOX_MATERIALS = Set.of(
        Material.SHULKER_BOX,
@@ -60,35 +69,44 @@ public class ShulkerBoxListener implements Listener {
    );

    private final EssentialsC plugin;
+    private final NamespacedKey sessionKey;
    private final Map<UUID, OpenShulkerSession> openShulkerBoxes = new HashMap<>();

    private static final class ShulkerBoxHolder implements InventoryHolder {
        private final Inventory inventory;

        private ShulkerBoxHolder(Component title) {
-            this.inventory = Bukkit.createInventory(this, SHULKER_SIZE, title);
+            this.inventory = Bukkit.createInventory(this, InventoryType.SHULKER_BOX, title);
        }

        @Override
        public Inventory getInventory() {
-            return this.inventory;
+            return inventory;
        }
    }

    private static final class OpenShulkerSession {
-        private final ItemStack sourceItem;
-        private final EquipmentSlot sourceHand;
+        private final String token;
+        private final Inventory inventory;
        private final int preferredSlot;
+        private boolean syncScheduled;

-        private OpenShulkerSession(ItemStack sourceItem, EquipmentSlot sourceHand, int preferredSlot) {
-            this.sourceItem = sourceItem;
-            this.sourceHand = sourceHand;
+        private OpenShulkerSession(String token, Inventory inventory, int preferredSlot) {
+            this.token = token;
+            this.inventory = inventory;
            this.preferredSlot = preferredSlot;
        }
    }

+    private record LocatedSource(ItemStack item, Consumer<ItemStack> save) {
+    }
+
    public ShulkerBoxListener(EssentialsC plugin) {
        this.plugin = plugin;
+        this.sessionKey = new NamespacedKey(plugin, "open_shulker_session");
+        for (Player player : Bukkit.getOnlinePlayers()) {
+            clearStaleSessionTokens(player);
+        }
    }

    @EventHandler(priority = EventPriority.HIGHEST)
@@ -102,6 +120,10 @@ public class ShulkerBoxListener implements Listener {
            return;
        }

+        if (event.useItemInHand() == org.bukkit.event.Event.Result.DENY) {
+            return;
+        }
+
        if (openShulkerBoxes.containsKey(player.getUniqueId())) {
            return;
        }
@@ -111,21 +133,15 @@ public class ShulkerBoxListener implements Listener {
        if (!isShulkerBox(sourceItem)) {
            return;
        }
+
+        event.setUseItemInHand(org.bukkit.event.Event.Result.DENY);
+        event.setUseInteractedBlock(org.bukkit.event.Event.Result.DENY);
+
        if (sourceItem.getAmount() != 1) {
            player.sendMessage(EssentialsC.getLangManager().getPrefixedString("messages.shulkerbox-unstack-first"));
            return;
        }

-        if (!(sourceItem.getItemMeta() instanceof BlockStateMeta blockStateMeta)) {
-            return;
-        }
-        if (!(blockStateMeta.getBlockState() instanceof ShulkerBox shulkerBox)) {
-            return;
-        }
-
-        event.setUseItemInHand(org.bukkit.event.Event.Result.DENY);
-        event.setUseInteractedBlock(org.bukkit.event.Event.Result.DENY);
-
        ItemStack sourceSnapshot = sourceItem.clone();
        plugin.getServer().getScheduler().runTask(plugin, () -> {
            if (!player.isOnline() || openShulkerBoxes.containsKey(player.getUniqueId())) {
@@ -137,7 +153,7 @@ public class ShulkerBoxListener implements Listener {
                return;
            }

-            openShulkerBox(player, hand, sourceSnapshot, shulkerBox);
+            openShulkerBox(player, hand, currentItem);
        });
    }

@@ -147,14 +163,33 @@ public class ShulkerBoxListener implements Listener {
            return;
        }

-        InventoryView view = event.getView();
-        Inventory topInventory = view.getTopInventory();
-        if (!(topInventory.getHolder(false) instanceof ShulkerBoxHolder)) {
+        OpenShulkerSession session = openShulkerBoxes.get(player.getUniqueId());
+        if (session == null || event.getView().getTopInventory() != session.inventory) {
            return;
        }

-        int topSize = topInventory.getSize();
-        boolean clickTopInventory = event.getRawSlot() >= 0 && event.getRawSlot() < topSize;
+        if (hasSessionToken(event.getCurrentItem(), session.token)
+            || hasSessionToken(event.getCursor(), session.token)) {
+            event.setCancelled(true);
+            return;
+        }
+
+        if (event.getClick() == ClickType.NUMBER_KEY) {
+            ItemStack hotbarItem = player.getInventory().getItem(event.getHotbarButton());
+            if (hasSessionToken(hotbarItem, session.token)) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+
+        if (event.getClick() == ClickType.SWAP_OFFHAND
+            && hasSessionToken(player.getInventory().getItemInOffHand(), session.token)) {
+            event.setCancelled(true);
+            return;
+        }
+
+        int topSize = session.inventory.getSize();
+        boolean clickTopInventory = ShulkerBoxSessionPolicy.isTopSlot(event.getRawSlot(), topSize);

        if (clickTopInventory && isShulkerBox(event.getCursor())) {
            event.setCancelled(true);
@@ -171,43 +206,46 @@ public class ShulkerBoxListener implements Listener {
            }
        }

-        if (clickTopInventory && event.getClick() == ClickType.SWAP_OFFHAND) {
-            ItemStack offHandItem = player.getInventory().getItemInOffHand();
-            if (isShulkerBox(offHandItem)) {
-                event.setCancelled(true);
-                sendNestedMessage(player);
-                return;
-            }
+        if (clickTopInventory && event.getClick() == ClickType.SWAP_OFFHAND
+            && isShulkerBox(player.getInventory().getItemInOffHand())) {
+            event.setCancelled(true);
+            sendNestedMessage(player);
+            return;
        }

        if (event.isShiftClick() && isShulkerBox(event.getCurrentItem())) {
            event.setCancelled(true);
            sendNestedMessage(player);
+            return;
        }
+
+        scheduleSynchronization(player, session);
    }

    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
    public void onInventoryDrag(InventoryDragEvent event) {
-        InventoryView view = event.getView();
-        Inventory topInventory = view.getTopInventory();
-        if (!(topInventory.getHolder(false) instanceof ShulkerBoxHolder)) {
+        if (!(event.getWhoClicked() instanceof Player player)) {
            return;
        }

-        if (!isShulkerBox(event.getOldCursor())) {
+        OpenShulkerSession session = openShulkerBoxes.get(player.getUniqueId());
+        if (session == null || event.getView().getTopInventory() != session.inventory) {
            return;
        }

-        int topSize = topInventory.getSize();
-        for (int rawSlot : event.getRawSlots()) {
-            if (rawSlot >= 0 && rawSlot < topSize) {
-                event.setCancelled(true);
-                if (event.getWhoClicked() instanceof Player player) {
-                    sendNestedMessage(player);
-                }
-                return;
-            }
+        if (hasSessionToken(event.getOldCursor(), session.token)) {
+            event.setCancelled(true);
+            return;
        }
+
+        if (isShulkerBox(event.getOldCursor())
+            && ShulkerBoxSessionPolicy.touchesTopInventory(event.getRawSlots(), session.inventory.getSize())) {
+            event.setCancelled(true);
+            sendNestedMessage(player);
+            return;
+        }
+
+        scheduleSynchronization(player, session);
    }

    @EventHandler
@@ -221,111 +259,436 @@ public class ShulkerBoxListener implements Listener {
        }
    }

+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onPlayerDropItem(PlayerDropItemEvent event) {
+        OpenShulkerSession session = openShulkerBoxes.get(event.getPlayer().getUniqueId());
+        if (session != null && hasSessionToken(event.getItemDrop().getItemStack(), session.token)) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onPlayerSwapHandItems(PlayerSwapHandItemsEvent event) {
+        OpenShulkerSession session = openShulkerBoxes.get(event.getPlayer().getUniqueId());
+        if (session == null) {
+            return;
+        }
+
+        if (hasSessionToken(event.getMainHandItem(), session.token)
+            || hasSessionToken(event.getOffHandItem(), session.token)) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onPlayerDeath(PlayerDeathEvent event) {
+        Player player = event.getPlayer();
+        OpenShulkerSession session = openShulkerBoxes.remove(player.getUniqueId());
+        if (session == null) {
+            return;
+        }
+
+        boolean saved;
+        if (event.getKeepInventory()) {
+            saved = writeSessionToPlayer(player, session, true);
+        } else {
+            saved = writeSessionToDrops(event.getDrops(), session);
+            if (!saved) {
+                saved = writeSessionToPlayer(player, session, true);
+            }
+        }
+
+        if (!saved) {
+            handleLostSource(player, session, "玩家死亡时未找到唯一的源物品");
+        }
+    }
+
    @EventHandler
    public void onPlayerQuit(PlayerQuitEvent event) {
-        Player player = event.getPlayer();
-        commitOpenShulker(player, player.getOpenInventory().getTopInventory());
+        commitCurrentSession(event.getPlayer());
    }

    @EventHandler
    public void onPlayerKick(PlayerKickEvent event) {
-        Player player = event.getPlayer();
-        commitOpenShulker(player, player.getOpenInventory().getTopInventory());
+        commitCurrentSession(event.getPlayer());
+    }
+
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        if (!openShulkerBoxes.containsKey(event.getPlayer().getUniqueId())) {
+            clearStaleSessionTokens(event.getPlayer());
+        }
    }

    @EventHandler
    public void onPluginDisable(PluginDisableEvent event) {
-        if (event.getPlugin() != plugin) {
+        if (event.getPlugin() == plugin) {
+            shutdown();
+        }
+    }
+
+    public void shutdown() {
+        for (UUID playerId : List.copyOf(openShulkerBoxes.keySet())) {
+            Player player = Bukkit.getPlayer(playerId);
+            if (player == null) {
+                openShulkerBoxes.remove(playerId);
+                plugin.getLogger().warning("潜影盒会话关闭失败: 玩家 " + playerId + " 已离线。");
+                continue;
+            }
+
+            OpenShulkerSession session = openShulkerBoxes.get(playerId);
+            boolean viewingSession = session != null && player.getOpenInventory().getTopInventory() == session.inventory;
+            commitCurrentSession(player);
+            if (viewingSession) {
+                player.closeInventory();
+            }
+        }
+    }
+
+    private void openShulkerBox(Player player, EquipmentSlot hand, ItemStack sourceItem) {
+        if (!(sourceItem.getItemMeta() instanceof BlockStateMeta blockStateMeta)
+            || !(blockStateMeta.getBlockState() instanceof ShulkerBox shulkerBox)) {
+            sendOpenFailedMessage(player);
            return;
        }

-        for (Player player : Bukkit.getOnlinePlayers()) {
-            commitOpenShulker(player, player.getOpenInventory().getTopInventory());
+        String token = UUID.randomUUID().toString();
+        ItemStack taggedSource = sourceItem.clone();
+        setSessionToken(taggedSource, token);
+        setItemInHand(player, hand, taggedSource);
+
+        ShulkerBoxHolder holder;
+        try {
+            holder = new ShulkerBoxHolder(resolveTitle(sourceItem));
+            holder.getInventory().setContents(cloneContents(shulkerBox.getInventory().getContents()));
+        } catch (RuntimeException exception) {
+            clearTokenFromPlayer(player, token);
+            plugin.getLogger().warning("打开潜影盒失败: " + exception.getMessage());
+            sendOpenFailedMessage(player);
+            return;
+        }
+
+        int preferredSlot = hand == EquipmentSlot.HAND ? player.getInventory().getHeldItemSlot() : OFF_HAND_SLOT;
+        OpenShulkerSession session = new OpenShulkerSession(token, holder.getInventory(), preferredSlot);
+        openShulkerBoxes.put(player.getUniqueId(), session);
+
+        try {
+            InventoryView openedView = player.openInventory(session.inventory);
+            if (openedView == null
+                || openedView.getTopInventory() != session.inventory
+                || player.getOpenInventory().getTopInventory() != session.inventory) {
+                rollbackFailedOpen(player, session);
+                return;
+            }
+        } catch (RuntimeException exception) {
+            plugin.getLogger().warning("打开潜影盒失败: " + exception.getMessage());
+            rollbackFailedOpen(player, session);
+            return;
+        }
+
+        player.playSound(player.getLocation(), Sound.BLOCK_SHULKER_BOX_OPEN, 0.8F, 1.0F);
+    }
+
+    private void rollbackFailedOpen(Player player, OpenShulkerSession session) {
+        openShulkerBoxes.remove(player.getUniqueId(), session);
+        clearTokenFromPlayer(player, session.token);
+        sendOpenFailedMessage(player);
+    }
+
+    private void scheduleSynchronization(Player player, OpenShulkerSession session) {
+        if (session.syncScheduled) {
+            return;
+        }
+
+        session.syncScheduled = true;
+        plugin.getServer().getScheduler().runTask(plugin, () -> {
+            session.syncScheduled = false;
+            if (openShulkerBoxes.get(player.getUniqueId()) != session) {
+                return;
+            }
+
+            if (!writeSessionToPlayer(player, session, false)) {
+                openShulkerBoxes.remove(player.getUniqueId(), session);
+                handleLostSource(player, session, "同步期间未找到唯一的源物品");
+                if (player.getOpenInventory().getTopInventory() == session.inventory) {
+                    player.closeInventory();
+                }
+            }
+        });
+    }
+
+    private void commitCurrentSession(Player player) {
+        OpenShulkerSession session = openShulkerBoxes.get(player.getUniqueId());
+        if (session != null) {
+            commitOpenShulker(player, session.inventory);
        }
    }

    private boolean commitOpenShulker(Player player, Inventory inventory) {
-        if (!(inventory.getHolder(false) instanceof ShulkerBoxHolder)) {
+        OpenShulkerSession session = openShulkerBoxes.get(player.getUniqueId());
+        if (session == null || session.inventory != inventory) {
            return false;
        }

-        OpenShulkerSession session = openShulkerBoxes.remove(player.getUniqueId());
-        if (session == null) {
+        openShulkerBoxes.remove(player.getUniqueId(), session);
+        boolean saved = writeSessionToPlayer(player, session, true);
+        if (!saved) {
+            handleLostSource(player, session, "关闭期间未找到唯一的源物品");
+        }
+        return saved;
+    }
+
+    private boolean writeSessionToPlayer(Player player, OpenShulkerSession session, boolean clearToken) {
+        List<LocatedSource> sources = findSources(player, session);
+        if (sources.size() != 1) {
+            clearSessionTokens(sources);
            return false;
        }

-        ItemStack updatedShulker = session.sourceItem.clone();
-        writeInventoryBack(updatedShulker, inventory.getContents());
-        restoreItemToPlayer(player, session, updatedShulker);
+        LocatedSource source = sources.getFirst();
+        if (source.item().getAmount() != 1) {
+            clearSessionTokens(sources);
+            return false;
+        }
+
+        ItemStack updatedItem = source.item().clone();
+        if (!writeInventoryBack(updatedItem, session.inventory.getContents(), clearToken)) {
+            clearSessionTokens(sources);
+            return false;
+        }
+
+        source.save().accept(updatedItem);
        return true;
    }

-    private void openShulkerBox(Player player, EquipmentSlot hand, ItemStack sourceItem, ShulkerBox shulkerBox) {
-        removeItemFromHand(player, hand);
+    private boolean writeSessionToDrops(List<ItemStack> drops, OpenShulkerSession session) {
+        List<Integer> matchingIndexes = new ArrayList<>();
+        for (int index = 0; index < drops.size(); index++) {
+            if (hasSessionToken(drops.get(index), session.token)) {
+                matchingIndexes.add(index);
+            }
+        }

-        ShulkerBoxHolder holder = new ShulkerBoxHolder(resolveTitle(sourceItem));
-        holder.getInventory().setContents(cloneContents(shulkerBox.getInventory().getContents()));
+        if (matchingIndexes.size() != 1) {
+            clearTokensFromDrops(drops, matchingIndexes);
+            return false;
+        }

-        int preferredSlot = hand == EquipmentSlot.HAND ? player.getInventory().getHeldItemSlot() : -1;
-        openShulkerBoxes.put(player.getUniqueId(), new OpenShulkerSession(sourceItem, hand, preferredSlot));
-        player.openInventory(holder.getInventory());
-        player.playSound(player.getLocation(), Sound.BLOCK_SHULKER_BOX_OPEN, 0.8F, 1.0F);
+        int sourceIndex = matchingIndexes.getFirst();
+        ItemStack sourceItem = drops.get(sourceIndex);
+        if (sourceItem.getAmount() != 1) {
+            clearTokensFromDrops(drops, matchingIndexes);
+            return false;
+        }
+
+        ItemStack updatedItem = sourceItem.clone();
+        if (!writeInventoryBack(updatedItem, session.inventory.getContents(), true)) {
+            clearTokensFromDrops(drops, matchingIndexes);
+            return false;
+        }
+
+        drops.set(sourceIndex, updatedItem);
+        return true;
    }

-    private void writeInventoryBack(ItemStack shulkerItem, ItemStack[] contents) {
+    private boolean writeInventoryBack(ItemStack shulkerItem, ItemStack[] contents, boolean clearToken) {
+        if (containsShulkerBox(contents)) {
+            plugin.getLogger().warning("保存潜影盒内容失败: 虚拟容器中检测到嵌套潜影盒。");
+            return false;
+        }
+
        if (!(shulkerItem.getItemMeta() instanceof BlockStateMeta blockStateMeta)) {
            plugin.getLogger().warning("保存潜影盒内容失败: 缺少 BlockStateMeta。");
-            return;
+            return false;
        }

        if (!(blockStateMeta.getBlockState() instanceof ShulkerBox shulkerBox)) {
            plugin.getLogger().warning("保存潜影盒内容失败: 方块状态不是 ShulkerBox。");
-            return;
+            return false;
        }

-        shulkerBox.getInventory().setContents(cloneContents(contents));
-        blockStateMeta.setBlockState(shulkerBox);
-        shulkerItem.setItemMeta(blockStateMeta);
+        try {
+            shulkerBox.getInventory().setContents(cloneContents(contents));
+            blockStateMeta.setBlockState(shulkerBox);
+            if (clearToken) {
+                blockStateMeta.getPersistentDataContainer().remove(sessionKey);
+            }
+            shulkerItem.setItemMeta(blockStateMeta);
+            return true;
+        } catch (RuntimeException exception) {
+            plugin.getLogger().warning("保存潜影盒内容失败: " + exception.getMessage());
+            return false;
+        }
    }

-    private void restoreItemToPlayer(Player player, OpenShulkerSession session, ItemStack shulkerItem) {
+    private List<LocatedSource> findSources(Player player, OpenShulkerSession session) {
+        List<LocatedSource> sources = new ArrayList<>();
        PlayerInventory inventory = player.getInventory();

-        if (session.sourceHand == EquipmentSlot.OFF_HAND) {
-            if (isEmpty(inventory.getItemInOffHand())) {
-                inventory.setItemInOffHand(shulkerItem);
-                return;
-            }
-        } else if (session.preferredSlot >= 0 && isEmpty(inventory.getItem(session.preferredSlot))) {
-            inventory.setItem(session.preferredSlot, shulkerItem);
-            return;
+        if (session.preferredSlot >= 0 && session.preferredSlot < inventory.getSize()) {
+            addSourceIfMatching(
+                sources,
+                inventory.getItem(session.preferredSlot),
+                item -> inventory.setItem(session.preferredSlot, item),
+                session.token
+            );
        }

-        Map<Integer, ItemStack> leftovers = inventory.addItem(shulkerItem);
-        for (ItemStack leftover : leftovers.values()) {
-            player.getWorld().dropItemNaturally(player.getLocation(), leftover);
+        for (int slot = 0; slot < inventory.getSize(); slot++) {
+            if (slot == session.preferredSlot) {
+                continue;
+            }
+            int inventorySlot = slot;
+            addSourceIfMatching(
+                sources,
+                inventory.getItem(inventorySlot),
+                item -> inventory.setItem(inventorySlot, item),
+                session.token
+            );
        }
+
+        addSourceIfMatching(sources, player.getItemOnCursor(), player::setItemOnCursor, session.token);
+        return sources;
+    }
+
+    private void addSourceIfMatching(
+        List<LocatedSource> sources,
+        ItemStack item,
+        Consumer<ItemStack> save,
+        String token
+    ) {
+        if (hasSessionToken(item, token)) {
+            sources.add(new LocatedSource(item, save));
+        }
+    }
+
+    private void clearSessionTokens(List<LocatedSource> sources) {
+        for (LocatedSource source : sources) {
+            ItemStack cleanedItem = source.item().clone();
+            clearSessionToken(cleanedItem);
+            source.save().accept(cleanedItem);
+        }
+    }
+
+    private void clearTokensFromDrops(List<ItemStack> drops, List<Integer> indexes) {
+        for (int index : indexes) {
+            ItemStack cleanedItem = drops.get(index).clone();
+            clearSessionToken(cleanedItem);
+            drops.set(index, cleanedItem);
+        }
+    }
+
+    private void clearTokenFromPlayer(Player player, String token) {
+        PlayerInventory inventory = player.getInventory();
+        for (int slot = 0; slot < inventory.getSize(); slot++) {
+            ItemStack item = inventory.getItem(slot);
+            if (!hasSessionToken(item, token)) {
+                continue;
+            }
+            ItemStack cleanedItem = item.clone();
+            clearSessionToken(cleanedItem);
+            inventory.setItem(slot, cleanedItem);
+        }
+
+        ItemStack cursor = player.getItemOnCursor();
+        if (hasSessionToken(cursor, token)) {
+            ItemStack cleanedCursor = cursor.clone();
+            clearSessionToken(cleanedCursor);
+            player.setItemOnCursor(cleanedCursor);
+        }
+    }
+
+    private void clearStaleSessionTokens(Player player) {
+        PlayerInventory inventory = player.getInventory();
+        for (int slot = 0; slot < inventory.getSize(); slot++) {
+            ItemStack item = inventory.getItem(slot);
+            if (!hasAnySessionToken(item)) {
+                continue;
+            }
+            ItemStack cleanedItem = item.clone();
+            clearSessionToken(cleanedItem);
+            inventory.setItem(slot, cleanedItem);
+        }
+
+        ItemStack cursor = player.getItemOnCursor();
+        if (hasAnySessionToken(cursor)) {
+            ItemStack cleanedCursor = cursor.clone();
+            clearSessionToken(cleanedCursor);
+            player.setItemOnCursor(cleanedCursor);
+        }
+    }
+
+    private void handleLostSource(Player player, OpenShulkerSession session, String reason) {
+        clearTokenFromPlayer(player, session.token);
+        plugin.getLogger().warning("潜影盒会话已终止: " + player.getName() + " (" + player.getUniqueId() + ")，" + reason + "。");
+        if (player.isOnline()) {
+            player.sendMessage(EssentialsC.getLangManager().getPrefixedString("messages.shulkerbox-session-invalid"));
+        }
+    }
+
+    private void setSessionToken(ItemStack item, String token) {
+        ItemMeta itemMeta = item.getItemMeta();
+        itemMeta.getPersistentDataContainer().set(sessionKey, PersistentDataType.STRING, token);
+        item.setItemMeta(itemMeta);
+    }
+
+    private void clearSessionToken(ItemStack item) {
+        ItemMeta itemMeta = item.getItemMeta();
+        if (itemMeta == null) {
+            return;
+        }
+        itemMeta.getPersistentDataContainer().remove(sessionKey);
+        item.setItemMeta(itemMeta);
+    }
+
+    private boolean hasSessionToken(ItemStack item, String token) {
+        if (!isShulkerBox(item)) {
+            return false;
+        }
+        ItemMeta itemMeta = item.getItemMeta();
+        if (itemMeta == null) {
+            return false;
+        }
+        String storedToken = itemMeta.getPersistentDataContainer().get(sessionKey, PersistentDataType.STRING);
+        return token.equals(storedToken);
+    }
+
+    private boolean hasAnySessionToken(ItemStack item) {
+        if (!isShulkerBox(item)) {
+            return false;
+        }
+        ItemMeta itemMeta = item.getItemMeta();
+        return itemMeta != null && itemMeta.getPersistentDataContainer().has(sessionKey, PersistentDataType.STRING);
    }

    private ItemStack[] cloneContents(ItemStack[] contents) {
        ItemStack[] copied = new ItemStack[SHULKER_SIZE];
-        for (int i = 0; i < SHULKER_SIZE && i < contents.length; i++) {
-            copied[i] = contents[i] == null ? null : contents[i].clone();
+        for (int index = 0; index < SHULKER_SIZE && index < contents.length; index++) {
+            copied[index] = contents[index] == null ? null : contents[index].clone();
        }
        return copied;
    }

+    private boolean containsShulkerBox(ItemStack[] contents) {
+        for (ItemStack item : contents) {
+            if (isShulkerBox(item)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
    private ItemStack getItemFromHand(Player player, EquipmentSlot hand) {
        return hand == EquipmentSlot.OFF_HAND
            ? player.getInventory().getItemInOffHand()
            : player.getInventory().getItemInMainHand();
    }

-    private void removeItemFromHand(Player player, EquipmentSlot hand) {
+    private void setItemInHand(Player player, EquipmentSlot hand, ItemStack item) {
        if (hand == EquipmentSlot.OFF_HAND) {
-            player.getInventory().setItemInOffHand(null);
+            player.getInventory().setItemInOffHand(item);
        } else {
-            player.getInventory().setItem(player.getInventory().getHeldItemSlot(), null);
+            player.getInventory().setItem(player.getInventory().getHeldItemSlot(), item);
        }
    }

@@ -336,7 +699,6 @@ public class ShulkerBoxListener implements Listener {
            if (displayName != null) {
                return displayName;
            }
-            return LegacyComponentSerializer.legacySection().deserialize(itemMeta.getDisplayName());
        }

        return Component.translatable(shulkerBox.getType().getItemTranslationKey());
@@ -346,12 +708,12 @@ public class ShulkerBoxListener implements Listener {
        player.sendMessage(EssentialsC.getLangManager().getPrefixedString("messages.shulkerbox-nested"));
    }

-    private boolean isShulkerBox(ItemStack item) {
-        return item != null && !item.getType().isAir() && SHULKER_BOX_MATERIALS.contains(item.getType());
+    private void sendOpenFailedMessage(Player player) {
+        player.sendMessage(EssentialsC.getLangManager().getPrefixedString("messages.shulkerbox-open-failed"));
    }

-    private boolean isEmpty(ItemStack item) {
-        return item == null || item.getType().isAir();
+    private boolean isShulkerBox(ItemStack item) {
+        return item != null && !item.getType().isAir() && SHULKER_BOX_MATERIALS.contains(item.getType());
    }

    private boolean isSameShulkerItem(ItemStack currentItem, ItemStack sourceSnapshot) {
@@ -0,0 +1,17 @@
+package cn.infstar.essentialsC.listeners;
+
+import java.util.Set;
+
+final class ShulkerBoxSessionPolicy {
+
+    private ShulkerBoxSessionPolicy() {
+    }
+
+    static boolean isTopSlot(int rawSlot, int topInventorySize) {
+        return rawSlot >= 0 && rawSlot < topInventorySize;
+    }
+
+    static boolean touchesTopInventory(Set<Integer> rawSlots, int topInventorySize) {
+        return rawSlots.stream().anyMatch(rawSlot -> isTopSlot(rawSlot, topInventorySize));
+    }
+}
@@ -7,23 +7,82 @@ import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.scheduler.BukkitTask;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;

 public final class VanishListener implements Listener {

    private final EssentialsC plugin;
+    private final BukkitTask permissionTask;
+    private final Map<UUID, Boolean> observerSeePermissions = new HashMap<>();

    public VanishListener(EssentialsC plugin) {
        this.plugin = plugin;
+        VanishCommand.loadState(plugin);
+        this.permissionTask = plugin.getServer().getScheduler().runTaskTimer(plugin, this::checkPermissions, 40L, 40L);
    }

    @EventHandler
    public void onPlayerJoin(PlayerJoinEvent event) {
+        Player player = event.getPlayer();
+        observerSeePermissions.put(player.getUniqueId(), player.hasPermission(VanishCommand.SEE_PERMISSION));
+        if (VanishCommand.isVanished(player) && !player.hasPermission("essentialsc.command.vanish")) {
+            VanishCommand.restoreVisibility(plugin, player, false);
+        }
+        if (VanishCommand.isVanished(player)) {
+            event.joinMessage(null);
+            plugin.getServer().getScheduler().runTask(plugin, () -> VanishCommand.applyHiddenState(plugin, player));
+        }
        VanishCommand.hideVanishedPlayersFrom(plugin, event.getPlayer());
    }

    @EventHandler
    public void onPlayerQuit(PlayerQuitEvent event) {
+        observerSeePermissions.remove(event.getPlayer().getUniqueId());
        Player player = event.getPlayer();
-        VanishCommand.removeVanished(player);
+        if (VanishCommand.isVanished(player)) {
+            event.quitMessage(null);
+        }
+    }
+
+    public void shutdown() {
+        permissionTask.cancel();
+    }
+
+    private void checkPermissions() {
+        Set<UUID> onlinePlayers = new HashSet<>();
+        for (Player player : plugin.getServer().getOnlinePlayers()) {
+            onlinePlayers.add(player.getUniqueId());
+            if (VanishCommand.isVanished(player) && !player.hasPermission("essentialsc.command.vanish")) {
+                VanishCommand.restoreVisibility(plugin, player, true);
+            }
+        }
+        observerSeePermissions.keySet().removeIf(uuid -> !onlinePlayers.contains(uuid));
+
+        for (Player observer : plugin.getServer().getOnlinePlayers()) {
+            boolean canSeeVanished = observer.hasPermission(VanishCommand.SEE_PERMISSION);
+            Boolean previous = observerSeePermissions.put(observer.getUniqueId(), canSeeVanished);
+            if (previous == null || previous != canSeeVanished) {
+                refreshObserverVisibility(observer, canSeeVanished);
+            }
+        }
+    }
+
+    private void refreshObserverVisibility(Player observer, boolean canSeeVanished) {
+        for (Player player : plugin.getServer().getOnlinePlayers()) {
+            if (observer.equals(player) || !VanishCommand.isVanished(player)) {
+                continue;
+            }
+            if (canSeeVanished) {
+                observer.showPlayer(plugin, player);
+            } else {
+                observer.hidePlayer(plugin, player);
+            }
+        }
    }
 }
@@ -1,96 +0,0 @@
-package cn.infstar.essentialsC.maintenance;
-
-import cn.infstar.essentialsC.EssentialsC;
-import cn.infstar.essentialsC.ModuleManager;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerLoginEvent;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
-import org.bukkit.event.server.ServerListPingEvent;
-
-import java.net.InetAddress;
-import java.util.Map;
-
-public final class MaintenanceListener implements Listener {
-
-    private final EssentialsC plugin;
-
-    public MaintenanceListener(EssentialsC plugin) {
-        this.plugin = plugin;
-    }
-
-    @EventHandler
-    public void onServerListPing(ServerListPingEvent event) {
-        MaintenanceManager maintenanceManager = plugin.getMaintenanceManager();
-        if (!plugin.getModuleManager().isEnabled(ModuleManager.MAINTENANCE)
-            || maintenanceManager == null
-            || !maintenanceManager.isEnabled()
-            || !maintenanceManager.isMotdEnabled()) {
-            return;
-        }
-
-        event.setMotd(maintenanceManager.getMotd());
-    }
-
-    @EventHandler
-    public void onPlayerLogin(PlayerLoginEvent event) {
-        MaintenanceManager maintenanceManager = plugin.getMaintenanceManager();
-        if (!plugin.getModuleManager().isEnabled(ModuleManager.MAINTENANCE)
-            || maintenanceManager == null
-            || !maintenanceManager.isEnabled()) {
-            return;
-        }
-
-        if (maintenanceManager.canJoin(event.getPlayer())) {
-            return;
-        }
-
-        event.disallow(PlayerLoginEvent.Result.KICK_OTHER, maintenanceManager.getKickMessage());
-        notifyBlockedLogin(event, maintenanceManager);
-    }
-
-    @EventHandler
-    public void onPlayerJoin(PlayerJoinEvent event) {
-        MaintenanceManager maintenanceManager = plugin.getMaintenanceManager();
-        if (!plugin.getModuleManager().isEnabled(ModuleManager.MAINTENANCE) || maintenanceManager == null) {
-            return;
-        }
-
-        maintenanceManager.addBossBarPlayer(event.getPlayer());
-    }
-
-    @EventHandler
-    public void onPlayerQuit(PlayerQuitEvent event) {
-        MaintenanceManager maintenanceManager = plugin.getMaintenanceManager();
-        if (maintenanceManager != null) {
-            maintenanceManager.removeBossBarPlayer(event.getPlayer());
-        }
-    }
-
-    private void notifyBlockedLogin(PlayerLoginEvent event, MaintenanceManager maintenanceManager) {
-        if (!maintenanceManager.isNotifyEnabled()) {
-            return;
-        }
-
-        String address = "";
-        InetAddress inetAddress = event.getAddress();
-        if (inetAddress != null) {
-            address = inetAddress.getHostAddress();
-        }
-
-        String message = EssentialsC.getLangManager().getPrefixedString("maintenance.messages.login-blocked",
-            Map.of(
-                "player", event.getPlayer().getName(),
-                "uuid", event.getPlayer().getUniqueId().toString(),
-                "address", address
-            ));
-
-        for (Player player : plugin.getServer().getOnlinePlayers()) {
-            if (player.hasPermission(maintenanceManager.getNotifyPermission())) {
-                player.sendMessage(message);
-            }
-        }
-    }
-}
@@ -1,321 +0,0 @@
-package cn.infstar.essentialsC.maintenance;
-
-import cn.infstar.essentialsC.EssentialsC;
-import org.bukkit.ChatColor;
-import org.bukkit.boss.BarColor;
-import org.bukkit.boss.BarStyle;
-import org.bukkit.boss.BossBar;
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.bukkit.entity.Player;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Locale;
-import java.util.Set;
-import java.util.UUID;
-
-public final class MaintenanceManager {
-
-    private static final int CURRENT_CONFIG_VERSION = 1;
-
-    private final EssentialsC plugin;
-    private final File configFile;
-    private FileConfiguration config;
-    private BossBar bossBar;
-
-    public MaintenanceManager(EssentialsC plugin) {
-        this.plugin = plugin;
-        this.configFile = new File(plugin.getDataFolder(), "maintenance.yml");
-        reload();
-    }
-
-    public void reload() {
-        if (!configFile.exists()) {
-            plugin.saveResource("maintenance.yml", false);
-        }
-
-        config = YamlConfiguration.loadConfiguration(configFile);
-        config.addDefault("config-version", CURRENT_CONFIG_VERSION);
-        config.addDefault("enabled", false);
-        config.addDefault("bypass-permission", "essentialsc.maintenance.bypass");
-        config.addDefault("notify.enabled", true);
-        config.addDefault("notify.permission", "essentialsc.maintenance.notify");
-        config.addDefault("whitelist.uuids", List.of());
-        config.addDefault("whitelist.names", List.of());
-        config.addDefault("motd.enabled", true);
-        config.addDefault("motd.lines", List.of("&c服务器维护中", "&7请稍后再试"));
-        config.addDefault("kick-message", List.of("&c服务器正在维护", "&7请稍后再进入"));
-        config.addDefault("bossbar.enabled", true);
-        config.addDefault("bossbar.title", "&c服务器正在维护");
-        config.addDefault("bossbar.color", "RED");
-        config.addDefault("bossbar.style", "SOLID");
-        config.addDefault("bossbar.progress", 1.0D);
-        config.options().copyDefaults(true);
-        save();
-        refreshBossBar();
-    }
-
-    public boolean isEnabled() {
-        return config.getBoolean("enabled", false);
-    }
-
-    public void setEnabled(boolean enabled) {
-        config.set("enabled", enabled);
-        save();
-        refreshBossBar();
-    }
-
-    public String getBypassPermission() {
-        return config.getString("bypass-permission", "essentialsc.maintenance.bypass");
-    }
-
-    public boolean isNotifyEnabled() {
-        return config.getBoolean("notify.enabled", true);
-    }
-
-    public String getNotifyPermission() {
-        return config.getString("notify.permission", "essentialsc.maintenance.notify");
-    }
-
-    public boolean canJoin(Player player) {
-        return player != null && (player.hasPermission(getBypassPermission()) || isWhitelisted(player));
-    }
-
-    public boolean isWhitelisted(Player player) {
-        if (player == null) {
-            return false;
-        }
-
-        return getWhitelistUuids().contains(player.getUniqueId().toString().toLowerCase(Locale.ROOT))
-            || getWhitelistNames().contains(normalizeName(player.getName()));
-    }
-
-    public boolean addWhitelistEntry(String input) {
-        String normalized = normalizeEntry(input);
-        if (normalized.isEmpty()) {
-            return false;
-        }
-
-        UUID uuid = parseUuid(normalized);
-        if (uuid != null) {
-            return addWhitelistUuid(uuid.toString());
-        }
-
-        return addWhitelistName(input);
-    }
-
-    public boolean removeWhitelistEntry(String input) {
-        String normalized = normalizeEntry(input);
-        if (normalized.isEmpty()) {
-            return false;
-        }
-
-        UUID uuid = parseUuid(normalized);
-        if (uuid != null) {
-            return removeWhitelistUuid(uuid.toString());
-        }
-
-        return removeWhitelistName(input);
-    }
-
-    public List<String> getWhitelistEntries() {
-        List<String> entries = new ArrayList<>();
-        entries.addAll(getWhitelistNames());
-        entries.addAll(getWhitelistUuids());
-        return entries;
-    }
-
-    public int getWhitelistCount() {
-        return getWhitelistEntries().size();
-    }
-
-    public boolean isMotdEnabled() {
-        return config.getBoolean("motd.enabled", true);
-    }
-
-    public String getMotd() {
-        return colorizeLines(config.getStringList("motd.lines"));
-    }
-
-    public String getKickMessage() {
-        return colorizeLines(config.getStringList("kick-message"));
-    }
-
-    public void refreshBossBar() {
-        clearBossBar();
-        if (!isEnabled() || !isBossBarEnabled()) {
-            return;
-        }
-
-        bossBar = plugin.getServer().createBossBar(
-            colorize(config.getString("bossbar.title", "&c服务器正在维护")),
-            readBossBarColor(),
-            readBossBarStyle()
-        );
-        bossBar.setProgress(readBossBarProgress());
-        bossBar.setVisible(true);
-
-        for (Player player : plugin.getServer().getOnlinePlayers()) {
-            addBossBarPlayer(player);
-        }
-    }
-
-    public void addBossBarPlayer(Player player) {
-        if (bossBar == null || player == null || !player.isOnline()) {
-            return;
-        }
-        if (canJoin(player)) {
-            bossBar.removePlayer(player);
-            return;
-        }
-        bossBar.addPlayer(player);
-    }
-
-    public void removeBossBarPlayer(Player player) {
-        if (bossBar != null && player != null) {
-            bossBar.removePlayer(player);
-        }
-    }
-
-    public void shutdown() {
-        clearBossBar();
-    }
-
-    private void clearBossBar() {
-        if (bossBar == null) {
-            return;
-        }
-
-        bossBar.removeAll();
-        bossBar = null;
-    }
-
-    private boolean isBossBarEnabled() {
-        return config.getBoolean("bossbar.enabled", true);
-    }
-
-    private BarColor readBossBarColor() {
-        try {
-            return BarColor.valueOf(config.getString("bossbar.color", "RED").toUpperCase(Locale.ROOT));
-        } catch (IllegalArgumentException ignored) {
-            return BarColor.RED;
-        }
-    }
-
-    private BarStyle readBossBarStyle() {
-        try {
-            return BarStyle.valueOf(config.getString("bossbar.style", "SOLID").toUpperCase(Locale.ROOT));
-        } catch (IllegalArgumentException ignored) {
-            return BarStyle.SOLID;
-        }
-    }
-
-    private double readBossBarProgress() {
-        double progress = config.getDouble("bossbar.progress", 1.0D);
-        if (!Double.isFinite(progress)) {
-            return 1.0D;
-        }
-        return Math.max(0.0D, Math.min(1.0D, progress));
-    }
-
-    private boolean addWhitelistUuid(String uuid) {
-        return updateWhitelist("whitelist.uuids", uuid.toLowerCase(Locale.ROOT), true);
-    }
-
-    private boolean addWhitelistName(String name) {
-        return updateWhitelist("whitelist.names", normalizeName(name), true);
-    }
-
-    private boolean removeWhitelistUuid(String uuid) {
-        return updateWhitelist("whitelist.uuids", uuid.toLowerCase(Locale.ROOT), false);
-    }
-
-    private boolean removeWhitelistName(String name) {
-        return updateWhitelist("whitelist.names", normalizeName(name), false);
-    }
-
-    private boolean updateWhitelist(String path, String value, boolean add) {
-        if (value == null || value.isBlank()) {
-            return false;
-        }
-
-        Set<String> entries = path.endsWith(".names") ? getWhitelistNames() : getWhitelistUuids();
-        boolean changed;
-        if (add) {
-            changed = entries.add(value);
-        } else {
-            changed = entries.remove(value);
-        }
-
-        if (changed) {
-            config.set(path, new ArrayList<>(entries));
-            save();
-            refreshBossBar();
-        }
-        return changed;
-    }
-
-    private Set<String> getWhitelistUuids() {
-        Set<String> entries = new LinkedHashSet<>();
-        for (String value : config.getStringList("whitelist.uuids")) {
-            String normalized = normalizeEntry(value).toLowerCase(Locale.ROOT);
-            if (!normalized.isEmpty()) {
-                entries.add(normalized);
-            }
-        }
-        return entries;
-    }
-
-    private Set<String> getWhitelistNames() {
-        Set<String> entries = new LinkedHashSet<>();
-        for (String value : config.getStringList("whitelist.names")) {
-            String normalized = normalizeName(value);
-            if (!normalized.isEmpty()) {
-                entries.add(normalized);
-            }
-        }
-        return entries;
-    }
-
-    private UUID parseUuid(String input) {
-        try {
-            return UUID.fromString(input);
-        } catch (IllegalArgumentException ignored) {
-            return null;
-        }
-    }
-
-    private String normalizeEntry(String input) {
-        return input == null ? "" : input.trim();
-    }
-
-    private String normalizeName(String input) {
-        return normalizeEntry(input).toLowerCase(Locale.ROOT);
-    }
-
-    private String colorizeLines(List<String> lines) {
-        if (lines == null || lines.isEmpty()) {
-            return "";
-        }
-
-        return String.join("\n", lines.stream()
-            .map(this::colorize)
-            .toList());
-    }
-
-    private String colorize(String text) {
-        return ChatColor.translateAlternateColorCodes('&', text == null ? "" : text);
-    }
-
-    private void save() {
-        try {
-            config.save(configFile);
-        } catch (IOException e) {
-            plugin.getLogger().warning("保存 maintenance.yml 失败: " + e.getMessage());
-        }
-    }
-}
@@ -0,0 +1,209 @@
+package cn.infstar.essentialsC.player;
+
+import cn.infstar.essentialsC.EssentialsC;
+import org.bukkit.GameMode;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.persistence.PersistentDataType;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.scheduler.BukkitTask;
+
+public final class PlayerStateManager implements Listener {
+
+    public static final String FLY_PERMISSION = "essentialsc.command.fly";
+    public static final String NIGHT_VISION_PERMISSION = "essentialsc.command.nightvision";
+    public static final String GLOW_PERMISSION = "essentialsc.command.glow";
+
+    private final EssentialsC plugin;
+    private final NamespacedKey flyEnabledKey;
+    private final NamespacedKey flyPreviousAllowKey;
+    private final NamespacedKey flyPreviousFlyingKey;
+    private final NamespacedKey nightVisionEnabledKey;
+    private final NamespacedKey glowEnabledKey;
+    private final BukkitTask permissionTask;
+
+    public PlayerStateManager(EssentialsC plugin) {
+        this.plugin = plugin;
+        this.flyEnabledKey = new NamespacedKey(plugin, "fly_enabled");
+        this.flyPreviousAllowKey = new NamespacedKey(plugin, "fly_previous_allow");
+        this.flyPreviousFlyingKey = new NamespacedKey(plugin, "fly_previous_flying");
+        this.nightVisionEnabledKey = new NamespacedKey(plugin, "nightvision_enabled");
+        this.glowEnabledKey = new NamespacedKey(plugin, "glow_enabled");
+        this.permissionTask = plugin.getServer().getScheduler()
+            .runTaskTimer(plugin, this::reconcileOnlinePlayers, 40L, 40L);
+    }
+
+    public boolean isFlyEnabled(Player player) {
+        return isMarked(player, flyEnabledKey);
+    }
+
+    public void enableFly(Player player) {
+        if (isFlyEnabled(player)) {
+            player.setAllowFlight(true);
+            player.setFlying(true);
+            return;
+        }
+
+        PersistentDataContainer data = player.getPersistentDataContainer();
+        setBoolean(data, flyPreviousAllowKey, player.getAllowFlight());
+        setBoolean(data, flyPreviousFlyingKey, player.isFlying());
+        setBoolean(data, flyEnabledKey, true);
+        player.setAllowFlight(true);
+        player.setFlying(true);
+    }
+
+    public void disableFly(Player player) {
+        PersistentDataContainer data = player.getPersistentDataContainer();
+        if (!isMarked(data, flyEnabledKey)) {
+            return;
+        }
+
+        boolean previousAllow = getBoolean(data, flyPreviousAllowKey);
+        boolean previousFlying = getBoolean(data, flyPreviousFlyingKey);
+        clearFlyMarkers(data);
+
+        boolean allowFlight = previousAllow || hasGameModeFlight(player);
+        player.setFlying(previousFlying && allowFlight);
+        player.setAllowFlight(allowFlight);
+    }
+
+    public boolean isNightVisionEnabled(Player player) {
+        return isMarked(player, nightVisionEnabledKey);
+    }
+
+    public void enableNightVision(Player player) {
+        if (!player.hasPotionEffect(PotionEffectType.NIGHT_VISION)) {
+            player.addPotionEffect(new PotionEffect(
+                PotionEffectType.NIGHT_VISION, Integer.MAX_VALUE, 0, false, false, false));
+            setBoolean(player.getPersistentDataContainer(), nightVisionEnabledKey, true);
+        }
+    }
+
+    public void disableNightVision(Player player) {
+        if (!isNightVisionEnabled(player)) {
+            return;
+        }
+        player.removePotionEffect(PotionEffectType.NIGHT_VISION);
+        player.getPersistentDataContainer().remove(nightVisionEnabledKey);
+    }
+
+    public boolean isGlowEnabled(Player player) {
+        return isMarked(player, glowEnabledKey);
+    }
+
+    public void enableGlow(Player player) {
+        if (!player.isGlowing()) {
+            player.setGlowing(true);
+            setBoolean(player.getPersistentDataContainer(), glowEnabledKey, true);
+        }
+    }
+
+    public void disableGlow(Player player) {
+        if (!isGlowEnabled(player)) {
+            return;
+        }
+        player.setGlowing(false);
+        player.getPersistentDataContainer().remove(glowEnabledKey);
+    }
+
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        plugin.getServer().getScheduler().runTask(plugin, () -> reconcilePlayer(event.getPlayer(), false));
+    }
+
+    public void shutdown() {
+        permissionTask.cancel();
+        for (Player player : plugin.getServer().getOnlinePlayers()) {
+            releaseOwnedStates(player, false);
+        }
+    }
+
+    private void reconcileOnlinePlayers() {
+        for (Player player : plugin.getServer().getOnlinePlayers()) {
+            reconcilePlayer(player, true);
+        }
+    }
+
+    private void reconcilePlayer(Player player, boolean notify) {
+        if (isFlyEnabled(player)) {
+            if (!player.hasPermission(FLY_PERMISSION)) {
+                disableFly(player);
+                notifyPermissionRemoval(player, "messages.fly-permission-removed", notify);
+            } else if (!player.getAllowFlight()) {
+                player.setAllowFlight(true);
+            }
+        }
+
+        if (isNightVisionEnabled(player)) {
+            if (!player.hasPermission(NIGHT_VISION_PERMISSION)) {
+                disableNightVision(player);
+                notifyPermissionRemoval(player, "messages.nightvision-permission-removed", notify);
+            } else if (!player.hasPotionEffect(PotionEffectType.NIGHT_VISION)) {
+                player.addPotionEffect(new PotionEffect(
+                    PotionEffectType.NIGHT_VISION, Integer.MAX_VALUE, 0, false, false, false));
+            }
+        }
+
+        if (isGlowEnabled(player)) {
+            if (!player.hasPermission(GLOW_PERMISSION)) {
+                disableGlow(player);
+                notifyPermissionRemoval(player, "messages.glow-permission-removed", notify);
+            } else if (!player.isGlowing()) {
+                player.setGlowing(true);
+            }
+        }
+    }
+
+    private void releaseOwnedStates(Player player, boolean notify) {
+        if (isFlyEnabled(player)) {
+            disableFly(player);
+            notifyPermissionRemoval(player, "messages.fly-permission-removed", notify);
+        }
+        if (isNightVisionEnabled(player)) {
+            disableNightVision(player);
+            notifyPermissionRemoval(player, "messages.nightvision-permission-removed", notify);
+        }
+        if (isGlowEnabled(player)) {
+            disableGlow(player);
+            notifyPermissionRemoval(player, "messages.glow-permission-removed", notify);
+        }
+    }
+
+    private void notifyPermissionRemoval(Player player, String path, boolean notify) {
+        if (notify) {
+            player.sendMessage(EssentialsC.getLangManager().getPrefixedString(path));
+        }
+    }
+
+    private boolean isMarked(Player player, NamespacedKey key) {
+        return isMarked(player.getPersistentDataContainer(), key);
+    }
+
+    private boolean isMarked(PersistentDataContainer data, NamespacedKey key) {
+        Byte value = data.get(key, PersistentDataType.BYTE);
+        return value != null && value == (byte) 1;
+    }
+
+    private boolean getBoolean(PersistentDataContainer data, NamespacedKey key) {
+        return isMarked(data, key);
+    }
+
+    private void setBoolean(PersistentDataContainer data, NamespacedKey key, boolean value) {
+        data.set(key, PersistentDataType.BYTE, value ? (byte) 1 : (byte) 0);
+    }
+
+    private void clearFlyMarkers(PersistentDataContainer data) {
+        data.remove(flyEnabledKey);
+        data.remove(flyPreviousAllowKey);
+        data.remove(flyPreviousFlyingKey);
+    }
+
+    private boolean hasGameModeFlight(Player player) {
+        return player.getGameMode() == GameMode.CREATIVE || player.getGameMode() == GameMode.SPECTATOR;
+    }
+}
@@ -18,20 +18,26 @@ public final class MineSkinGateway implements SkinBridgeGateway {
    private static final String TEXTURES_PROPERTY = "textures";
    private static final String QUEUE_PATH = "/v2/queue";
    private static final long POLL_INTERVAL_MILLIS = 1000L;
+    private static final int MAX_RATE_LIMIT_RETRIES = 3;

    private final HttpClient httpClient;
    private final URI queueUri;
    private final String apiKey;
    private final String visibility;
    private final int timeoutSeconds;
+    private final long minimumSubmitIntervalMillis;
    private final String userAgent;
+    private final Object submissionLock = new Object();
+    private long lastSubmissionMillis;

-    public MineSkinGateway(HttpClient httpClient, String endpoint, String apiKey, String visibility, int timeoutSeconds, String userAgent) {
+    public MineSkinGateway(HttpClient httpClient, String endpoint, String apiKey, String visibility, int timeoutSeconds,
+                           long minimumSubmitIntervalMillis, String userAgent) {
        this.httpClient = httpClient;
        this.queueUri = URI.create(normalizeEndpoint(endpoint) + QUEUE_PATH);
        this.apiKey = apiKey;
        this.visibility = normalizeVisibility(visibility);
        this.timeoutSeconds = timeoutSeconds;
+        this.minimumSubmitIntervalMillis = minimumSubmitIntervalMillis;
        this.userAgent = userAgent;
    }

@@ -42,9 +48,15 @@ public final class MineSkinGateway implements SkinBridgeGateway {
        requestBody.addProperty("variant", model == SkinModel.SLIM ? "slim" : "classic");
        requestBody.addProperty("visibility", visibility);

-        HttpResponse<String> response = send(HttpRequest.newBuilder(queueUri)
-            .POST(HttpRequest.BodyPublishers.ofString(requestBody.toString(), StandardCharsets.UTF_8))
-            .header("Content-Type", "application/json"));
+        HttpResponse<String> response;
+        synchronized (submissionLock) {
+            waitForSubmissionInterval();
+            try {
+                response = submitWithRateLimitRetry(requestBody.toString());
+            } finally {
+                lastSubmissionMillis = System.currentTimeMillis();
+            }
+        }
        JsonObject body = parseResponse(response);
        if (response.statusCode() == 200) {
            return parseGeneratedSkin(body);
@@ -71,6 +83,10 @@ public final class MineSkinGateway implements SkinBridgeGateway {
        URI jobUri = URI.create(queueUri + "/" + jobId);
        while (System.nanoTime() < deadline) {
            HttpResponse<String> response = send(HttpRequest.newBuilder(jobUri).GET());
+            if (response.statusCode() == 429) {
+                Thread.sleep(readRetryDelayMillis(response, 0));
+                continue;
+            }
            JsonObject body = parseResponse(response);
            if (response.statusCode() != 200) {
                throw apiError("查询 MineSkin 生成任务", response, body);
@@ -89,7 +105,43 @@ public final class MineSkinGateway implements SkinBridgeGateway {
            }
            Thread.sleep(POLL_INTERVAL_MILLIS);
        }
-        throw new IllegalStateException("MineSkin 生成任务超时，请增大 skin-bridge.yml 中的 mineskin.request-timeout-seconds。");
+        throw new IllegalStateException("MineSkin 生成任务超时，请增大 config.yml 中的 skin-bridge.mineskin.request-timeout-seconds。");
+    }
+
+    private void waitForSubmissionInterval() throws InterruptedException {
+        long waitMillis = minimumSubmitIntervalMillis - (System.currentTimeMillis() - lastSubmissionMillis);
+        if (waitMillis > 0L) {
+            Thread.sleep(waitMillis);
+        }
+    }
+
+    private HttpResponse<String> submitWithRateLimitRetry(String requestBody) throws Exception {
+        HttpResponse<String> response = null;
+        for (int attempt = 0; attempt <= MAX_RATE_LIMIT_RETRIES; attempt++) {
+            response = send(HttpRequest.newBuilder(queueUri)
+                .POST(HttpRequest.BodyPublishers.ofString(requestBody, StandardCharsets.UTF_8))
+                .header("Content-Type", "application/json"));
+            if (response.statusCode() != 429 || attempt == MAX_RATE_LIMIT_RETRIES) {
+                return response;
+            }
+            Thread.sleep(readRetryDelayMillis(response, attempt));
+        }
+        return response;
+    }
+
+    private long readRetryDelayMillis(HttpResponse<?> response, int attempt) {
+        long fallback = Math.min(30_000L, 1000L << Math.min(attempt, 5));
+        return response.headers().firstValue("Retry-After")
+            .map(String::trim)
+            .filter(value -> value.matches("\\d+"))
+            .map(value -> {
+                try {
+                    return Math.min(60_000L, Long.parseLong(value) * 1000L);
+                } catch (NumberFormatException ignored) {
+                    return fallback;
+                }
+            })
+            .orElse(fallback);
    }

    private HttpResponse<String> send(HttpRequest.Builder builder) throws Exception {
@@ -1,6 +1,7 @@
 package cn.infstar.essentialsC.skinbridge;

 import cn.infstar.essentialsC.EssentialsC;
+import com.destroystokyo.paper.profile.ProfileProperty;
 import com.google.gson.JsonArray;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
@@ -12,6 +13,9 @@ import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.scheduler.BukkitTask;

 import java.net.URI;
 import java.net.http.HttpClient;
@@ -25,83 +29,155 @@ import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
 import java.util.UUID;
+import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicLong;

 public final class SkinBridgeManager implements Listener {

+    private static final int WORKER_THREADS = 2;
+    private static final int MAX_PENDING_LOOKUPS = 100;
+
    private final EssentialsC plugin;
    private final HttpClient httpClient;
-    private final ExecutorService executor;
+    private final ThreadPoolExecutor executor;
+    private final SkinCacheStore cacheStore;
    private final ConcurrentMap<UUID, CachedLookup> cache = new ConcurrentHashMap<>();
+    private final ConcurrentMap<SkinCacheStore.Key, SkinCacheStore.Entry> generatedSkinCache = new ConcurrentHashMap<>();
    private final ConcurrentMap<UUID, Long> pendingLookups = new ConcurrentHashMap<>();
+    private final ConcurrentMap<UUID, BukkitRunnable> scheduledLookups = new ConcurrentHashMap<>();
+    private final ConcurrentMap<LookupKey, Future<?>> runningLookups = new ConcurrentHashMap<>();
+    private final ConcurrentMap<UUID, Long> forceRefreshCooldowns = new ConcurrentHashMap<>();
+    private final ConcurrentMap<UUID, String> loginSkinUrls = new ConcurrentHashMap<>();
+    private final ConcurrentMap<SkinCacheStore.Key, CompletableFuture<GeneratedSkin>> pendingGenerations = new ConcurrentHashMap<>();
    private final AtomicLong configurationGeneration = new AtomicLong();
+    private BukkitTask generatedCacheSaveTask;
+    private boolean generatedCacheDirty;
+    private volatile boolean shuttingDown;

    private volatile List<SkinProvider> providers = List.of();
    private volatile SkinBridgeGateway gateway;
-    private volatile boolean enabled;
    private volatile boolean debug;
    private volatile boolean sendPlayerMessage;
+    private volatile boolean logDetectionResults;
    private volatile int requestTimeoutSeconds;
    private volatile int cacheMinutes;
+    private volatile int maxGeneratedCacheEntries;
+    private volatile int forceRefreshCooldownSeconds;
+    private volatile boolean requireCurrentTextureMatch;
    private volatile long joinDelayTicks;
+    private volatile Set<String> excludedUuids = Set.of();
+    private volatile Set<String> excludedNames = Set.of();

    public SkinBridgeManager(EssentialsC plugin) {
        this.plugin = plugin;
+        this.cacheStore = new SkinCacheStore(plugin);
        this.httpClient = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(5))
            .followRedirects(HttpClient.Redirect.NEVER)
            .build();
-        this.executor = Executors.newFixedThreadPool(2, new SkinBridgeThreadFactory());
+        this.executor = new ThreadPoolExecutor(
+            WORKER_THREADS,
+            WORKER_THREADS,
+            0L,
+            TimeUnit.MILLISECONDS,
+            new ArrayBlockingQueue<>(MAX_PENDING_LOOKUPS),
+            new SkinBridgeThreadFactory(),
+            new ThreadPoolExecutor.AbortPolicy()
+        );
        reload();
+        loadGeneratedSkinCache();
    }

    public void reload() {
        configurationGeneration.incrementAndGet();
-        FileConfiguration config = plugin.getFeatureConfigManager().getSkinBridgeConfig();
-        addDefaults(config);
-        config.options().copyDefaults(true);
-        plugin.getFeatureConfigManager().saveSkinBridgeConfig();
+        cancelScheduledLookups();
+        cancelRunningLookups();
+        pendingLookups.clear();
+        pendingGenerations.clear();
+        FileConfiguration config = plugin.getConfig();

-        enabled = config.getBoolean("enabled", false);
        debug = plugin.getConfig().getBoolean("debug", false);
-        sendPlayerMessage = config.getBoolean("send-player-message", true);
-        requestTimeoutSeconds = clamp(config.getInt("profile-request-timeout-seconds", 5), 1, 30);
-        String mineSkinEndpoint = config.getString("mineskin.endpoint", "https://api.mineskin.org");
-        String mineSkinApiKey = config.getString("mineskin.api-key", "").trim();
-        String mineSkinVisibility = config.getString("mineskin.visibility", "unlisted");
-        int mineSkinTimeoutSeconds = clamp(config.getInt("mineskin.request-timeout-seconds", 30), 10, 180);
-        cacheMinutes = clamp(config.getInt("cache-minutes", 120), 5, 10080);
-        joinDelayTicks = clamp(config.getLong("join-delay-ticks", 20L), 0, 200);
+        sendPlayerMessage = config.getBoolean("skin-bridge.send-player-message", true);
+        logDetectionResults = config.getBoolean("skin-bridge.log-detection-results", true);
+        requestTimeoutSeconds = clamp(config.getInt("skin-bridge.profile-request-timeout-seconds", 5), 1, 30);
+        String mineSkinEndpoint = config.getString("skin-bridge.mineskin.endpoint", "https://api.mineskin.org");
+        String mineSkinApiKey = config.getString("skin-bridge.mineskin.api-key", "").trim();
+        String mineSkinVisibility = config.getString("skin-bridge.mineskin.visibility", "unlisted");
+        int mineSkinTimeoutSeconds = clamp(config.getInt("skin-bridge.mineskin.request-timeout-seconds", 30), 10, 180);
+        long minimumSubmitIntervalMillis = clamp(
+            config.getLong("skin-bridge.mineskin.minimum-submit-interval-millis", 1000L), 0L, 10000L);
+        cacheMinutes = clamp(config.getInt("skin-bridge.cache-minutes", 120), 5, 10080);
+        maxGeneratedCacheEntries = clamp(config.getInt("skin-bridge.max-generated-cache-entries", 500), 10, 10_000);
+        forceRefreshCooldownSeconds = clamp(config.getInt("skin-bridge.force-refresh-cooldown-seconds", 30), 0, 3600);
+        requireCurrentTextureMatch = config.getBoolean("skin-bridge.require-current-texture-match", true);
+        joinDelayTicks = clamp(config.getLong("skin-bridge.join-delay-ticks", 20L), 0, 200);
+        excludedUuids = loadNormalizedValues(config, "skin-bridge.exclusions.uuids");
+        excludedNames = loadNormalizedValues(config, "skin-bridge.exclusions.names");
        providers = loadProviders(config);
        cache.clear();
-        gateway = loadGateway(mineSkinEndpoint, mineSkinApiKey, mineSkinVisibility, mineSkinTimeoutSeconds);
+        gateway = loadGateway(mineSkinEndpoint, mineSkinApiKey, mineSkinVisibility,
+            mineSkinTimeoutSeconds, minimumSubmitIntervalMillis);

-        if (enabled && gateway == null) {
+        if (gateway == null) {
            plugin.getLogger().warning("SkinBridge 已启用，但未配置有效的 MineSkin API Key，皮肤同步不会执行。");
        }
    }

    public void shutdown() {
+        shuttingDown = true;
        configurationGeneration.incrementAndGet();
-        cache.clear();
-        pendingLookups.clear();
+        cancelScheduledLookups();
+        cancelRunningLookups();
        executor.shutdownNow();
+        cancelGeneratedCacheSave();
+        saveGeneratedSkinCache();
+        cache.clear();
+        generatedSkinCache.clear();
+        pendingLookups.clear();
+        pendingGenerations.clear();
+        forceRefreshCooldowns.clear();
+        loginSkinUrls.clear();
    }

    @EventHandler
    public void onPlayerJoin(PlayerJoinEvent event) {
+        UUID playerId = event.getPlayer().getUniqueId();
+        getCurrentSkinUrl(event.getPlayer()).ifPresentOrElse(
+            skinUrl -> loginSkinUrls.put(playerId, skinUrl),
+            () -> loginSkinUrls.remove(playerId)
+        );
        queueSync(event.getPlayer(), false);
    }

+    @EventHandler
+    public void onPlayerQuit(PlayerQuitEvent event) {
+        UUID playerId = event.getPlayer().getUniqueId();
+        loginSkinUrls.remove(playerId);
+        pendingLookups.remove(playerId);
+        cancelScheduledLookup(playerId);
+        cancelRunningLookup(playerId);
+    }
+
    public SyncResult queueSync(Player player, boolean force) {
-        if (!enabled) {
-            return SyncResult.FEATURE_DISABLED;
+        UUID playerId = player.getUniqueId();
+        if (isExcluded(player)) {
+            cache.put(playerId, cached(null, null, State.EXCLUDED));
+            sendPlayerNotification(playerId, "skin-bridge.notifications.excluded", Map.of());
+            if (logDetectionResults) {
+                plugin.getLogger().info("SkinBridge 已根据排除名单跳过玩家: " + player.getName());
+            }
+            return SyncResult.EXCLUDED;
        }
        if (gateway == null) {
            return SyncResult.DEPENDENCY_MISSING;
@@ -110,8 +186,12 @@ public final class SkinBridgeManager implements Listener {
            return SyncResult.NO_PROVIDERS;
        }

-        UUID playerId = player.getUniqueId();
        if (force) {
+            long now = System.currentTimeMillis();
+            long expiresAt = forceRefreshCooldowns.getOrDefault(playerId, 0L);
+            if (expiresAt > now) {
+                return SyncResult.REFRESH_COOLDOWN;
+            }
            cache.remove(playerId);
        }

@@ -124,12 +204,35 @@ public final class SkinBridgeManager implements Listener {
        }

        long lookupGeneration = configurationGeneration.get();
+        if (!pendingLookups.containsKey(playerId) && pendingLookups.size() >= MAX_PENDING_LOOKUPS) {
+            plugin.getLogger().warning("SkinBridge 查询队列已满，已跳过玩家: " + player.getName());
+            sendPlayerNotification(playerId, "skin-bridge.notifications.queue-full", Map.of());
+            return SyncResult.QUEUE_FULL;
+        }
        if (!registerPendingLookup(playerId, lookupGeneration)) {
            return SyncResult.ALREADY_RUNNING;
        }
+        if (force && forceRefreshCooldownSeconds > 0) {
+            forceRefreshCooldowns.put(playerId,
+                System.currentTimeMillis() + forceRefreshCooldownSeconds * 1000L);
+        }

        String playerName = player.getName();
-        Bukkit.getScheduler().runTaskLater(plugin, () -> startLookup(playerId, playerName, lookupGeneration), joinDelayTicks);
+        String loginSkinUrl = loginSkinUrls.computeIfAbsent(playerId,
+            ignored -> getCurrentSkinUrl(player).orElse(""));
+        String currentSkinUrl = loginSkinUrl.isEmpty() ? null : loginSkinUrl;
+        BukkitRunnable scheduledLookup = new BukkitRunnable() {
+            @Override
+            public void run() {
+                scheduledLookups.remove(playerId, this);
+                startLookup(playerId, playerName, currentSkinUrl, lookupGeneration);
+            }
+        };
+        BukkitRunnable previousLookup = scheduledLookups.put(playerId, scheduledLookup);
+        if (previousLookup != null) {
+            previousLookup.cancel();
+        }
+        scheduledLookup.runTaskLater(plugin, joinDelayTicks);
        sendPlayerNotification(playerId, "skin-bridge.notifications.detecting", Map.of());
        return SyncResult.QUEUED;
    }
@@ -145,8 +248,9 @@ public final class SkinBridgeManager implements Listener {
        return new Status(State.UNKNOWN, null);
    }

-    public boolean isEnabled() {
-        return enabled;
+    public int getRemainingForceRefreshCooldownSeconds(Player player) {
+        long remaining = forceRefreshCooldowns.getOrDefault(player.getUniqueId(), 0L) - System.currentTimeMillis();
+        return remaining <= 0L ? 0 : (int) Math.ceil(remaining / 1000.0D);
    }

    public boolean isSkinGatewayAvailable() {
@@ -158,9 +262,6 @@ public final class SkinBridgeManager implements Listener {
    }

    public String getModuleDetail() {
-        if (!enabled) {
-            return "配置未启用";
-        }
        if (gateway == null) {
            return "缺少 MineSkin API Key 或配置无效";
        }
@@ -170,36 +271,55 @@ public final class SkinBridgeManager implements Listener {
        return providers.size() + " 个 Provider 已就绪";
    }

-    private void startLookup(UUID playerId, String playerName, long lookupGeneration) {
-        if (executor.isShutdown() || lookupGeneration != configurationGeneration.get()) {
+    private void startLookup(UUID playerId, String playerName, String currentSkinUrl, long lookupGeneration) {
+        Player player = Bukkit.getPlayer(playerId);
+        if (executor.isShutdown() || lookupGeneration != configurationGeneration.get()
+            || !isLookupActive(playerId, lookupGeneration) || player == null || !player.isOnline()) {
            pendingLookups.remove(playerId, lookupGeneration);
            return;
        }
-        executor.execute(() -> {
-            try {
-                CachedLookup resolved = resolve(playerId, playerName);
-                if (lookupGeneration != configurationGeneration.get()) {
-                    return;
-                }
-                cache.put(playerId, resolved);
-                if (resolved.skin() != null) {
-                    applySkin(playerId, resolved, lookupGeneration);
-                } else {
-                    sendPlayerNotification(playerId, "skin-bridge.notifications.not-external", Map.of());
-                    if (debug) {
-                        plugin.getLogger().info("SkinBridge 未识别到外置登录玩家: " + playerName);
+        LookupKey lookupKey = new LookupKey(playerId, lookupGeneration);
+        try {
+            Future<?> lookupTask = executor.submit(() -> {
+                try {
+                    CachedLookup resolved = resolve(playerId, playerName, currentSkinUrl);
+                    if (lookupGeneration != configurationGeneration.get() || !isLookupActive(playerId, lookupGeneration)) {
+                        return;
                    }
+                    cache.put(playerId, resolved);
+                    if (resolved.skin() != null) {
+                        applySkin(playerId, resolved, lookupGeneration);
+                    } else {
+                        sendPlayerNotification(playerId, "skin-bridge.notifications.not-external", Map.of());
+                        if (logDetectionResults) {
+                            plugin.getLogger().info("SkinBridge 未匹配到外置皮肤站，已保留玩家皮肤: " + playerName);
+                        }
+                    }
+                } catch (Exception exception) {
+                    if (!isLookupActive(playerId, lookupGeneration) || exception instanceof InterruptedException) {
+                        return;
+                    }
+                    plugin.getLogger().warning("SkinBridge 查询 " + playerName + " 的皮肤资料失败: " + exception.getMessage());
+                    sendPlayerNotification(playerId, "skin-bridge.notifications.failed", Map.of());
+                    if (debug) {
+                        plugin.getLogger().warning("SkinBridge 异常类型: " + exception.getClass().getName());
+                    }
+                } finally {
+                    pendingLookups.remove(playerId, lookupGeneration);
+                    runningLookups.remove(lookupKey);
                }
-            } catch (Exception exception) {
-                plugin.getLogger().warning("SkinBridge 查询 " + playerName + " 的皮肤资料失败: " + exception.getMessage());
-                sendPlayerNotification(playerId, "skin-bridge.notifications.failed", Map.of());
-                if (debug) {
-                    plugin.getLogger().warning("SkinBridge 异常类型: " + exception.getClass().getName());
-                }
-            } finally {
-                pendingLookups.remove(playerId, lookupGeneration);
+            });
+            runningLookups.put(lookupKey, lookupTask);
+            if (!isLookupActive(playerId, lookupGeneration)) {
+                runningLookups.remove(lookupKey, lookupTask);
+                lookupTask.cancel(true);
+                executor.purge();
            }
-        });
+        } catch (RejectedExecutionException exception) {
+            pendingLookups.remove(playerId, lookupGeneration);
+            plugin.getLogger().warning("SkinBridge 查询队列拒绝了玩家任务: " + playerName);
+            sendPlayerNotification(playerId, "skin-bridge.notifications.queue-full", Map.of());
+        }
    }

    private boolean registerPendingLookup(UUID playerId, long lookupGeneration) {
@@ -217,7 +337,7 @@ public final class SkinBridgeManager implements Listener {
        }
    }

-    private CachedLookup resolve(UUID playerId, String playerName) throws Exception {
+    private CachedLookup resolve(UUID playerId, String playerName, String currentSkinUrl) throws Exception {
        Exception lastFailure = null;
        for (SkinProvider provider : providers) {
            Optional<ProviderProfile> profile;
@@ -238,8 +358,19 @@ public final class SkinBridgeManager implements Listener {
            }

            ProviderProfile matchedProfile = profile.get();
-            GeneratedSkin generatedSkin = currentGateway.generateSkin(matchedProfile.skinUrl(), matchedProfile.model());
-            return cached(provider.id(), generatedSkin, State.EXTERNAL);
+            if (requireCurrentTextureMatch
+                && (currentSkinUrl == null || !currentSkinUrl.equals(matchedProfile.skinUrl()))) {
+                if (debug) {
+                    plugin.getLogger().info("SkinBridge 已忽略与当前登录纹理不一致的 Provider: " + provider.name());
+                }
+                continue;
+            }
+            if (logDetectionResults) {
+                plugin.getLogger().info("SkinBridge 已识别玩家 " + playerName + " 的皮肤来源: " + provider.name());
+            }
+            SkinCacheStore.Key cacheKey = new SkinCacheStore.Key(matchedProfile.skinUrl(), matchedProfile.model());
+            GeneratedSkin generatedSkin = getOrGenerateSkin(cacheKey, currentGateway);
+            return cached(provider.name(), generatedSkin, State.EXTERNAL);
        }

        if (lastFailure != null) {
@@ -253,7 +384,7 @@ public final class SkinBridgeManager implements Listener {
        HttpRequest request = HttpRequest.newBuilder(requestUri)
            .timeout(Duration.ofSeconds(requestTimeoutSeconds))
            .header("Accept", "application/json")
-            .header("User-Agent", "EssentialsC/" + plugin.getDescription().getVersion() + " SkinBridge")
+            .header("User-Agent", "EssentialsC/" + plugin.getPluginMeta().getVersion() + " SkinBridge")
            .GET()
            .build();
        HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
@@ -282,8 +413,8 @@ public final class SkinBridgeManager implements Listener {
        JsonObject skin = textureData.getAsJsonObject("textures").getAsJsonObject("SKIN");
        String skinUrl = requireString(skin, "url");
        URI skinUri = URI.create(skinUrl);
-        if (!"https".equalsIgnoreCase(skinUri.getScheme()) && !"http".equalsIgnoreCase(skinUri.getScheme())) {
-            throw new IllegalStateException(provider.id() + " 返回了不支持的皮肤 URL 协议。");
+        if (!"https".equalsIgnoreCase(skinUri.getScheme())) {
+            throw new IllegalStateException(provider.id() + " 返回了非 HTTPS 皮肤 URL。");
        }

        SkinModel model = SkinModel.CLASSIC;
@@ -321,8 +452,183 @@ public final class SkinBridgeManager implements Listener {
        throw new IllegalStateException("profile 不包含有效的皮肤 textures 属性。");
    }

+    private Optional<String> getCurrentSkinUrl(Player player) {
+        try {
+            for (ProfileProperty property : player.getPlayerProfile().getProperties()) {
+                if (!"textures".equals(property.getName())) {
+                    continue;
+                }
+                String decoded = new String(Base64.getDecoder().decode(property.getValue()), StandardCharsets.UTF_8);
+                JsonObject textureData = JsonParser.parseString(decoded).getAsJsonObject();
+                if (!textureData.has("textures") || !textureData.get("textures").isJsonObject()) {
+                    continue;
+                }
+                JsonObject textures = textureData.getAsJsonObject("textures");
+                if (!textures.has("SKIN") || !textures.get("SKIN").isJsonObject()) {
+                    continue;
+                }
+                String skinUrl = requireString(textures.getAsJsonObject("SKIN"), "url");
+                if ("https".equalsIgnoreCase(URI.create(skinUrl).getScheme())) {
+                    return Optional.of(skinUrl);
+                }
+            }
+        } catch (RuntimeException exception) {
+            if (debug) {
+                plugin.getLogger().warning("SkinBridge 无法解析玩家当前纹理: " + exception.getMessage());
+            }
+        }
+        return Optional.empty();
+    }
+
+    private void loadGeneratedSkinCache() {
+        generatedSkinCache.putAll(cacheStore.load());
+        trimGeneratedSkinCache();
+    }
+
+    private synchronized void saveGeneratedSkinCache() {
+        if (!generatedCacheDirty) {
+            return;
+        }
+        long now = System.currentTimeMillis();
+        generatedSkinCache.entrySet().removeIf(entry -> entry.getValue().expiresAtMillis() <= now);
+        trimGeneratedSkinCache();
+        if (cacheStore.save(generatedSkinCache)) {
+            generatedCacheDirty = false;
+        } else if (!shuttingDown) {
+            scheduleGeneratedCacheSave();
+        }
+    }
+
+    private GeneratedSkin getOrGenerateSkin(SkinCacheStore.Key cacheKey, SkinBridgeGateway currentGateway) throws Exception {
+        SkinCacheStore.Entry cachedEntry = generatedSkinCache.get(cacheKey);
+        if (cachedEntry != null && !cachedEntry.hasExpired()) {
+            return cachedEntry.skin();
+        }
+        if (cachedEntry != null) {
+            generatedSkinCache.remove(cacheKey, cachedEntry);
+        }
+
+        CompletableFuture<GeneratedSkin> created = new CompletableFuture<>();
+        CompletableFuture<GeneratedSkin> running = pendingGenerations.putIfAbsent(cacheKey, created);
+        if (running != null) {
+            return awaitGeneratedSkin(running);
+        }
+
+        try {
+            GeneratedSkin generated = currentGateway.generateSkin(cacheKey.skinUrl(), cacheKey.model());
+            cacheGeneratedSkin(cacheKey, generated);
+            created.complete(generated);
+            return generated;
+        } catch (Exception exception) {
+            created.completeExceptionally(exception);
+            throw exception;
+        } catch (Error error) {
+            created.completeExceptionally(error);
+            throw error;
+        } finally {
+            pendingGenerations.remove(cacheKey, created);
+        }
+    }
+
+    private GeneratedSkin awaitGeneratedSkin(CompletableFuture<GeneratedSkin> running) throws Exception {
+        try {
+            return running.get();
+        } catch (InterruptedException exception) {
+            Thread.currentThread().interrupt();
+            throw exception;
+        } catch (ExecutionException exception) {
+            Throwable cause = exception.getCause();
+            if (cause instanceof Exception nested) {
+                throw nested;
+            }
+            if (cause instanceof Error error) {
+                throw error;
+            }
+            throw new IllegalStateException("MineSkin 生成任务失败。", cause);
+        }
+    }
+
+    private synchronized void cacheGeneratedSkin(SkinCacheStore.Key cacheKey, GeneratedSkin generatedSkin) {
+        if (shuttingDown) {
+            return;
+        }
+        generatedSkinCache.put(cacheKey, new SkinCacheStore.Entry(generatedSkin,
+            System.currentTimeMillis() + Duration.ofMinutes(cacheMinutes).toMillis()));
+        trimGeneratedSkinCache();
+        generatedCacheDirty = true;
+        scheduleGeneratedCacheSave();
+    }
+
+    private synchronized void scheduleGeneratedCacheSave() {
+        if (shuttingDown || generatedCacheSaveTask != null) {
+            return;
+        }
+        generatedCacheSaveTask = Bukkit.getScheduler().runTaskLaterAsynchronously(plugin, () -> {
+            synchronized (this) {
+                generatedCacheSaveTask = null;
+            }
+            saveGeneratedSkinCache();
+        }, 100L);
+    }
+
+    private synchronized void cancelGeneratedCacheSave() {
+        if (generatedCacheSaveTask != null) {
+            generatedCacheSaveTask.cancel();
+            generatedCacheSaveTask = null;
+        }
+    }
+
+    private void trimGeneratedSkinCache() {
+        long now = System.currentTimeMillis();
+        generatedSkinCache.entrySet().removeIf(entry -> entry.getValue().expiresAtMillis() <= now);
+        int excessEntries = generatedSkinCache.size() - maxGeneratedCacheEntries;
+        if (excessEntries <= 0) {
+            return;
+        }
+        generatedSkinCache.entrySet().stream()
+            .sorted(Comparator.comparingLong(entry -> entry.getValue().expiresAtMillis()))
+            .limit(excessEntries)
+            .map(Map.Entry::getKey)
+            .forEach(generatedSkinCache::remove);
+    }
+
+    private boolean isLookupActive(UUID playerId, long lookupGeneration) {
+        return Long.valueOf(lookupGeneration).equals(pendingLookups.get(playerId));
+    }
+
+    private void cancelScheduledLookup(UUID playerId) {
+        BukkitRunnable scheduledLookup = scheduledLookups.remove(playerId);
+        if (scheduledLookup != null) {
+            scheduledLookup.cancel();
+        }
+    }
+
+    private void cancelScheduledLookups() {
+        for (UUID playerId : List.copyOf(scheduledLookups.keySet())) {
+            cancelScheduledLookup(playerId);
+        }
+    }
+
+    private void cancelRunningLookup(UUID playerId) {
+        runningLookups.forEach((lookupKey, lookupTask) -> {
+            if (lookupKey.playerId().equals(playerId) && runningLookups.remove(lookupKey, lookupTask)) {
+                lookupTask.cancel(true);
+            }
+        });
+        executor.purge();
+    }
+
+    private void cancelRunningLookups() {
+        runningLookups.forEach((lookupKey, lookupTask) -> {
+            if (runningLookups.remove(lookupKey, lookupTask)) {
+                lookupTask.cancel(true);
+            }
+        });
+        executor.purge();
+    }
+
    private List<SkinProvider> loadProviders(FileConfiguration config) {
-        ConfigurationSection providersSection = config.getConfigurationSection("providers");
+        ConfigurationSection providersSection = config.getConfigurationSection("skin-bridge.providers");
        if (providersSection == null) {
            return List.of();
        }
@@ -339,9 +645,19 @@ public final class SkinBridgeManager implements Listener {
                continue;
            }
            try {
-                URI.create(profileUrl.replace("{uuid}", "00000000000000000000000000000000")
+                URI profileUri = URI.create(profileUrl.replace("{uuid}", "00000000000000000000000000000000")
                    .replace("{uuid-dashed}", "00000000-0000-0000-0000-000000000000"));
-                loadedProviders.add(new SkinProvider(key, profileUrl, providerSection.getInt("priority", 100)));
+                if (!"https".equalsIgnoreCase(profileUri.getScheme())) {
+                    plugin.getLogger().warning("SkinBridge Provider " + key + " 必须使用 HTTPS，已跳过。");
+                    continue;
+                }
+                String configuredName = providerSection.getString("name", key);
+                String providerName = configuredName == null ? key : configuredName.trim();
+                if (providerName.isEmpty()) {
+                    providerName = key;
+                }
+                loadedProviders.add(new SkinProvider(key, providerName, profileUrl,
+                    providerSection.getInt("priority", 100)));
            } catch (IllegalArgumentException exception) {
                plugin.getLogger().warning("SkinBridge Provider " + key + " 的 profile-url 无效，已跳过。");
            }
@@ -350,30 +666,35 @@ public final class SkinBridgeManager implements Listener {
        return List.copyOf(loadedProviders);
    }

-    private SkinBridgeGateway loadGateway(String endpoint, String apiKey, String visibility, int timeoutSeconds) {
+    private SkinBridgeGateway loadGateway(String endpoint, String apiKey, String visibility, int timeoutSeconds,
+                                          long minimumSubmitIntervalMillis) {
        if (apiKey.isBlank()) {
            return null;
        }
        try {
            return new MineSkinGateway(httpClient, endpoint, apiKey, visibility, timeoutSeconds,
-                "EssentialsC/" + plugin.getDescription().getVersion() + " SkinBridge");
+                minimumSubmitIntervalMillis,
+                "EssentialsC/" + plugin.getPluginMeta().getVersion() + " SkinBridge");
        } catch (Exception | LinkageError exception) {
            plugin.getLogger().warning("加载 MineSkin SkinBridge 适配器失败: " + exception.getMessage());
            return null;
        }
    }

-    private void addDefaults(FileConfiguration config) {
-        config.addDefault("config-version", 1);
-        config.addDefault("enabled", false);
-        config.addDefault("send-player-message", true);
-        config.addDefault("profile-request-timeout-seconds", 5);
-        config.addDefault("mineskin.endpoint", "https://api.mineskin.org");
-        config.addDefault("mineskin.api-key", "");
-        config.addDefault("mineskin.visibility", "unlisted");
-        config.addDefault("mineskin.request-timeout-seconds", 30);
-        config.addDefault("cache-minutes", 120);
-        config.addDefault("join-delay-ticks", 20);
+    private Set<String> loadNormalizedValues(FileConfiguration config, String path) {
+        Set<String> values = ConcurrentHashMap.newKeySet();
+        for (String value : config.getStringList(path)) {
+            String normalized = value == null ? "" : value.trim().toLowerCase(java.util.Locale.ROOT);
+            if (!normalized.isEmpty()) {
+                values.add(normalized);
+            }
+        }
+        return Set.copyOf(values);
+    }
+
+    private boolean isExcluded(Player player) {
+        return excludedUuids.contains(player.getUniqueId().toString().toLowerCase(java.util.Locale.ROOT))
+            || excludedNames.contains(player.getName().toLowerCase(java.util.Locale.ROOT));
    }

    private void applySkin(UUID playerId, CachedLookup resolved, long lookupGeneration) {
@@ -445,7 +766,7 @@ public final class SkinBridgeManager implements Listener {
        return Math.max(min, Math.min(max, value));
    }

-    private record SkinProvider(String id, String profileUrl, int priority) {
+    private record SkinProvider(String id, String name, String profileUrl, int priority) {
        private String resolveProfileUrl(UUID playerId) {
            return profileUrl.replace("{uuid}", playerId.toString().replace("-", ""))
                .replace("{uuid-dashed}", playerId.toString());
@@ -455,6 +776,9 @@ public final class SkinBridgeManager implements Listener {
    private record ProviderProfile(String skinUrl, SkinModel model) {
    }

+    private record LookupKey(UUID playerId, long generation) {
+    }
+
    private record CachedLookup(String providerId, GeneratedSkin skin, State state, long expiresAtMillis) {
        private boolean hasExpired() {
            return System.currentTimeMillis() >= expiresAtMillis;
@@ -474,9 +798,11 @@ public final class SkinBridgeManager implements Listener {
        QUEUED,
        CACHED,
        ALREADY_RUNNING,
-        FEATURE_DISABLED,
+        EXCLUDED,
+        QUEUE_FULL,
        DEPENDENCY_MISSING,
-        NO_PROVIDERS
+        NO_PROVIDERS,
+        REFRESH_COOLDOWN
    }

    public record Status(State state, String providerId) {
@@ -484,6 +810,7 @@ public final class SkinBridgeManager implements Listener {

    public enum State {
        EXTERNAL,
+        EXCLUDED,
        NOT_EXTERNAL,
        PENDING,
        UNKNOWN
@@ -0,0 +1,95 @@
+package cn.infstar.essentialsC.skinbridge;
+
+import cn.infstar.essentialsC.EssentialsC;
+import cn.infstar.essentialsC.util.AtomicYamlWriter;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import java.io.File;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.Map;
+
+final class SkinCacheStore {
+
+    private final EssentialsC plugin;
+    private final File cacheFile;
+
+    SkinCacheStore(EssentialsC plugin) {
+        this.plugin = plugin;
+        this.cacheFile = new File(plugin.getDataFolder(), "skin-cache.yml");
+    }
+
+    Map<Key, Entry> load() {
+        Map<Key, Entry> loaded = new HashMap<>();
+        if (!cacheFile.exists()) {
+            return loaded;
+        }
+
+        YamlConfiguration config = YamlConfiguration.loadConfiguration(cacheFile);
+        ConfigurationSection entries = config.getConfigurationSection("entries");
+        if (entries == null) {
+            return loaded;
+        }
+        long now = System.currentTimeMillis();
+        for (String id : entries.getKeys(false)) {
+            String path = "entries." + id;
+            try {
+                String skinUrl = config.getString(path + ".skin-url", "");
+                SkinModel model = SkinModel.valueOf(config.getString(path + ".model", "CLASSIC"));
+                long expiresAt = config.getLong(path + ".expires-at", 0L);
+                String value = config.getString(path + ".value", "");
+                String signature = config.getString(path + ".signature", "");
+                if (expiresAt > now && !skinUrl.isBlank() && !value.isBlank() && !signature.isBlank()) {
+                    loaded.put(new Key(skinUrl, model),
+                        new Entry(new GeneratedSkin(value, signature), expiresAt));
+                }
+            } catch (IllegalArgumentException exception) {
+                plugin.getLogger().warning("忽略无效的 SkinBridge 缓存记录: " + id);
+            }
+        }
+        return loaded;
+    }
+
+    boolean save(Map<Key, Entry> entries) {
+        YamlConfiguration config = new YamlConfiguration();
+        entries.forEach((key, entry) -> {
+            String path = "entries." + cacheId(key);
+            config.set(path + ".skin-url", key.skinUrl());
+            config.set(path + ".model", key.model().name());
+            config.set(path + ".expires-at", entry.expiresAtMillis());
+            config.set(path + ".value", entry.skin().value());
+            config.set(path + ".signature", entry.skin().signature());
+        });
+        try {
+            AtomicYamlWriter.save(config, cacheFile);
+            return true;
+        } catch (Exception exception) {
+            plugin.getLogger().warning("保存 skin-cache.yml 失败: " + exception.getMessage());
+            return false;
+        }
+    }
+
+    private String cacheId(Key key) {
+        try {
+            MessageDigest digest = MessageDigest.getInstance("SHA-256");
+            byte[] hash = digest.digest((key.skinUrl() + "\n" + key.model().name())
+                .getBytes(StandardCharsets.UTF_8));
+            return Base64.getUrlEncoder().withoutPadding().encodeToString(hash);
+        } catch (NoSuchAlgorithmException exception) {
+            throw new IllegalStateException("当前 Java 环境不支持 SHA-256。", exception);
+        }
+    }
+
+    record Key(String skinUrl, SkinModel model) {
+    }
+
+    record Entry(GeneratedSkin skin, long expiresAtMillis) {
+        boolean hasExpired() {
+            return System.currentTimeMillis() >= expiresAtMillis;
+        }
+    }
+}
@@ -1,12 +1,16 @@
 package cn.infstar.essentialsC.teleport;

 import cn.infstar.essentialsC.EssentialsC;
+import cn.infstar.essentialsC.api.event.TeleportEvent;
+import cn.infstar.essentialsC.api.event.TeleportRequestReceiveEvent;
+import cn.infstar.essentialsC.api.event.TeleportRequestReplyEvent;
+import cn.infstar.essentialsC.api.event.TeleportRequestSendEvent;
+import cn.infstar.essentialsC.api.event.TeleportWarmupCancelledEvent;
+import cn.infstar.essentialsC.api.event.TeleportWarmupEvent;
 import cn.infstar.essentialsC.commands.VanishCommand;
 import net.kyori.adventure.title.Title;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
@@ -18,13 +22,10 @@ import org.bukkit.event.player.PlayerTeleportEvent;
 import org.bukkit.permissions.PermissionAttachmentInfo;
 import org.bukkit.scheduler.BukkitTask;

-import java.io.File;
-import java.io.IOException;
 import java.time.Duration;
 import java.time.Instant;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
-import java.util.Comparator;
 import java.util.Deque;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -52,9 +53,11 @@ public final class TeleportRequestManager implements Listener {
    private final Set<UUID> warmupDamagedPlayers = new HashSet<>();
    private final Set<UUID> invulnerablePlayers = new HashSet<>();
    private final Set<UUID> ignoringRequests = new HashSet<>();
-    private final File ignoreFile;
+    private final TeleportStateStore stateStore;
+    private BukkitTask cleanupTask;

    private int timeoutSeconds;
+    private int maxPendingRequests;
    private boolean strictTpaRequests;
    private boolean strictTpaHereRequests;
    private int warmupSeconds;
@@ -74,12 +77,17 @@ public final class TeleportRequestManager implements Listener {

    public TeleportRequestManager(EssentialsC plugin) {
        this.plugin = plugin;
-        this.ignoreFile = new File(plugin.getDataFolder(), "teleport-ignore.yml");
+        this.stateStore = new TeleportStateStore(plugin);
        reload();
+        TeleportStateStore.CooldownState cooldownState = stateStore.loadCooldowns();
+        sendCooldowns.putAll(cooldownState.send());
+        acceptCooldowns.putAll(cooldownState.accept());
+        cleanupTask = Bukkit.getScheduler().runTaskTimer(plugin, this::cleanupExpiredState, 1200L, 1200L);
    }

    public void reload() {
        plugin.getConfig().addDefault("tpa.timeout-seconds", 60);
+        plugin.getConfig().addDefault("tpa.max-pending-requests", 5);
        plugin.getConfig().addDefault("tpa.strict-tpa-requests", false);
        plugin.getConfig().addDefault("tpa.strict-tpahere-requests", true);
        plugin.getConfig().addDefault("tpa.warmup-seconds", 5);
@@ -98,9 +106,10 @@ public final class TeleportRequestManager implements Listener {
        plugin.getConfig().addDefault("tpa.sounds.complete", "entity.enderman.teleport");
        plugin.getConfig().set("tpa.warmup-move-threshold", null);
        plugin.getConfig().options().copyDefaults(true);
-        plugin.saveConfig();

        timeoutSeconds = Math.max(0, plugin.getConfig().getInt("tpa.timeout-seconds", 60));
+        maxPendingRequests = Math.max(1, Math.min(100,
+            plugin.getConfig().getInt("tpa.max-pending-requests", 5)));
        strictTpaRequests = plugin.getConfig().getBoolean("tpa.strict-tpa-requests", false);
        strictTpaHereRequests = plugin.getConfig().getBoolean("tpa.strict-tpahere-requests", true);
        warmupSeconds = Math.max(0, plugin.getConfig().getInt("tpa.warmup-seconds", 5));
@@ -118,16 +127,22 @@ public final class TeleportRequestManager implements Listener {
        warmupSound = plugin.getConfig().getString("tpa.sounds.warmup", "block.note_block.banjo");
        cancelSound = plugin.getConfig().getString("tpa.sounds.cancelled", "entity.item.break");
        completeSound = plugin.getConfig().getString("tpa.sounds.complete", "entity.enderman.teleport");
-        loadIgnoringRequests();
+        ignoringRequests.clear();
+        ignoringRequests.addAll(stateStore.loadIgnoringRequests());
    }

    public void shutdown() {
+        if (cleanupTask != null) {
+            cleanupTask.cancel();
+            cleanupTask = null;
+        }
+        stateStore.saveCooldowns(sendCooldowns, acceptCooldowns);
        requests.clear();
        sendCooldowns.clear();
        acceptCooldowns.clear();
        cancelAllWarmups();
        clearAllInvulnerability();
-        saveIgnoringRequests();
+        stateStore.saveIgnoringRequests(ignoringRequests);
    }

    public CreateRequestResult createRequest(Player requester, Player target, TeleportRequest.Type type) {
@@ -140,16 +155,6 @@ public final class TeleportRequestManager implements Listener {
            return new CreateRequestResult(CreateRequestStatus.ON_COOLDOWN, null, sendCooldown.seconds());
        }

-        Optional<TeleportRequest> existingRequest = findIncoming(target, requester.getName());
-        if (existingRequest.isPresent()
-            && existingRequest.get().type() == type
-            && !existingRequest.get().hasExpired()) {
-            if (applyCooldown) {
-                startCooldown(requester, sendCooldowns, sendCooldownSeconds);
-            }
-            return new CreateRequestResult(CreateRequestStatus.DUPLICATE, existingRequest.get());
-        }
-
        TeleportRequest request = new TeleportRequest(
            requester.getUniqueId(),
            requester.getName(),
@@ -162,6 +167,14 @@ public final class TeleportRequestManager implements Listener {
            TeleportRequest.Status.PENDING
        );

+        if (applyCooldown) {
+            TeleportRequestSendEvent sendEvent = new TeleportRequestSendEvent(requester, request);
+            Bukkit.getPluginManager().callEvent(sendEvent);
+            if (sendEvent.isCancelled()) {
+                return new CreateRequestResult(CreateRequestStatus.CANCELLED, request);
+            }
+        }
+
        if (isIgnoringRequests(target) || isVanished(target)) {
            request.setStatus(TeleportRequest.Status.IGNORED);
            if (applyCooldown) {
@@ -170,8 +183,24 @@ public final class TeleportRequestManager implements Listener {
            return new CreateRequestResult(CreateRequestStatus.IGNORED, request);
        }

+        Optional<TeleportRequest> existingRequest = findIncoming(target, requester.getName());
+        if (existingRequest.isPresent()
+            && existingRequest.get().type() == type
+            && !existingRequest.get().hasExpired()) {
+            if (applyCooldown) {
+                startCooldown(requester, sendCooldowns, sendCooldownSeconds);
+            }
+            return new CreateRequestResult(CreateRequestStatus.DUPLICATE, existingRequest.get());
+        }
+
+        TeleportRequestReceiveEvent receiveEvent = new TeleportRequestReceiveEvent(target, request);
+        Bukkit.getPluginManager().callEvent(receiveEvent);
+        if (receiveEvent.isCancelled()) {
+            return new CreateRequestResult(CreateRequestStatus.CANCELLED, request);
+        }
        Deque<TeleportRequest> targetRequests = requests.computeIfAbsent(target.getUniqueId(), ignored -> new ArrayDeque<>());
-        targetRequests.addFirst(request);
+        pruneExpiredRequests(targetRequests);
+        TeleportRequestQueuePolicy.addFirstBounded(targetRequests, request, maxPendingRequests);
        if (applyCooldown) {
            startCooldown(requester, sendCooldowns, sendCooldownSeconds);
        }
@@ -197,34 +226,25 @@ public final class TeleportRequestManager implements Listener {
            .findFirst();
    }

-    public Optional<TeleportRequest> findOutgoing(Player requester, String targetName) {
-        return requests.values().stream()
-            .flatMap(Deque::stream)
-            .filter(request -> request.requesterId().equals(requester.getUniqueId()))
-            .filter(request -> !request.hasExpired())
-            .filter(request -> targetName == null || request.targetName().equalsIgnoreCase(targetName))
-            .max(Comparator.comparingLong(TeleportRequest::expiresAtMillis));
-    }
-
    public List<String> getIncomingRequesterNames(Player target, String partial) {
-        String partialLower = partial == null ? "" : partial.toLowerCase();
+        String partialLower = partial == null ? "" : partial.toLowerCase(Locale.ROOT);
        return requests.getOrDefault(target.getUniqueId(), new ArrayDeque<>()).stream()
            .filter(request -> !request.hasExpired())
            .map(TeleportRequest::requesterName)
-            .filter(name -> name.toLowerCase().startsWith(partialLower))
+            .filter(name -> name.toLowerCase(Locale.ROOT).startsWith(partialLower))
            .distinct()
            .sorted(String.CASE_INSENSITIVE_ORDER)
            .toList();
    }

    public List<String> getOutgoingTargetNames(Player requester, String partial) {
-        String partialLower = partial == null ? "" : partial.toLowerCase();
+        String partialLower = partial == null ? "" : partial.toLowerCase(Locale.ROOT);
        return requests.values().stream()
            .flatMap(Deque::stream)
            .filter(request -> request.requesterId().equals(requester.getUniqueId()))
            .filter(request -> !request.hasExpired())
            .map(TeleportRequest::targetName)
-            .filter(name -> name.toLowerCase().startsWith(partialLower))
+            .filter(name -> name.toLowerCase(Locale.ROOT).startsWith(partialLower))
            .distinct()
            .sorted(String.CASE_INSENSITIVE_ORDER)
            .toList();
@@ -242,6 +262,11 @@ public final class TeleportRequestManager implements Listener {
        }

        request.setStatus(TeleportRequest.Status.ACCEPTED);
+        TeleportRequestReplyEvent replyEvent = new TeleportRequestReplyEvent(target, request);
+        Bukkit.getPluginManager().callEvent(replyEvent);
+        if (replyEvent.isCancelled()) {
+            return TeleportResult.CANCELLED;
+        }
        Map<String, String> placeholders = placeholders(request);
        target.sendMessage(plugin.getLangManager().getPrefixedComponent("tpa.messages.accepted-target", placeholders));

@@ -273,8 +298,9 @@ public final class TeleportRequestManager implements Listener {
            return TeleportResult.ACCEPTED_WITHOUT_TELEPORT;
        }

-        startWarmup(plan, playerWarmupSeconds);
-        return TeleportResult.WARMING_UP;
+        return startWarmup(plan, playerWarmupSeconds)
+            ? TeleportResult.WARMING_UP
+            : TeleportResult.CANCELLED;
    }

    public TeleportResult deny(Player target, TeleportRequest request) {
@@ -285,6 +311,11 @@ public final class TeleportRequestManager implements Listener {
            return TeleportResult.EXPIRED;
        }
        request.setStatus(TeleportRequest.Status.DECLINED);
+        TeleportRequestReplyEvent replyEvent = new TeleportRequestReplyEvent(target, request);
+        Bukkit.getPluginManager().callEvent(replyEvent);
+        if (replyEvent.isCancelled()) {
+            return TeleportResult.CANCELLED;
+        }
        Map<String, String> placeholders = placeholders(request);
        target.sendMessage(plugin.getLangManager().getPrefixedComponent("tpa.messages.denied-target", placeholders));
        Player requester = Bukkit.getPlayer(request.requesterId());
@@ -296,35 +327,15 @@ public final class TeleportRequestManager implements Listener {
        return TeleportResult.SUCCESS;
    }

-    public boolean cancel(TeleportRequest request) {
-        Deque<TeleportRequest> targetRequests = requests.get(request.targetId());
-        if (targetRequests == null) {
-            return false;
-        }
-
-        boolean removed = targetRequests.removeIf(candidate ->
-            candidate.requesterName().equalsIgnoreCase(request.requesterName()));
-        if (targetRequests.isEmpty()) {
-            requests.remove(request.targetId());
-        }
-        return removed;
-    }
-
    public boolean isIgnoringRequests(Player player) {
        return ignoringRequests.contains(player.getUniqueId());
    }

    public boolean isVanished(Player player) {
-        if (VanishCommand.isVanished(player)) {
-            return true;
-        }
-        return player.hasMetadata("vanished") && player.getMetadata("vanished").stream()
-            .map(metadata -> metadata.asBoolean())
-            .findFirst()
-            .orElse(false);
+        return VanishCommand.isVanished(player);
    }

-    public boolean toggleIgnoringRequests(Player player) {
+    public ToggleIgnoreResult toggleIgnoringRequests(Player player) {
        UUID uuid = player.getUniqueId();
        boolean nowIgnoring;
        if (ignoringRequests.contains(uuid)) {
@@ -334,8 +345,15 @@ public final class TeleportRequestManager implements Listener {
            ignoringRequests.add(uuid);
            nowIgnoring = true;
        }
-        saveIgnoringRequests();
-        return nowIgnoring;
+        if (!stateStore.saveIgnoringRequests(ignoringRequests)) {
+            if (nowIgnoring) {
+                ignoringRequests.remove(uuid);
+            } else {
+                ignoringRequests.add(uuid);
+            }
+            return ToggleIgnoreResult.SAVE_FAILED;
+        }
+        return nowIgnoring ? ToggleIgnoreResult.ENABLED : ToggleIgnoreResult.DISABLED;
    }

    public void playRequestReceivedSound(Player player) {
@@ -375,11 +393,11 @@ public final class TeleportRequestManager implements Listener {
            return exactMatch;
        }

-        String playerNameLower = playerName.toLowerCase();
+        String playerNameLower = playerName.toLowerCase(Locale.ROOT);
        return Bukkit.getOnlinePlayers().stream()
            .map(Player.class::cast)
            .filter(filter)
-            .filter(player -> player.getName().toLowerCase().startsWith(playerNameLower))
+            .filter(player -> player.getName().toLowerCase(Locale.ROOT).startsWith(playerNameLower))
            .findFirst();
    }

@@ -422,13 +440,15 @@ public final class TeleportRequestManager implements Listener {
            return new TeleportPlan(
                requester,
                strictTpaRequests ? currentTarget.getLocation().clone() : null,
-                strictTpaRequests ? null : currentTarget.getUniqueId()
+                strictTpaRequests ? null : currentTarget.getUniqueId(),
+                request
            );
        }
        return new TeleportPlan(
            currentTarget,
            strictTpaHereRequests ? request.requesterLocation().clone() : null,
-            strictTpaHereRequests ? null : requester.getUniqueId()
+            strictTpaHereRequests ? null : requester.getUniqueId(),
+            request
        );
    }

@@ -452,9 +472,14 @@ public final class TeleportRequestManager implements Listener {
        }
    }

-    private void startWarmup(TeleportPlan plan, int playerWarmupSeconds) {
+    private boolean startWarmup(TeleportPlan plan, int playerWarmupSeconds) {
        Player teleporter = plan.teleporter();
        UUID uuid = teleporter.getUniqueId();
+        TeleportWarmupEvent warmupEvent = new TeleportWarmupEvent(teleporter, plan.request(), playerWarmupSeconds);
+        Bukkit.getPluginManager().callEvent(warmupEvent);
+        if (warmupEvent.isCancelled()) {
+            return false;
+        }
        PendingTeleport pendingTeleport = new PendingTeleport(
            plan,
            teleporter.getLocation().clone(),
@@ -466,6 +491,7 @@ public final class TeleportRequestManager implements Listener {
        warmups.put(uuid, pendingTeleport);
        teleporter.sendMessage(plugin.getLangManager().getPrefixedComponent("tpa.messages.warmup-start",
            Map.of("seconds", String.valueOf(playerWarmupSeconds))));
+        return true;
    }

    private void tickWarmup(UUID teleporterId) {
@@ -476,16 +502,18 @@ public final class TeleportRequestManager implements Listener {

        Player teleporter = Bukkit.getPlayer(teleporterId);
        if (teleporter == null || !teleporter.isOnline()) {
-            cancelWarmup(teleporterId, null, false);
+            cancelWarmup(teleporterId, null, false, TeleportWarmupCancelledEvent.Reason.PLAYER_QUIT);
            return;
        }

        if (cancelWarmupOnDamage && warmupDamagedPlayers.contains(teleporterId)) {
-            cancelWarmup(teleporterId, "tpa.messages.warmup-cancelled-damage", true);
+            cancelWarmup(teleporterId, "tpa.messages.warmup-cancelled-damage", true,
+                TeleportWarmupCancelledEvent.Reason.PLAYER_DAMAGE);
            return;
        }
        if (cancelWarmupOnMove && hasMoved(pendingTeleport.startLocation(), teleporter.getLocation())) {
-            cancelWarmup(teleporterId, "tpa.messages.warmup-cancelled-move", true);
+            cancelWarmup(teleporterId, "tpa.messages.warmup-cancelled-move", true,
+                TeleportWarmupCancelledEvent.Reason.PLAYER_MOVE);
            return;
        }

@@ -531,6 +559,13 @@ public final class TeleportRequestManager implements Listener {
            return TeleportResult.TARGET_OFFLINE;
        }

+        TeleportEvent teleportEvent = new TeleportEvent(teleporter, plan.request(), destination);
+        Bukkit.getPluginManager().callEvent(teleportEvent);
+        if (teleportEvent.isCancelled()) {
+            return TeleportResult.CANCELLED;
+        }
+        destination = teleportEvent.getDestination();
+
        teleporter.leaveVehicle();
        teleporter.eject();
        teleporter.setFallDistance(0.0F);
@@ -646,6 +681,11 @@ public final class TeleportRequestManager implements Listener {
    }

    private void cancelWarmup(UUID teleporterId, String messagePath, boolean playSound) {
+        cancelWarmup(teleporterId, messagePath, playSound, null);
+    }
+
+    private void cancelWarmup(UUID teleporterId, String messagePath, boolean playSound,
+                              TeleportWarmupCancelledEvent.Reason reason) {
        PendingTeleport pendingTeleport = warmups.remove(teleporterId);
        warmupDamagedPlayers.remove(teleporterId);
        if (pendingTeleport == null) {
@@ -663,12 +703,18 @@ public final class TeleportRequestManager implements Listener {
                playConfiguredSound(player, cancelSound, 1.0F, 1.0F);
            }
        }
+        if (player != null && reason != null) {
+            int duration = pendingTeleport.initialSeconds();
+            Bukkit.getPluginManager().callEvent(new TeleportWarmupCancelledEvent(
+                player, pendingTeleport.plan().request(), duration,
+                Math.max(0, duration - pendingTeleport.remainingSeconds()), reason));
+        }
    }

    private void cancelAllWarmups() {
        List<UUID> warmingPlayers = new ArrayList<>(warmups.keySet());
        for (UUID warmingPlayer : warmingPlayers) {
-            cancelWarmup(warmingPlayer, null, false);
+            cancelWarmup(warmingPlayer, null, false, TeleportWarmupCancelledEvent.Reason.PLUGIN_SHUTDOWN);
        }
    }

@@ -702,7 +748,7 @@ public final class TeleportRequestManager implements Listener {
        placeholders.put("requester", request.requesterName());
        placeholders.put("target", request.targetName());
        placeholders.put("seconds", String.valueOf(timeoutSeconds));
-        placeholders.put("type", request.type().name().toLowerCase());
+        placeholders.put("type", request.type().name().toLowerCase(Locale.ROOT));
        return placeholders;
    }

@@ -728,8 +774,13 @@ public final class TeleportRequestManager implements Listener {
    @EventHandler
    private void onPlayerQuit(PlayerQuitEvent event) {
        UUID uuid = event.getPlayer().getUniqueId();
-        cancelWarmup(uuid, null, false);
+        cancelWarmup(uuid, null, false, TeleportWarmupCancelledEvent.Reason.PLAYER_QUIT);
        clearInvulnerability(uuid);
+        requests.remove(uuid);
+        requests.values().removeIf(targetRequests -> {
+            targetRequests.removeIf(request -> request.requesterId().equals(uuid));
+            return targetRequests.isEmpty();
+        });
    }

    private boolean hasMoved(Location start, Location current) {
@@ -747,46 +798,36 @@ public final class TeleportRequestManager implements Listener {
        return player.getVelocity().length() >= MOVEMENT_THRESHOLD;
    }

-    private void loadIgnoringRequests() {
-        ignoringRequests.clear();
-        if (!ignoreFile.exists()) {
-            return;
-        }
-
-        FileConfiguration ignoreConfig = YamlConfiguration.loadConfiguration(ignoreFile);
-        if (!ignoreConfig.isConfigurationSection("ignored")) {
-            return;
-        }
-
-        for (String key : ignoreConfig.getConfigurationSection("ignored").getKeys(false)) {
-            if (!ignoreConfig.getBoolean("ignored." + key, false)) {
-                continue;
-            }
-            try {
-                ignoringRequests.add(UUID.fromString(key));
-            } catch (IllegalArgumentException ignored) {
-                plugin.getLogger().warning("忽略无效的 TPA 忽略记录 UUID: " + key);
-            }
-        }
+    private void pruneExpiredRequests(Deque<TeleportRequest> targetRequests) {
+        long retentionMillis = Math.max(60_000L, timeoutSeconds * 1000L);
+        long now = System.currentTimeMillis();
+        targetRequests.removeIf(request -> TeleportRequestQueuePolicy.shouldPrune(
+            request.expiresAtMillis(), now, retentionMillis));
    }

-    private void saveIgnoringRequests() {
-        FileConfiguration ignoreConfig = new YamlConfiguration();
-        for (UUID uuid : ignoringRequests) {
-            ignoreConfig.set("ignored." + uuid, true);
-        }
-        try {
-            ignoreConfig.save(ignoreFile);
-        } catch (IOException e) {
-            plugin.getLogger().warning("保存 teleport-ignore.yml 失败: " + e.getMessage());
-        }
+    private void cleanupExpiredState() {
+        requests.entrySet().removeIf(entry -> {
+            pruneExpiredRequests(entry.getValue());
+            return entry.getValue().isEmpty();
+        });
+        long now = System.currentTimeMillis();
+        sendCooldowns.values().removeIf(expiresAt -> expiresAt <= now);
+        acceptCooldowns.values().removeIf(expiresAt -> expiresAt <= now);
+        stateStore.saveCooldowns(sendCooldowns, acceptCooldowns);
+    }
+
+    public enum ToggleIgnoreResult {
+        ENABLED,
+        DISABLED,
+        SAVE_FAILED
    }

    public enum CreateRequestStatus {
        SUCCESS,
        DUPLICATE,
        IGNORED,
-        ON_COOLDOWN
+        ON_COOLDOWN,
+        CANCELLED
    }

    public record TeleportResult(Status status, int cooldownSeconds) {
@@ -797,6 +838,7 @@ public final class TeleportRequestManager implements Listener {
        public static final TeleportResult TARGET_OFFLINE = new TeleportResult(Status.TARGET_OFFLINE, 0);
        public static final TeleportResult ALREADY_WARMING_UP = new TeleportResult(Status.ALREADY_WARMING_UP, 0);
        public static final TeleportResult ACCEPTED_WITHOUT_TELEPORT = new TeleportResult(Status.ACCEPTED_WITHOUT_TELEPORT, 0);
+        public static final TeleportResult CANCELLED = new TeleportResult(Status.CANCELLED, 0);

        public static TeleportResult onCooldown(int seconds) {
            return new TeleportResult(Status.ON_COOLDOWN, seconds);
@@ -810,7 +852,8 @@ public final class TeleportRequestManager implements Listener {
            TARGET_OFFLINE,
            ALREADY_WARMING_UP,
            ACCEPTED_WITHOUT_TELEPORT,
-            ON_COOLDOWN
+            ON_COOLDOWN,
+            CANCELLED
        }
    }

@@ -902,7 +945,8 @@ public final class TeleportRequestManager implements Listener {
        }
    }

-    private record TeleportPlan(Player teleporter, Location fixedDestination, UUID dynamicTargetId) {
+    private record TeleportPlan(Player teleporter, Location fixedDestination, UUID dynamicTargetId,
+                                TeleportRequest request) {
    }

    private record OptionalIntCooldown(boolean active, int seconds) {
@@ -914,12 +958,14 @@ public final class TeleportRequestManager implements Listener {
    private static final class PendingTeleport {
        private final TeleportPlan plan;
        private final Location startLocation;
+        private final int initialSeconds;
        private int remainingSeconds;
        private BukkitTask task;

        private PendingTeleport(TeleportPlan plan, Location startLocation, int remainingSeconds) {
            this.plan = plan;
            this.startLocation = startLocation;
+            this.initialSeconds = remainingSeconds;
            this.remainingSeconds = remainingSeconds;
        }

@@ -935,6 +981,10 @@ public final class TeleportRequestManager implements Listener {
            return remainingSeconds;
        }

+        private int initialSeconds() {
+            return initialSeconds;
+        }
+
        private void decrementRemainingSeconds() {
            remainingSeconds--;
        }
@@ -0,0 +1,20 @@
+package cn.infstar.essentialsC.teleport;
+
+import java.util.Deque;
+
+final class TeleportRequestQueuePolicy {
+
+    private TeleportRequestQueuePolicy() {
+    }
+
+    static <T> void addFirstBounded(Deque<T> queue, T value, int maximumSize) {
+        while (queue.size() >= maximumSize) {
+            queue.removeLast();
+        }
+        queue.addFirst(value);
+    }
+
+    static boolean shouldPrune(long expiresAtMillis, long nowMillis, long retentionMillis) {
+        return expiresAtMillis <= nowMillis - retentionMillis;
+    }
+}
@@ -0,0 +1,145 @@
+package cn.infstar.essentialsC.teleport;
+
+import cn.infstar.essentialsC.EssentialsC;
+import cn.infstar.essentialsC.util.AtomicYamlWriter;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+final class TeleportStateStore {
+
+    private final EssentialsC plugin;
+    private final File cooldownFile;
+    private final File ignoreFile;
+    private boolean cooldownWritable = true;
+    private boolean ignoreWritable = true;
+
+    TeleportStateStore(EssentialsC plugin) {
+        this.plugin = plugin;
+        this.cooldownFile = new File(plugin.getDataFolder(), "teleport-cooldowns.yml");
+        this.ignoreFile = new File(plugin.getDataFolder(), "teleport-ignore.yml");
+    }
+
+    CooldownState loadCooldowns() {
+        Map<UUID, Long> send = new HashMap<>();
+        Map<UUID, Long> accept = new HashMap<>();
+        if (!cooldownFile.exists()) {
+            return new CooldownState(send, accept);
+        }
+
+        YamlConfiguration config = new YamlConfiguration();
+        try {
+            config.load(cooldownFile);
+        } catch (IOException | InvalidConfigurationException exception) {
+            cooldownWritable = false;
+            plugin.getLogger().severe("加载 teleport-cooldowns.yml 失败，已禁止覆盖原文件: "
+                + exception.getMessage());
+            return new CooldownState(send, accept);
+        }
+        loadCooldownMap(config, "send", send);
+        loadCooldownMap(config, "accept", accept);
+        return new CooldownState(send, accept);
+    }
+
+    void saveCooldowns(Map<UUID, Long> send, Map<UUID, Long> accept) {
+        if (!cooldownWritable) {
+            return;
+        }
+        YamlConfiguration config = new YamlConfiguration();
+        long now = System.currentTimeMillis();
+        saveCooldownMap(config, "send", send, now);
+        saveCooldownMap(config, "accept", accept, now);
+        try {
+            AtomicYamlWriter.save(config, cooldownFile);
+        } catch (Exception exception) {
+            plugin.getLogger().warning("保存 teleport-cooldowns.yml 失败: " + exception.getMessage());
+        }
+    }
+
+    Set<UUID> loadIgnoringRequests() {
+        Set<UUID> ignoredPlayers = new HashSet<>();
+        if (!ignoreFile.exists()) {
+            return ignoredPlayers;
+        }
+
+        YamlConfiguration config = new YamlConfiguration();
+        try {
+            config.load(ignoreFile);
+        } catch (IOException | InvalidConfigurationException exception) {
+            ignoreWritable = false;
+            plugin.getLogger().severe("加载 teleport-ignore.yml 失败，已禁止覆盖原文件: "
+                + exception.getMessage());
+            return ignoredPlayers;
+        }
+        ConfigurationSection ignored = config.getConfigurationSection("ignored");
+        if (ignored == null) {
+            return ignoredPlayers;
+        }
+        for (String key : ignored.getKeys(false)) {
+            if (!ignored.getBoolean(key, false)) {
+                continue;
+            }
+            try {
+                ignoredPlayers.add(UUID.fromString(key));
+            } catch (IllegalArgumentException exception) {
+                plugin.getLogger().warning("忽略无效的 TPA 忽略记录 UUID: " + key);
+            }
+        }
+        return ignoredPlayers;
+    }
+
+    boolean saveIgnoringRequests(Set<UUID> ignoredPlayers) {
+        if (!ignoreWritable) {
+            return false;
+        }
+        YamlConfiguration config = new YamlConfiguration();
+        for (UUID playerId : ignoredPlayers) {
+            config.set("ignored." + playerId, true);
+        }
+        try {
+            AtomicYamlWriter.save(config, ignoreFile);
+            return true;
+        } catch (Exception exception) {
+            plugin.getLogger().warning("保存 teleport-ignore.yml 失败: " + exception.getMessage());
+            return false;
+        }
+    }
+
+    private void loadCooldownMap(YamlConfiguration config, String path, Map<UUID, Long> destination) {
+        ConfigurationSection section = config.getConfigurationSection(path);
+        if (section == null) {
+            return;
+        }
+        long now = System.currentTimeMillis();
+        for (String key : section.getKeys(false)) {
+            try {
+                UUID playerId = UUID.fromString(key);
+                long expiresAt = section.getLong(key, 0L);
+                if (expiresAt > now) {
+                    destination.put(playerId, expiresAt);
+                }
+            } catch (IllegalArgumentException exception) {
+                plugin.getLogger().warning("忽略无效的 TPA 冷却记录 UUID: " + key);
+            }
+        }
+    }
+
+    private void saveCooldownMap(YamlConfiguration config, String path, Map<UUID, Long> source, long now) {
+        source.forEach((playerId, expiresAt) -> {
+            if (expiresAt > now) {
+                config.set(path + "." + playerId, expiresAt);
+            }
+        });
+    }
+
+    record CooldownState(Map<UUID, Long> send, Map<UUID, Long> accept) {
+    }
+}
@@ -1,13 +1,14 @@
 package cn.infstar.essentialsC.tpsbar;

 import cn.infstar.essentialsC.EssentialsC;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
 import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
 import org.bukkit.boss.BarColor;
 import org.bukkit.boss.BarStyle;
 import org.bukkit.boss.BossBar;
 import org.bukkit.command.CommandMap;
-import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.command.PluginIdentifiableCommand;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -26,6 +27,8 @@ import java.util.UUID;

 public final class TpsBarManager implements Listener, TpsBarService {

+    private static final LegacyComponentSerializer LEGACY_SECTION = LegacyComponentSerializer.legacySection();
+    private static final PlainTextComponentSerializer PLAIN_TEXT = PlainTextComponentSerializer.plainText();
    private static final double MAX_TPS = 20.0D;
    private static final int UPDATE_INTERVAL_TICKS = 20;
    private static final BarStyle BAR_STYLE = BarStyle.SEGMENTED_20;
@@ -41,9 +44,9 @@ public final class TpsBarManager implements Listener, TpsBarService {
    private final Map<UUID, BossBar> activeBars = new java.util.HashMap<>();

    private BukkitTask updateTask;
-    private Mode mode;
    private boolean pluginCommandEnabled;
    private boolean nativeCommandAvailable;
+    private boolean nativeDetectionInitialized;
    private String titleFormat;
    private String enabledSelfMessage;
    private String disabledSelfMessage;
@@ -54,12 +57,9 @@ public final class TpsBarManager implements Listener, TpsBarService {
    private String noTargetsMessage;
    private String nativeDetectedMessage;
    private String pluginEnabledMessage;
-    private String pluginForcedButNativeExistsMessage;
-    private String modeChangedReloadMessage;

    public TpsBarManager(EssentialsC plugin) {
        this.plugin = plugin;
-        addConfigDefaults();
        reloadSettings();
    }

@@ -75,11 +75,8 @@ public final class TpsBarManager implements Listener, TpsBarService {

    @Override
    public void reloadSettings() {
-        FileConfiguration config = plugin.getConfig();
        var lang = EssentialsC.getLangManager();
-        Mode previousMode = this.mode;

-        this.mode = Mode.fromString(config.getString("tpsbar.mode", "auto"));
        this.titleFormat = lang.getString("tpsbar.title-format");
        this.enabledSelfMessage = lang.getString("tpsbar.messages.enabled-self");
        this.disabledSelfMessage = lang.getString("tpsbar.messages.disabled-self");
@@ -90,26 +87,15 @@ public final class TpsBarManager implements Listener, TpsBarService {
        this.noTargetsMessage = lang.getString("tpsbar.messages.no-targets");
        this.nativeDetectedMessage = lang.getString("tpsbar.messages.native-detected");
        this.pluginEnabledMessage = lang.getString("tpsbar.messages.plugin-enabled");
-        this.pluginForcedButNativeExistsMessage = lang.getString("tpsbar.messages.plugin-forced-but-native-exists");
-        this.modeChangedReloadMessage = lang.getString("tpsbar.messages.mode-changed-reload");

-        this.nativeCommandAvailable = detectNativeTpsBar();
-        this.pluginCommandEnabled = switch (mode) {
-            case OFF -> false;
-            case AUTO -> !nativeCommandAvailable;
-            case ON -> !nativeCommandAvailable;
-        };
-
-        if (previousMode != null && previousMode != mode) {
-            plugin.getLogger().info(stripColor(modeChangedReloadMessage));
+        if (!nativeDetectionInitialized) {
+            this.nativeCommandAvailable = detectNativeTpsBar();
+            this.nativeDetectionInitialized = true;
        }
+        this.pluginCommandEnabled = !nativeCommandAvailable;

        if (nativeCommandAvailable) {
-            if (mode == Mode.AUTO) {
-                plugin.getLogger().info(stripColor(nativeDetectedMessage));
-            } else if (mode == Mode.ON) {
-                plugin.getLogger().warning(stripColor(pluginForcedButNativeExistsMessage));
-            }
+            plugin.getLogger().info(stripColor(nativeDetectedMessage));
        } else if (pluginCommandEnabled) {
            plugin.getLogger().info(stripColor(pluginEnabledMessage));
        }
@@ -299,11 +285,11 @@ public final class TpsBarManager implements Listener, TpsBarService {
    }

    private String buildTitle(double tps, double mspt, int ping) {
-        return ChatColor.translateAlternateColorCodes('&', applyPlaceholders(titleFormat, Map.of(
+        return applyPlaceholders(titleFormat, Map.of(
            "tps_1m", formatDouble(tps),
            "mspt", formatDouble(mspt),
            "ping", Integer.toString(ping)
-        )));
+        ));
    }

    private BarColor resolveBarColor(double tps, double mspt, int ping) {
@@ -320,21 +306,21 @@ public final class TpsBarManager implements Listener, TpsBarService {
        try {
            CommandMap commandMap = Bukkit.getCommandMap();
            org.bukkit.command.Command command = commandMap.getCommand("tpsbar");
-            return command != null;
+            if (command == null) {
+                return false;
+            }
+            if (command instanceof PluginIdentifiableCommand pluginCommand
+                && pluginCommand.getPlugin().equals(plugin)) {
+                return false;
+            }
+            return !command.getClass().getName().startsWith("cn.infstar.essentialsC.");
        } catch (Exception ignored) {
            return false;
        }
    }

-    private void addConfigDefaults() {
-        FileConfiguration config = plugin.getConfig();
-        config.addDefault("tpsbar.mode", "auto");
-        config.options().copyDefaults(true);
-        plugin.saveConfig();
-    }
-
    private String prefixed(String message) {
-        return EssentialsC.getLangManager().getPrefix() + ChatColor.translateAlternateColorCodes('&', message);
+        return EssentialsC.getLangManager().getPrefix() + message;
    }

    private String applyPlaceholders(String text, Map<String, String> placeholders) {
@@ -346,7 +332,7 @@ public final class TpsBarManager implements Listener, TpsBarService {
    }

    private String stripColor(String message) {
-        return ChatColor.stripColor(ChatColor.translateAlternateColorCodes('&', message));
+        return PLAIN_TEXT.serialize(LEGACY_SECTION.deserialize(message == null ? "" : message));
    }

    private String formatDouble(double value) {
@@ -371,20 +357,4 @@ public final class TpsBarManager implements Listener, TpsBarService {
        return Math.max(min, Math.min(max, value));
    }

-    private enum Mode {
-        OFF,
-        AUTO,
-        ON;
-
-        private static Mode fromString(String value) {
-            if (value == null) {
-                return AUTO;
-            }
-            return switch (value.toLowerCase(Locale.ROOT)) {
-                case "off", "false", "disabled" -> OFF;
-                case "on", "enabled", "plugin" -> ON;
-                default -> AUTO;
-            };
-        }
-    }
 }
@@ -0,0 +1,41 @@
+package cn.infstar.essentialsC.util;
+
+import org.bukkit.configuration.file.FileConfiguration;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.AtomicMoveNotSupportedException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+
+public final class AtomicYamlWriter {
+
+    private AtomicYamlWriter() {
+    }
+
+    public static void save(FileConfiguration configuration, File targetFile) throws IOException {
+        Path target = targetFile.toPath().toAbsolutePath();
+        Path parent = target.toAbsolutePath().getParent();
+        if (parent != null) {
+            Files.createDirectories(parent);
+        }
+
+        String temporaryPrefix = targetFile.getName();
+        if (temporaryPrefix.length() < 3) {
+            temporaryPrefix = (temporaryPrefix + "___").substring(0, 3);
+        }
+        Path temporary = Files.createTempFile(parent, temporaryPrefix, ".tmp");
+        try {
+            Files.writeString(temporary, configuration.saveToString(), StandardCharsets.UTF_8);
+            try {
+                Files.move(temporary, target, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING);
+            } catch (AtomicMoveNotSupportedException ignored) {
+                Files.move(temporary, target, StandardCopyOption.REPLACE_EXISTING);
+            }
+        } finally {
+            Files.deleteIfExists(temporary);
+        }
+    }
+}
@@ -1,5 +1,5 @@
 # EssentialsC 主配置
-# 其他配置：modules.yml、maintenance.yml、skin-bridge.yml、blocks-menu.yml
+# 其他配置：modules.yml、blocks-menu.yml
 # 消息与颜色：lang/<语言>.yml
 # 修改后使用 /essc reload 重载；命令注册状态发生变化时建议重启服务器。

@@ -17,27 +17,18 @@ admin-mode:
  actionbar:
    interval-ticks: 40

-# TPS 状态栏：off（关闭）/ auto（自动检测）/ on（请求启用）
-tpsbar:
-  mode: auto
-
-# JEI 配方同步修复；同时受 modules.yml 中的模块开关控制。
-jei-sync:
-  enabled: true
-  # 玩家加入后延迟多少 tick 检测客户端品牌。
-  brand-check-delay-ticks: 20
-  send-player-message: true
-
 # 生物掉落
 mob-drops:
  enderman:
-    # 允许末影人掉落搬运的方块。
-    enabled: true
+    # 控制该生物死亡时是否掉落物品（经验值正常掉落）；当前仅支持末影人。
+    allow-drops: true

-# TPA 传送请求，行为参考 HuskHomes。
+# TPA 传送请求
 tpa:
  # 请求有效时间，单位为秒。
  timeout-seconds: 60
+  # 每名接收者最多保留的待处理请求数；超出时移除最早请求。
+  max-pending-requests: 5

  # 位置规则
  # /tpa：使用目标接受请求时的位置快照。
@@ -70,3 +61,58 @@ tpa:
    warmup: "block.note_block.banjo"
    cancelled: "entity.item.break"
    complete: "entity.enderman.teleport"
+
+# SkinBridge 外置皮肤站检测与同步；同时受 modules.yml 中的模块开关控制。
+skin-bridge:
+  # 是否加载由 modules.yml 控制；加载前必须填写 MineSkin API Key。
+  # 是否向玩家发送检测与同步结果。
+  send-player-message: true
+  # 是否在控制台记录每次来源检测结果。
+  log-detection-results: true
+  # 玩家加入后延迟多少 tick 开始检测。
+  join-delay-ticks: 20
+  # 检测结果与生成皮肤的内存缓存时间，单位为分钟。
+  cache-minutes: 120
+  # 持久化 MineSkin 纹理缓存的最大条目数，超出时优先清理最早过期的记录。
+  max-generated-cache-entries: 500
+  # 强制刷新同一玩家皮肤的冷却时间，单位为秒。
+  force-refresh-cooldown-seconds: 30
+  # 仅当 Provider 纹理与玩家登录时携带的纹理一致时，才确认其来自该皮肤站。
+  require-current-texture-match: true
+  # 查询皮肤站 Profile 的超时时间，单位为秒。
+  profile-request-timeout-seconds: 5
+
+  # 排除名单中的玩家不会查询皮肤站，也不会修改当前皮肤。
+  exclusions:
+    uuids: []
+    names: []
+
+  mineskin:
+    endpoint: "https://api.mineskin.org"
+    # 只应填写在服务器运行目录中，禁止提交真实密钥。
+    api-key: ""
+    # 可选值：public / unlisted / private
+    visibility: "unlisted"
+    # 等待 MineSkin 队列完成的最长时间，单位为秒。
+    request-timeout-seconds: 30
+    # 两次 MineSkin 生成任务之间的最小间隔，单位为毫秒。
+    minimum-submit-interval-millis: 1000
+
+  # 数值越小，Provider 查询优先级越高；name 会显示在日志和状态命令中。
+  providers:
+    infstar-mc:
+      enabled: true
+      name: "InfstarMC"
+      priority: 10
+      profile-url: "https://skin.infstar.cn/api/yggdrasil/sessionserver/session/minecraft/profile/{uuid}?unsigned=false"
+    littleskin:
+      enabled: true
+      name: "LittleSkin"
+      priority: 20
+      profile-url: "https://littleskin.cn/api/yggdrasil/sessionserver/session/minecraft/profile/{uuid}?unsigned=false"
+    custom-blessing-skin:
+      # 自建 Blessing Skin 示例。启用前请修改 name 和 profile-url。
+      enabled: false
+      name: "Blessing Skin"
+      priority: 30
+      profile-url: "https://skin.example.com/api/yggdrasil/sessionserver/session/minecraft/profile/{uuid}?unsigned=false"
@@ -1,11 +1,12 @@
 # English language file
-# HuskHomes-inspired style: MiniMessage, green success, red errors, gray details.
+# MiniMessage format with green success, red errors, and gray details.

-prefix: ''
+prefix: '<#00FB9A><bold>[EssentialsC]</bold></#00FB9A><gray>: </gray>'

 messages:
  no-permission: '<#FF3300>Error:</#FF3300> <#FF7E5E>You do not have permission to use this command.</#FF7E5E> <gray>Required: {permission}</gray>'
  player-only: '<#FF3300>Error:</#FF3300> <#FF7E5E>This command can only be run by players.</#FF7E5E>'
+  console-name: 'Console'
  config-reloaded: '<#00FB9A>Configuration reloaded.</#00FB9A>'
  version: '<#00FB9A>EssentialsC v{version}</#00FB9A>'
  paper-version: '<gray>Running on Paper {version}</gray>'
@@ -20,16 +21,27 @@ messages:
  suicide-message: '<#FF7E5E>{player} died by suicide.</#FF7E5E>'
  fly-enabled: '<#00FB9A>Flight mode enabled.</#00FB9A>'
  fly-disabled: '<#FF7E5E>Flight mode disabled.</#FF7E5E>'
+  fly-permission-removed: '<#FF7E5E>Your flight permission was removed, so flight mode was disabled.</#FF7E5E>'
  nightvision-enabled: '<#00FB9A>Night vision enabled.</#00FB9A>'
  nightvision-disabled: '<#FF7E5E>Night vision disabled.</#FF7E5E>'
+  nightvision-permission-removed: '<#FF7E5E>Your night vision permission was removed, so night vision was disabled.</#FF7E5E>'
  nightvision-usage: '<#FF3300>Error:</#FF3300> <#FF7E5E>Usage: /nightvision [on|off|toggle]</#FF7E5E>'
  glow-enabled: '<#00FB9A>Glowing enabled.</#00FB9A>'
  glow-disabled: '<#FF7E5E>Glowing disabled.</#FF7E5E>'
+  glow-permission-removed: '<#FF7E5E>Your glowing permission was removed, so glowing was disabled.</#FF7E5E>'
  glow-usage: '<#FF3300>Error:</#FF3300> <#FF7E5E>Usage: /glow [on|off|toggle]</#FF7E5E>'
  vanish-enabled: '<#00FB9A>You are now vanished.</#00FB9A>'
  vanish-disabled: '<#FF7E5E>You are no longer vanished.</#FF7E5E>'
+  vanish-save-failed: '<#FF3300>Error:</#FF3300> <#FF7E5E>Failed to save vanish state; no changes were applied.</#FF7E5E>'
+  vanish-permission-removed: '<#FFC43B>Your vanish permission was removed, so vanish mode was disabled.</#FFC43B>'
  seen-usage: '<#FF3300>Error:</#FF3300> <#FF7E5E>Usage: /seen [player]</#FF7E5E>'
  seen-usage-console: '<#FF3300>Error:</#FF3300> <#FF7E5E>Usage: /seen [player]</#FF7E5E>'
+  seen-header: '<#00FB9A>Player information:</#00FB9A> <white>{player}</white>'
+  seen-status-online: '<gray>Status: <#00FB9A>Online</#00FB9A></gray>'
+  seen-status-offline: '<gray>Status: <#FF7E5E>Offline</#FF7E5E></gray>'
+  seen-world: '<gray>World: <white>{world}</white></gray>'
+  seen-last-online: '<gray>Last online: <white>{time}</white></gray>'
+  seen-first-joined: '<gray>First joined: <white>{time}</white></gray>'
  player-not-found: '<#FF3300>Error:</#FF3300> <#FF7E5E>Could not find the player {player}.</#FF7E5E>'
  no-permission-others: '<#FF3300>Error:</#FF3300> <#FF7E5E>You do not have permission to affect other players.</#FF7E5E>'

@@ -38,9 +50,11 @@ messages:
  heal-self: '<#00FB9A>Your health and hunger have been restored.</#00FB9A>'
  heal-other: '<#00FB9A>You healed <bold>{player}</bold>.</#00FB9A>'
  heal-by-other: '<#00FB9A>You were healed by <bold>{admin}</bold>.</#00FB9A>'
+  heal-usage-console: '<#FF3300>Error:</#FF3300> <#FF7E5E>Usage: /heal [player]</#FF7E5E>'
  feed-self: '<#00FB9A>Your hunger has been restored.</#00FB9A>'
  feed-other: '<#00FB9A>You fed <bold>{player}</bold>.</#00FB9A>'
  feed-by-other: '<#00FB9A>You were fed by <bold>{admin}</bold>.</#00FB9A>'
+  feed-usage-console: '<#FF3300>Error:</#FF3300> <#FF7E5E>Usage: /feed [player]</#FF7E5E>'
  repair-hand-success: '<#00FB9A>Repaired the item in your hand.</#00FB9A>'
  repair-all-success: '<#00FB9A>Repaired <bold>{count}</bold> item(s).</#00FB9A>'
  repair-not-damaged: '<#FF3300>Error:</#FF3300> <#FF7E5E>This item is not damaged.</#FF7E5E>'
@@ -52,9 +66,8 @@ messages:
  mobdrop-toggled: '<#00FB9A>Enderman drops are now {status}.</#00FB9A>'
  shulkerbox-nested: '<#FF3300>Error:</#FF3300> <#FF7E5E>You cannot put a shulker box inside another shulker box.</#FF7E5E>'
  shulkerbox-unstack-first: '<#FF3300>Error:</#FF3300> <#FF7E5E>Please unstack the shulker box before quick opening it.</#FF7E5E>'
-  jei-sync-fabric: '<#00FB9A>Synchronizing recipes for your <bold>Fabric</bold> client…</#00FB9A>'
-  jei-sync-neoforge: '<#00FB9A>Synchronizing recipes for your <bold>NeoForge</bold> client…</#00FB9A>'
-
+  shulkerbox-open-failed: '<#FF3300>Error:</#FF3300> <#FF7E5E>Failed to open the shulker box. Please try again.</#FF7E5E>'
+  shulkerbox-session-invalid: '<#FF3300>Error:</#FF3300> <#FF7E5E>The shulker box session became invalid. Saving was stopped to prevent item duplication.</#FF7E5E>'
 help:
  title: '<#00FB9A><bold>EssentialsC</bold></#00FB9A> <gray>Command Help</gray>'
  version: '<gray>Plugin version: <white>{version}</white></gray>'
@@ -63,6 +76,8 @@ help:
  footer: '<gray>Each command requires the corresponding permission.</gray>'

  commands:
+    reload: '<white>/essc reload</white> <gray>- Reload plugin configuration</gray>'
+    version: '<white>/essc version</white> <gray>- View plugin and server versions</gray>'
    workbench: '<white>/workbench</white> <gray>- Open a crafting table</gray>'
    anvil: '<white>/anvil</white> <gray>- Open an anvil</gray>'
    enchantingtable: '<white>/enchantingtable</white> <gray>- Open an enchanting table</gray>'
@@ -78,10 +93,10 @@ help:
    fly: '<white>/fly</white> <gray>- Toggle flight mode</gray>'
    nightvision: '<white>/nightvision</white> <gray>- Toggle night vision</gray>'
    glow: '<white>/glow</white> <gray>- Toggle glowing</gray>'
-    heal: '<white>/heal</white> <gray>- Restore health and hunger</gray>'
+    heal: '<white>/heal [player]</white> <gray>- Restore health and hunger</gray>'
    vanish: '<white>/vanish</white> <gray>- Toggle vanish mode</gray>'
-    seen: '<white>/seen</white> <gray>- View player information</gray>'
-    feed: '<white>/feed</white> <gray>- Restore hunger</gray>'
+    seen: '<white>/seen [player]</white> <gray>- View player information</gray>'
+    feed: '<white>/feed [player]</white> <gray>- Restore hunger</gray>'
    repair: '<white>/repair</white> <gray>- Repair held or all items</gray>'
    tpa: '<white>/tpa [player]</white> <gray>- Request to teleport to a player</gray>'
    tpahere: '<white>/tpahere [player]</white> <gray>- Request a player teleport to you</gray>'
@@ -92,7 +107,6 @@ help:
    skin: '<white>/essc skin [status|refresh] [player]</white> <gray>- View or refresh SkinBridge status</gray>'
    admin: '<white>/essc admin</white> <gray>- Toggle admin mode</gray>'
    tpsbar: '<white>/tpsbar [player]</white> <gray>- Toggle TPS boss bar</gray>'
-    maintenance: '<white>/maintenance [on|off|status|reload|add|remove|list]</white> <gray>- Manage maintenance mode</gray>'

 tpa:
  messages:
@@ -131,6 +145,7 @@ tpa:
    teleport-failed: '<#FF3300>Error:</#FF3300> <#FF7E5E>Teleportation could not be completed. Please try again.</#FF7E5E>'
    ignore-enabled: '<#00FB9A>Now</#00FB9A> <bold><#00FB9A>ignoring</#00FB9A></bold> <#00FB9A>incoming teleport requests.</#00FB9A>'
    ignore-disabled: '<#00FB9A>Now</#00FB9A> <bold><#00FB9A>listening</#00FB9A></bold> <#00FB9A>to incoming teleport requests.</#00FB9A>'
+    ignore-save-failed: '<#FF3300>Error:</#FF3300> <#FF7E5E>Failed to save the teleport request ignore state; no changes were applied.</#FF7E5E>'
    ignore-notification: '<gray>You are currently ignoring teleport requests.</gray>'
    tpaall-sent: '<#00FB9A>You sent a teleport request to every player asking them to teleport to you.</#00FB9A>'
    tpaall-no-targets: '<#FF3300>Error:</#FF3300> <#FF7E5E>There are no other players online.</#FF7E5E>'
@@ -139,20 +154,25 @@ skin-bridge:
  notifications:
    detecting: '<#00FB9A>Detecting your skin source…</#00FB9A>'
    synced: '<#00FB9A>Skin synchronized through <bold>{provider}</bold>.</#00FB9A>'
+    excluded: '<gray>You are excluded from SkinBridge detection; your current skin was kept.</gray>'
+    queue-full: '<#FFC43B>Skin detection is busy; this check was skipped.</#FFC43B>'
    not-external: '<gray>No external skin provider matched; your current skin was kept.</gray>'
    failed: '<#FF3300>Error:</#FF3300> <#FF7E5E>Skin detection or synchronization failed. Please try again later.</#FF7E5E>'
  messages:
    usage: '<#FF3300>Error:</#FF3300> <#FF7E5E>Usage: /essc skin [status|refresh] [player]</#FF7E5E>'
-    feature-disabled: '<#FF3300>Error:</#FF3300> <#FF7E5E>SkinBridge is disabled in skin-bridge.yml.</#FF7E5E>'
-    dependency-missing: '<#FF3300>Error:</#FF3300> <#FF7E5E>No valid MineSkin API key is configured in skin-bridge.yml.</#FF7E5E>'
+    dependency-missing: '<#FF3300>Error:</#FF3300> <#FF7E5E>No valid MineSkin API key is configured in config.yml.</#FF7E5E>'
    no-providers: '<#FF3300>Error:</#FF3300> <#FF7E5E>No valid SkinBridge provider is enabled.</#FF7E5E>'
    status-external: '<#00FB9A>{player} is identified as an external skin provider player.</#00FB9A> <gray>Provider: <white>{provider}</white></gray>'
+    status-excluded: '<gray>{player} is excluded from SkinBridge detection.</gray>'
    status-not-external: '<gray>{player} does not match any configured external skin provider.</gray>'
    status-pending: '<#FFC43B>SkinBridge is still detecting {player}''s login source.</#FFC43B>'
    status-unknown: '<gray>{player} has not been checked by SkinBridge yet.</gray>'
    refresh-queued: '<#00FB9A>SkinBridge is detecting and refreshing {player}''s skin.</#00FB9A>'
    refresh-cached: '<gray>{player} is using a valid skin cache entry.</gray>'
    refresh-running: '<#FFC43B>SkinBridge is already processing {player}.</#FFC43B>'
+    refresh-excluded: '<gray>{player} is excluded from SkinBridge detection; no skin was changed.</gray>'
+    refresh-cooldown: '<#FFC43B>Wait {seconds} seconds before refreshing {player} again.</#FFC43B>'
+    queue-full: '<#FFC43B>The SkinBridge lookup queue is full. Please try again later.</#FFC43B>'

 blocks-menu:
  title: '<#00FB9A><bold>Shortcut Menu</bold></#00FB9A>'
@@ -214,6 +234,7 @@ admin-mode:
    enabled: '<#00FB9A>Admin mode enabled; normal inventory has been saved.</#00FB9A>'
    disabled: '<#FF7E5E>Admin mode disabled; normal inventory has been restored.</#FF7E5E>'
    crash-restored: '<#FFC43B>The previous admin mode session has been restored safely.</#FFC43B>'
+    save-failed: '<#FF3300>Error:</#FF3300> <#FF7E5E>Could not safely save your inventory; admin mode was not enabled.</#FF7E5E>'

 tpsbar:
  title-format: '<#00FB9A>TPS</#00FB9A><gray>: {tps_1m} | </gray><#00FB9A>MSPT</#00FB9A><gray>: {mspt} | </gray><#00FB9A>Ping</#00FB9A><gray>: {ping}</gray>'
@@ -227,8 +248,6 @@ tpsbar:
    no-targets: '<#FF3300>Error:</#FF3300> <#FF7E5E>No matching players were found to toggle.</#FF7E5E>'
    native-detected: '<gray>Detected a native /tpsbar command on this server; skipped plugin implementation.</gray>'
    plugin-enabled: '<gray>No native /tpsbar command was detected; plugin implementation enabled.</gray>'
-    plugin-forced-but-native-exists: '<#FFC43B>The configuration requests the plugin TPSBar, but a native /tpsbar already exists, so the plugin implementation was skipped to avoid conflicts.</#FFC43B>'
-    mode-changed-reload: '<#FFC43B>TPSBar mode has been updated, but command registration changes require a server restart to fully take effect.</#FFC43B>'

 mobdrops-menu:
  title: '<#00FB9A><bold>Mob Drop Control</bold></#00FB9A>'
@@ -239,23 +258,3 @@ mobdrops-menu:
    name: '<#00FB9A>Enderman Drops</#00FB9A>'
    status: '<gray>Current status: {status}</gray>'
    toggle: '<gray>Click to toggle</gray>'
-
-maintenance:
-  status:
-    enabled: '<#FF7E5E>Enabled</#FF7E5E>'
-    disabled: '<#00FB9A>Disabled</#00FB9A>'
-  messages:
-    enabled: '<#00FB9A>Maintenance mode enabled.</#00FB9A>'
-    disabled: '<#FF7E5E>Maintenance mode disabled.</#FF7E5E>'
-    reloaded: '<#00FB9A>Maintenance configuration reloaded.</#00FB9A>'
-    status: '<gray>Maintenance mode status: {status} | Whitelist: <white>{whitelist_count}</white></gray>'
-    usage: '<#FF3300>Error:</#FF3300> <#FF7E5E>Usage: /maintenance [on|off|status|reload|add|remove|list]</#FF7E5E>'
-    add-usage: '<#FF3300>Error:</#FF3300> <#FF7E5E>Usage: /maintenance add [player|uuid]</#FF7E5E>'
-    remove-usage: '<#FF3300>Error:</#FF3300> <#FF7E5E>Usage: /maintenance remove [player|uuid]</#FF7E5E>'
-    whitelist-added: '<#00FB9A>Added {player} to the maintenance whitelist.</#00FB9A>'
-    whitelist-removed: '<#00FB9A>Removed {player} from the maintenance whitelist.</#00FB9A>'
-    whitelist-exists: '<#FFC43B>{player} is already on the maintenance whitelist.</#FFC43B>'
-    whitelist-missing: '<#FF3300>Error:</#FF3300> <#FF7E5E>{player} is not on the maintenance whitelist.</#FF7E5E>'
-    whitelist-empty: '<gray>The maintenance whitelist is empty.</gray>'
-    whitelist-list: '<gray>Maintenance whitelist ({count}): <white>{entries}</white></gray>'
-    login-blocked: '<#FFC43B>{player} was blocked by maintenance mode.</#FFC43B> <gray>UUID: {uuid} | IP: {address}</gray>'
@@ -1,11 +1,12 @@
 # 简体中文语言文件
-# 文本风格参考 HuskHomes：MiniMessage、绿色成功、红色错误、灰色说明。
+# 支持 MiniMessage 格式，默认使用绿色成功、红色错误和灰色说明。

-prefix: ''
+prefix: '<#00FB9A><bold>[EssentialsC]</bold></#00FB9A><gray>: </gray>'

 messages:
  no-permission: '<#FF3300>错误:</#FF3300> <#FF7E5E>你没有权限执行此命令.</#FF7E5E> <gray>需要权限: {permission}</gray>'
  player-only: '<#FF3300>错误:</#FF3300> <#FF7E5E>此命令只能由玩家执行.</#FF7E5E>'
+  console-name: '控制台'
  config-reloaded: '<#00FB9A>配置已重载.</#00FB9A>'
  version: '<#00FB9A>EssentialsC v{version}</#00FB9A>'
  paper-version: '<gray>当前运行于 Paper {version}</gray>'
@@ -20,16 +21,27 @@ messages:
  suicide-message: '<#FF7E5E>{player} 自杀了.</#FF7E5E>'
  fly-enabled: '<#00FB9A>飞行模式已开启.</#00FB9A>'
  fly-disabled: '<#FF7E5E>飞行模式已关闭.</#FF7E5E>'
+  fly-permission-removed: '<#FF7E5E>你的飞行权限已被移除，飞行模式已关闭.</#FF7E5E>'
  nightvision-enabled: '<#00FB9A>夜视已开启.</#00FB9A>'
  nightvision-disabled: '<#FF7E5E>夜视已关闭.</#FF7E5E>'
+  nightvision-permission-removed: '<#FF7E5E>你的夜视权限已被移除，夜视已关闭.</#FF7E5E>'
  nightvision-usage: '<#FF3300>错误:</#FF3300> <#FF7E5E>用法: /nightvision [on|off|toggle]</#FF7E5E>'
  glow-enabled: '<#00FB9A>发光已开启.</#00FB9A>'
  glow-disabled: '<#FF7E5E>发光已关闭.</#FF7E5E>'
+  glow-permission-removed: '<#FF7E5E>你的发光权限已被移除，发光已关闭.</#FF7E5E>'
  glow-usage: '<#FF3300>错误:</#FF3300> <#FF7E5E>用法: /glow [on|off|toggle]</#FF7E5E>'
  vanish-enabled: '<#00FB9A>你已进入隐身模式.</#00FB9A>'
  vanish-disabled: '<#FF7E5E>你已退出隐身模式.</#FF7E5E>'
+  vanish-save-failed: '<#FF3300>错误:</#FF3300> <#FF7E5E>无法保存隐身状态，本次操作未生效.</#FF7E5E>'
+  vanish-permission-removed: '<#FFC43B>你的隐身权限已被移除,隐身模式已自动关闭.</#FFC43B>'
  seen-usage: '<#FF3300>错误:</#FF3300> <#FF7E5E>用法: /seen [玩家]</#FF7E5E>'
  seen-usage-console: '<#FF3300>错误:</#FF3300> <#FF7E5E>用法: /seen [玩家]</#FF7E5E>'
+  seen-header: '<#00FB9A>玩家信息:</#00FB9A> <white>{player}</white>'
+  seen-status-online: '<gray>状态: <#00FB9A>在线</#00FB9A></gray>'
+  seen-status-offline: '<gray>状态: <#FF7E5E>离线</#FF7E5E></gray>'
+  seen-world: '<gray>所在世界: <white>{world}</white></gray>'
+  seen-last-online: '<gray>最后在线: <white>{time}</white></gray>'
+  seen-first-joined: '<gray>首次加入: <white>{time}</white></gray>'
  player-not-found: '<#FF3300>错误:</#FF3300> <#FF7E5E>没有找到玩家 {player}.</#FF7E5E>'
  no-permission-others: '<#FF3300>错误:</#FF3300> <#FF7E5E>你没有权限影响其他玩家.</#FF7E5E>'

@@ -38,9 +50,11 @@ messages:
  heal-self: '<#00FB9A>你的生命值和饥饿值已恢复.</#00FB9A>'
  heal-other: '<#00FB9A>你已治疗玩家 <bold>{player}</bold>.</#00FB9A>'
  heal-by-other: '<#00FB9A>管理员 <bold>{admin}</bold> 治疗了你.</#00FB9A>'
+  heal-usage-console: '<#FF3300>错误:</#FF3300> <#FF7E5E>用法: /heal [玩家]</#FF7E5E>'
  feed-self: '<#00FB9A>你的饥饿值已恢复.</#00FB9A>'
  feed-other: '<#00FB9A>你已喂饱玩家 <bold>{player}</bold>.</#00FB9A>'
  feed-by-other: '<#00FB9A>管理员 <bold>{admin}</bold> 喂饱了你.</#00FB9A>'
+  feed-usage-console: '<#FF3300>错误:</#FF3300> <#FF7E5E>用法: /feed [玩家]</#FF7E5E>'
  repair-hand-success: '<#00FB9A>手中物品已修复.</#00FB9A>'
  repair-all-success: '<#00FB9A>已修复 <bold>{count}</bold> 个物品.</#00FB9A>'
  repair-not-damaged: '<#FF3300>错误:</#FF3300> <#FF7E5E>该物品没有损坏.</#FF7E5E>'
@@ -52,9 +66,8 @@ messages:
  mobdrop-toggled: '<#00FB9A>末影人掉落已切换为 {status}.</#00FB9A>'
  shulkerbox-nested: '<#FF3300>错误:</#FF3300> <#FF7E5E>不能将潜影盒放入另一个潜影盒.</#FF7E5E>'
  shulkerbox-unstack-first: '<#FF3300>错误:</#FF3300> <#FF7E5E>请先将潜影盒拆分为单个后再快捷打开.</#FF7E5E>'
-  jei-sync-fabric: '<#00FB9A>正在为 <bold>Fabric</bold> 客户端同步配方…</#00FB9A>'
-  jei-sync-neoforge: '<#00FB9A>正在为 <bold>NeoForge</bold> 客户端同步配方…</#00FB9A>'
-
+  shulkerbox-open-failed: '<#FF3300>错误:</#FF3300> <#FF7E5E>潜影盒打开失败，请稍后重试.</#FF7E5E>'
+  shulkerbox-session-invalid: '<#FF3300>错误:</#FF3300> <#FF7E5E>潜影盒会话异常，已停止保存以避免物品复制.</#FF7E5E>'
 help:
  title: '<#00FB9A><bold>EssentialsC</bold></#00FB9A> <gray>命令帮助</gray>'
  version: '<gray>插件版本: <white>{version}</white></gray>'
@@ -63,6 +76,8 @@ help:
  footer: '<gray>每个命令都需要对应权限.</gray>'

  commands:
+    reload: '<white>/essc reload</white> <gray>- 重载插件配置</gray>'
+    version: '<white>/essc version</white> <gray>- 查看插件与服务端版本</gray>'
    workbench: '<white>/workbench</white> <gray>- 打开工作台</gray>'
    anvil: '<white>/anvil</white> <gray>- 打开铁砧</gray>'
    enchantingtable: '<white>/enchantingtable</white> <gray>- 打开附魔台</gray>'
@@ -78,10 +93,10 @@ help:
    fly: '<white>/fly</white> <gray>- 切换飞行模式</gray>'
    nightvision: '<white>/nightvision</white> <gray>- 切换夜视</gray>'
    glow: '<white>/glow</white> <gray>- 切换发光</gray>'
-    heal: '<white>/heal</white> <gray>- 恢复生命值和饥饿值</gray>'
+    heal: '<white>/heal [玩家]</white> <gray>- 恢复生命值和饥饿值</gray>'
    vanish: '<white>/vanish</white> <gray>- 切换隐身模式</gray>'
-    seen: '<white>/seen</white> <gray>- 查看玩家信息</gray>'
-    feed: '<white>/feed</white> <gray>- 恢复饥饿值</gray>'
+    seen: '<white>/seen [玩家]</white> <gray>- 查看玩家信息</gray>'
+    feed: '<white>/feed [玩家]</white> <gray>- 恢复饥饿值</gray>'
    repair: '<white>/repair</white> <gray>- 修复手中或全部物品</gray>'
    tpa: '<white>/tpa [玩家]</white> <gray>- 请求传送到玩家身边</gray>'
    tpahere: '<white>/tpahere [玩家]</white> <gray>- 请求玩家传送到你身边</gray>'
@@ -92,7 +107,6 @@ help:
    skin: '<white>/essc skin [status|refresh] [玩家]</white> <gray>- 查看或刷新皮肤桥接状态</gray>'
    admin: '<white>/essc admin</white> <gray>- 切换管理模式</gray>'
    tpsbar: '<white>/tpsbar [玩家]</white> <gray>- 切换 TPS 状态栏</gray>'
-    maintenance: '<white>/maintenance [on|off|status|reload|add|remove|list]</white> <gray>- 管理维护模式</gray>'

 tpa:
  messages:
@@ -131,6 +145,7 @@ tpa:
    teleport-failed: '<#FF3300>错误:</#FF3300> <#FF7E5E>无法完成传送,请稍后重试</#FF7E5E>'
    ignore-enabled: '<#00FB9A>你已</#00FB9A> <bold><#00FB9A>忽略</#00FB9A></bold> <#00FB9A>传送请求</#00FB9A>'
    ignore-disabled: '<#00FB9A>你已</#00FB9A> <bold><#00FB9A>恢复接收</#00FB9A></bold> <#00FB9A>传送请求</#00FB9A>'
+    ignore-save-failed: '<#FF3300>错误:</#FF3300> <#FF7E5E>无法保存传送请求忽略状态，本次操作未生效.</#FF7E5E>'
    ignore-notification: '<gray>你当前正在忽略传送请求.</gray>'
    tpaall-sent: '<#00FB9A>你已向所有玩家发送传送请求,请求他们传送到你的位置</#00FB9A>'
    tpaall-no-targets: '<#FF3300>错误:</#FF3300> <#FF7E5E>当前没有其他在线玩家.</#FF7E5E>'
@@ -139,20 +154,25 @@ skin-bridge:
  notifications:
    detecting: '<#00FB9A>正在检测你的皮肤来源…</#00FB9A>'
    synced: '<#00FB9A>已通过 <bold>{provider}</bold> 同步皮肤.</#00FB9A>'
+    excluded: '<gray>你位于 SkinBridge 排除名单中,已保留当前皮肤.</gray>'
+    queue-full: '<#FFC43B>当前皮肤检测任务较多,已跳过本次检测.</#FFC43B>'
    not-external: '<gray>未匹配外置皮肤站,已保留当前皮肤.</gray>'
    failed: '<#FF3300>错误:</#FF3300> <#FF7E5E>皮肤检测或同步失败,请稍后重试.</#FF7E5E>'
  messages:
    usage: '<#FF3300>错误:</#FF3300> <#FF7E5E>用法: /essc skin [status|refresh] [玩家]</#FF7E5E>'
-    feature-disabled: '<#FF3300>错误:</#FF3300> <#FF7E5E>SkinBridge 在 skin-bridge.yml 中未启用.</#FF7E5E>'
-    dependency-missing: '<#FF3300>错误:</#FF3300> <#FF7E5E>未在 skin-bridge.yml 中配置有效的 MineSkin API Key.</#FF7E5E>'
+    dependency-missing: '<#FF3300>错误:</#FF3300> <#FF7E5E>未在 config.yml 中配置有效的 MineSkin API Key.</#FF7E5E>'
    no-providers: '<#FF3300>错误:</#FF3300> <#FF7E5E>没有启用有效的 SkinBridge Provider.</#FF7E5E>'
    status-external: '<#00FB9A>{player} 已识别为外置皮肤站玩家.</#00FB9A> <gray>Provider: <white>{provider}</white></gray>'
+    status-excluded: '<gray>{player} 位于 SkinBridge 排除名单中.</gray>'
    status-not-external: '<gray>{player} 未匹配任何已配置的外置皮肤站.</gray>'
    status-pending: '<#FFC43B>{player} 的皮肤站来源正在检测中.</#FFC43B>'
    status-unknown: '<gray>{player} 尚未进行 SkinBridge 检测.</gray>'
    refresh-queued: '<#00FB9A>已开始重新检测并刷新 {player} 的皮肤.</#00FB9A>'
    refresh-cached: '<gray>{player} 正在使用有效的皮肤缓存.</gray>'
    refresh-running: '<#FFC43B>{player} 的皮肤检测任务仍在运行.</#FFC43B>'
+    refresh-excluded: '<gray>{player} 位于 SkinBridge 排除名单中,未修改皮肤.</gray>'
+    refresh-cooldown: '<#FFC43B>请等待 {seconds} 秒后再刷新 {player} 的皮肤.</#FFC43B>'
+    queue-full: '<#FFC43B>SkinBridge 查询队列已满,请稍后重试.</#FFC43B>'

 blocks-menu:
  title: '<#00FB9A><bold>便捷菜单</bold></#00FB9A>'
@@ -214,6 +234,7 @@ admin-mode:
    enabled: '<#00FB9A>管理模式已开启,普通背包已保存.</#00FB9A>'
    disabled: '<#FF7E5E>管理模式已关闭,普通背包已恢复.</#FF7E5E>'
    crash-restored: '<#FFC43B>上一次管理模式会话已安全恢复.</#FFC43B>'
+    save-failed: '<#FF3300>错误:</#FF3300> <#FF7E5E>无法安全保存当前背包,管理模式未开启.</#FF7E5E>'

 tpsbar:
  title-format: '<#00FB9A>TPS</#00FB9A><gray>: {tps_1m} | </gray><#00FB9A>MSPT</#00FB9A><gray>: {mspt} | </gray><#00FB9A>Ping</#00FB9A><gray>: {ping}</gray>'
@@ -227,8 +248,6 @@ tpsbar:
    no-targets: '<#FF3300>错误:</#FF3300> <#FF7E5E>没有匹配到可切换的玩家.</#FF7E5E>'
    native-detected: '<gray>检测到服务端已内置 /tpsbar,已跳过插件实现.</gray>'
    plugin-enabled: '<gray>未检测到服务端内置 /tpsbar,已启用插件实现.</gray>'
-    plugin-forced-but-native-exists: '<#FFC43B>配置要求启用插件版 TPSBar,但服务端已存在原生 /tpsbar,已跳过插件实现以避免冲突.</#FFC43B>'
-    mode-changed-reload: '<#FFC43B>TPSBar 模式已更新,但命令注册状态需要重启服务器后才会完全生效.</#FFC43B>'

 mobdrops-menu:
  title: '<#00FB9A><bold>生物掉落控制</bold></#00FB9A>'
@@ -239,23 +258,3 @@ mobdrops-menu:
    name: '<#00FB9A>末影人掉落</#00FB9A>'
    status: '<gray>当前状态: {status}</gray>'
    toggle: '<gray>点击切换</gray>'
-
-maintenance:
-  status:
-    enabled: '<#FF7E5E>开启</#FF7E5E>'
-    disabled: '<#00FB9A>关闭</#00FB9A>'
-  messages:
-    enabled: '<#00FB9A>维护模式已开启.</#00FB9A>'
-    disabled: '<#FF7E5E>维护模式已关闭.</#FF7E5E>'
-    reloaded: '<#00FB9A>维护模式配置已重载.</#00FB9A>'
-    status: '<gray>维护模式当前状态: {status} | 白名单: <white>{whitelist_count}</white></gray>'
-    usage: '<#FF3300>错误:</#FF3300> <#FF7E5E>用法: /maintenance [on|off|status|reload|add|remove|list]</#FF7E5E>'
-    add-usage: '<#FF3300>错误:</#FF3300> <#FF7E5E>用法: /maintenance add [玩家|UUID]</#FF7E5E>'
-    remove-usage: '<#FF3300>错误:</#FF3300> <#FF7E5E>用法: /maintenance remove [玩家|UUID]</#FF7E5E>'
-    whitelist-added: '<#00FB9A>已将 {player} 加入维护白名单.</#00FB9A>'
-    whitelist-removed: '<#00FB9A>已将 {player} 移出维护白名单.</#00FB9A>'
-    whitelist-exists: '<#FFC43B>{player} 已在维护白名单中.</#FFC43B>'
-    whitelist-missing: '<#FF3300>错误:</#FF3300> <#FF7E5E>{player} 不在维护白名单中.</#FF7E5E>'
-    whitelist-empty: '<gray>维护白名单为空.</gray>'
-    whitelist-list: '<gray>维护白名单 ({count}): <white>{entries}</white></gray>'
-    login-blocked: '<#FFC43B>{player} 被维护模式拦截.</#FFC43B> <gray>UUID: {uuid} | IP: {address}</gray>'
@@ -1,43 +0,0 @@
-# EssentialsC 维护模式配置
-
-config-version: 1
-
-# 是否开启维护模式。
-enabled: false
-
-# 拥有该权限的玩家可以在维护模式下进入服务器。
-bypass-permission: "essentialsc.maintenance.bypass"
-
-notify:
-  # 玩家因维护模式被拒绝进入时，是否通知在线管理员。
-  enabled: true
-  # 拥有该权限的在线玩家会收到拦截通知。
-  permission: "essentialsc.maintenance.notify"
-
-whitelist:
-  # 这些 UUID 可以在维护模式下进入服务器。
-  uuids: []
-  # 这些玩家名可以在维护模式下进入服务器。大小写不敏感。
-  names: []
-
-motd:
-  # 维护模式开启时是否替换服务器列表 MOTD。
-  enabled: true
-  lines:
-    - "&c服务器维护中"
-    - "&7请稍后再试"
-
-kick-message:
-  - "&c服务器正在维护"
-  - "&7请稍后再进入"
-
-bossbar:
-  # 维护模式开启时是否向无绕过权限的在线玩家显示 BossBar。
-  enabled: true
-  title: "&c服务器正在维护"
-  # 可选值：PINK / BLUE / RED / GREEN / YELLOW / PURPLE / WHITE
-  color: RED
-  # 可选值：SOLID / SEGMENTED_6 / SEGMENTED_10 / SEGMENTED_12 / SEGMENTED_20
-  style: SOLID
-  # 进度范围：0.0 - 1.0
-  progress: 1.0
@@ -1,7 +1,7 @@
 # EssentialsC 模块配置
 #
 # modules.yml 用于控制功能模块是否在运行时加载。
-# 各功能的详细设置位于 config.yml 及对应的独立功能配置文件。
+# 各功能的详细设置位于 config.yml 与 blocks-menu.yml。
 #
 # 修改模块开关后可使用 /essc reload 刷新运行期服务和监听器。
 # 直连命令的完整热增删仍建议通过重启服务器完成。
@@ -12,24 +12,15 @@ modules:
  blocks:
    # 工作台、铁砧等便捷方块命令、/essc blocks 菜单和潜影盒快捷打开。
    enabled: true
-  player:
-    # 玩家常用命令：飞行、夜视、发光、治疗、喂食、修复、帽子、自杀、隐身、查询玩家和 TPA。
-    enabled: true
  admin-mode:
    # /essc admin 管理模式，以及独立背包和状态管理。
    enabled: true
  tpsbar:
-    # 插件版 TPSBar。config.yml 中的 tpsbar.mode 仍会决定遇到原生 /tpsbar 时的行为。
-    enabled: true
-  jei-sync:
-    # Fabric / NeoForge JEI 配方同步兼容修复。
+    # 插件版 TPSBar。检测到服务端原生命令时会自动避免冲突。
    enabled: true
  mob-drops:
-    # 末影人掉落控制菜单和监听器。默认关闭，用于保留过去标准版的行为。
+    # 末影人掉落控制菜单和监听器；具体掉落状态可在游戏内切换。
    enabled: false
-  maintenance:
-    # 维护模式。开启维护后可替换 MOTD，并阻止无绕过权限的玩家进入。
-    enabled: true
  skin-bridge:
    # 查询外置 Yggdrasil profile，并通过 MineSkin 与 Paper Profile API 同步皮肤。
    enabled: false
@@ -1,9 +1,9 @@
 name: EssentialsC
-description: 适用于 Paper 服务端的轻量基础功能插件。
+description: 高版本基础工具箱
 version: ${version}

 main: cn.infstar.essentialsC.EssentialsC
-api-version: '1.21'
+api-version: '1.21.11'
 load: POSTWORLD
 folia-supported: false

@@ -62,6 +62,9 @@ permissions:
  essentialsc.command.vanish:
    description: 允许使用 /vanish
    default: op
+  essentialsc.vanish.see:
+    description: 允许看见隐身玩家
+    default: op
  essentialsc.command.seen:
    description: 允许使用 /seen
    default: op
@@ -116,23 +119,27 @@ permissions:
  essentialsc.command.tpsbar.others:
    description: 允许为其他玩家切换 /tpsbar
    default: op
-  essentialsc.command.maintenance:
-    description: 允许管理维护模式
-    default: op
  essentialsc.command.skin:
-    description: 允许管理 SkinBridge 状态与刷新
+    description: 允许使用 SkinBridge 管理命令
    default: op
-  essentialsc.maintenance.bypass:
-    description: 允许在维护模式下进入服务器
+    children:
+      essentialsc.command.skin.status: true
+      essentialsc.command.skin.refresh: true
+      essentialsc.command.skin.others: true
+  essentialsc.command.skin.status:
+    description: 允许查看 SkinBridge 状态
    default: op
-  essentialsc.maintenance.notify:
-    description: 允许接收维护模式拦截通知
+  essentialsc.command.skin.refresh:
+    description: 允许强制刷新自己的皮肤
+    default: op
+  essentialsc.command.skin.others:
+    description: 允许查看或刷新其他玩家的皮肤
    default: op
  essentialsc.shulkerbox.open:
    description: 允许通过 Shift+右键快捷打开潜影盒
    default: op
  essentialsc.mobdrops.enderman:
-    description: 允许控制末影人掉落方块
+    description: 允许控制末影人死亡时是否掉落物品
    default: op
  essentialsc.*:
    description: 授予 EssentialsC 的全部权限
@@ -155,6 +162,7 @@ permissions:
      essentialsc.command.heal: true
      essentialsc.command.heal.others: true
      essentialsc.command.vanish: true
+      essentialsc.vanish.see: true
      essentialsc.command.seen: true
      essentialsc.command.feed: true
      essentialsc.command.feed.others: true
@@ -173,9 +181,9 @@ permissions:
      essentialsc.command.reload: true
      essentialsc.command.tpsbar: true
      essentialsc.command.tpsbar.others: true
-      essentialsc.command.maintenance: true
      essentialsc.command.skin: true
-      essentialsc.maintenance.bypass: true
-      essentialsc.maintenance.notify: true
+      essentialsc.command.skin.status: true
+      essentialsc.command.skin.refresh: true
+      essentialsc.command.skin.others: true
      essentialsc.shulkerbox.open: true
      essentialsc.mobdrops.enderman: true
@@ -1,64 +0,0 @@
-# ============================================================================
-# EssentialsC - SkinBridge 配置
-# ============================================================================
-# 模块总开关位于 modules.yml：modules.skin-bridge.enabled
-# 本文件控制 SkinBridge 内部行为。修改后使用 /essc reload 重载。
-
-config-version: 1
-
-# ----------------------------------------------------------------------------
-# 基础设置
-# ----------------------------------------------------------------------------
-
-# 是否启用外置皮肤站检测与皮肤同步。
-enabled: false
-
-# 是否在玩家加入时发送检测与同步结果提示。
-send-player-message: true
-
-# 玩家加入后延迟多少 tick 开始检测，避免登录资料尚未稳定。
-join-delay-ticks: 20
-
-# 玩家登录来源与生成皮肤的内存缓存时间，单位为分钟。
-cache-minutes: 120
-
-# 查询皮肤站 Yggdrasil Profile 的超时时间，单位为秒。
-profile-request-timeout-seconds: 5
-
-# ----------------------------------------------------------------------------
-# MineSkin v2
-# ----------------------------------------------------------------------------
-
-mineskin:
-  # API 地址，一般不需要修改。
-  endpoint: "https://api.mineskin.org"
-
-  # MineSkin API Key。只应填写在服务器运行目录，禁止提交到公开仓库。
-  api-key: ""
-
-  # 生成结果可见性：public / unlisted / private
-  visibility: "unlisted"
-
-  # 等待 MineSkin 队列完成的最长时间，单位为秒。
-  request-timeout-seconds: 30
-
-# ----------------------------------------------------------------------------
-# 外置皮肤站 Provider
-# ----------------------------------------------------------------------------
-# 每个一级子节点代表一个皮肤站，节点名称可自由修改，并显示在日志与
-# /essc skin status 中。建议只使用小写英文、数字和连字符，不要使用点号。
-#
-# 可用占位符：
-#   {uuid}        无连字符 UUID
-#   {uuid-dashed} 标准带连字符 UUID
-
-providers:
-  littleskin:
-    enabled: false
-    priority: 10
-    profile-url: "https://littleskin.cn/api/yggdrasil/sessionserver/session/minecraft/profile/{uuid}?unsigned=false"
-
-  my-blessing-skin:
-    enabled: false
-    priority: 20
-    profile-url: "https://skin.example.com/api/yggdrasil/sessionserver/session/minecraft/profile/{uuid}?unsigned=false"
@@ -0,0 +1,111 @@
+package cn.infstar.essentialsC;
+
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.junit.jupiter.api.Test;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
+
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ConfigurationResourcesTest {
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+        "config.yml",
+        "modules.yml",
+        "blocks-menu.yml",
+        "paper-plugin.yml",
+        "lang/zh_CN.yml",
+        "lang/en_US.yml"
+    })
+    void bundledYamlIsValid(String resourcePath) throws Exception {
+        try (InputStream input = getClass().getClassLoader().getResourceAsStream(resourcePath)) {
+            assertNotNull(input, resourcePath);
+            YamlConfiguration configuration = new YamlConfiguration();
+            configuration.load(new InputStreamReader(input, StandardCharsets.UTF_8));
+
+            if (resourcePath.equals("config.yml")) {
+                assertEquals(2, configuration.getInt("config-version"));
+                assertEquals(5, configuration.getInt("tpa.max-pending-requests"));
+                assertEquals(500, configuration.getInt("skin-bridge.max-generated-cache-entries"));
+                assertTrue(configuration.getString("skin-bridge.mineskin.api-key", "").isBlank());
+            }
+            if (resourcePath.equals("paper-plugin.yml")) {
+                assertEquals("1.21.11", configuration.getString("api-version"));
+            }
+            if (resourcePath.startsWith("lang/")) {
+                assertTrue(!configuration.getString("prefix", "").isBlank());
+            }
+        }
+    }
+
+    @Test
+    void bundledLanguagesContainTheSameKeys() throws Exception {
+        YamlConfiguration chinese = loadResource("lang/zh_CN.yml");
+        YamlConfiguration english = loadResource("lang/en_US.yml");
+
+        assertEquals(chinese.getKeys(true), english.getKeys(true));
+    }
+
+    @Test
+    void retiredJeiFeatureIsAbsentFromResources() throws Exception {
+        assertFalse(loadResource("config.yml").contains("jei-sync", true));
+        assertFalse(loadResource("modules.yml").contains("modules.jei-sync", true));
+        assertFalse(loadResource("lang/zh_CN.yml").contains("messages.jei-sync-fabric", true));
+        assertFalse(loadResource("lang/zh_CN.yml").contains("messages.jei-sync-neoforge", true));
+        assertFalse(loadResource("lang/en_US.yml").contains("messages.jei-sync-fabric", true));
+        assertFalse(loadResource("lang/en_US.yml").contains("messages.jei-sync-neoforge", true));
+    }
+
+    @Test
+    void retiredMaintenanceFeatureIsAbsentFromResources() throws Exception {
+        assertNull(getClass().getClassLoader().getResource("maintenance.yml"));
+        assertFalse(loadResource("modules.yml").contains("modules.maintenance", true));
+        assertFalse(loadResource("paper-plugin.yml").contains("dependencies.server.LuckPerms", true));
+        assertFalse(loadResource("paper-plugin.yml").contains("permissions.essentialsc.command.maintenance", true));
+        assertFalse(loadResource("paper-plugin.yml").contains("permissions.essentialsc.maintenance.bypass", true));
+        assertFalse(loadResource("paper-plugin.yml").contains("permissions.essentialsc.maintenance.notify", true));
+        assertFalse(loadResource("lang/zh_CN.yml").contains("maintenance", true));
+        assertFalse(loadResource("lang/en_US.yml").contains("maintenance", true));
+        assertNull(cn.infstar.essentialsC.commands.CommandRegistry.resolveCommandName("maintenance"));
+        assertNull(cn.infstar.essentialsC.commands.CommandRegistry.resolveCommandName("maint"));
+    }
+
+    @Test
+    void miniMessageTagNamesAreNormalized() {
+        assertEquals("<gray>文本</gray>", LangManager.normalizeMiniMessageTags("<GRAY>文本</GRAY>"));
+        assertEquals("\\<GRAY>", LangManager.normalizeMiniMessageTags("\\<GRAY>"));
+    }
+
+    @Test
+    void legacyFormattingCanBeNestedInMiniMessage() {
+        String message = LangManager.applyPlaceholders(
+            "<gray>维护状态: {status}</gray>",
+            java.util.Map.of("status", "§a开启")
+        );
+        String rendered = PlainTextComponentSerializer.plainText().serialize(
+            MiniMessage.miniMessage().deserialize(message)
+        );
+
+        assertEquals("维护状态: 开启", rendered);
+    }
+
+    private YamlConfiguration loadResource(String resourcePath) throws Exception {
+        try (InputStream input = getClass().getClassLoader().getResourceAsStream(resourcePath)) {
+            assertNotNull(input, resourcePath);
+            YamlConfiguration configuration = new YamlConfiguration();
+            configuration.load(new InputStreamReader(input, StandardCharsets.UTF_8));
+            return configuration;
+        }
+    }
+}
@@ -0,0 +1,45 @@
+package cn.infstar.essentialsC.admin;
+
+import cn.infstar.essentialsC.util.AtomicYamlWriter;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.UUID;
+import java.util.logging.Logger;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class AdminModeStoreTest {
+
+    @TempDir
+    Path temporaryDirectory;
+
+    @Test
+    void migratesLegacyPlayersIntoIndependentFiles() throws Exception {
+        UUID playerId = UUID.randomUUID();
+        Path legacyFile = temporaryDirectory.resolve("admin-mode.yml");
+        YamlConfiguration legacy = new YamlConfiguration();
+        legacy.set("players." + playerId + ".active", true);
+        legacy.set("players." + playerId + ".normal.level", 27);
+        AtomicYamlWriter.save(legacy, legacyFile.toFile());
+
+        AdminModeStore store = new AdminModeStore(
+            temporaryDirectory.resolve("admin-mode").toFile(), legacyFile.toFile(), Logger.getAnonymousLogger());
+
+        YamlConfiguration migrated = store.load(playerId);
+        assertNotNull(migrated);
+        assertTrue(migrated.getBoolean("active"));
+        assertEquals(27, migrated.getInt("normal.level"));
+        assertTrue(Files.exists(temporaryDirectory.resolve("admin-mode").resolve(playerId + ".yml")));
+        assertFalse(Files.exists(legacyFile));
+        try (var backups = Files.list(temporaryDirectory)) {
+            assertTrue(backups.anyMatch(path -> path.getFileName().toString().startsWith("admin-mode.legacy-")));
+        }
+    }
+}
@@ -0,0 +1,25 @@
+package cn.infstar.essentialsC.listeners;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ShulkerBoxSessionPolicyTest {
+
+    @Test
+    void identifiesOnlySlotsInsideTopInventory() {
+        assertFalse(ShulkerBoxSessionPolicy.isTopSlot(-999, 27));
+        assertTrue(ShulkerBoxSessionPolicy.isTopSlot(0, 27));
+        assertTrue(ShulkerBoxSessionPolicy.isTopSlot(26, 27));
+        assertFalse(ShulkerBoxSessionPolicy.isTopSlot(27, 27));
+    }
+
+    @Test
+    void detectsDragsThatTouchTopInventory() {
+        assertTrue(ShulkerBoxSessionPolicy.touchesTopInventory(Set.of(5, 30), 27));
+        assertFalse(ShulkerBoxSessionPolicy.touchesTopInventory(Set.of(27, 35), 27));
+    }
+}
@@ -0,0 +1,32 @@
+package cn.infstar.essentialsC.teleport;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class TeleportRequestQueuePolicyTest {
+
+    @Test
+    void keepsNewestRequestsWithinConfiguredLimit() {
+        Deque<String> requests = new ArrayDeque<>();
+
+        TeleportRequestQueuePolicy.addFirstBounded(requests, "first", 2);
+        TeleportRequestQueuePolicy.addFirstBounded(requests, "second", 2);
+        TeleportRequestQueuePolicy.addFirstBounded(requests, "third", 2);
+
+        assertEquals(java.util.List.of("third", "second"), java.util.List.copyOf(requests));
+    }
+
+    @Test
+    void retainsRecentlyExpiredRequestsForUserFeedback() {
+        long now = 120_000L;
+
+        assertFalse(TeleportRequestQueuePolicy.shouldPrune(90_000L, now, 60_000L));
+        assertTrue(TeleportRequestQueuePolicy.shouldPrune(60_000L, now, 60_000L));
+    }
+}
@@ -0,0 +1,76 @@
+package cn.infstar.essentialsC.util;
+
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class AtomicYamlWriterTest {
+
+    @TempDir
+    Path temporaryDirectory;
+
+    @Test
+    void createsParentDirectoriesAndWritesUtf8Yaml() throws Exception {
+        Path target = temporaryDirectory.resolve("nested/data.yml");
+        YamlConfiguration configuration = new YamlConfiguration();
+        configuration.set("message", "中文内容");
+
+        AtomicYamlWriter.save(configuration, target.toFile());
+
+        assertTrue(Files.exists(target));
+        assertTrue(Files.readString(target, StandardCharsets.UTF_8).contains("中文内容"));
+        try (var files = Files.list(target.getParent())) {
+            assertFalse(files.anyMatch(path -> path.getFileName().toString().endsWith(".tmp")));
+        }
+    }
+
+    @Test
+    void replacesExistingYamlWithoutRetainingOldValues() throws Exception {
+        Path target = temporaryDirectory.resolve("state.yml");
+        YamlConfiguration initial = new YamlConfiguration();
+        initial.set("old-value", true);
+        AtomicYamlWriter.save(initial, target.toFile());
+
+        YamlConfiguration replacement = new YamlConfiguration();
+        replacement.set("new-value", 42);
+        AtomicYamlWriter.save(replacement, target.toFile());
+
+        YamlConfiguration loaded = YamlConfiguration.loadConfiguration(target.toFile());
+        assertFalse(loaded.contains("old-value"));
+        assertEquals(42, loaded.getInt("new-value"));
+    }
+
+    @Test
+    void supportsShortTargetFileNames() throws Exception {
+        Path target = temporaryDirectory.resolve("x");
+        YamlConfiguration configuration = new YamlConfiguration();
+        configuration.set("written", true);
+
+        AtomicYamlWriter.save(configuration, target.toFile());
+
+        assertTrue(YamlConfiguration.loadConfiguration(target.toFile()).getBoolean("written"));
+    }
+
+    @Test
+    void preservesParsedChineseComments() throws Exception {
+        Path target = temporaryDirectory.resolve("commented.yml");
+        YamlConfiguration configuration = new YamlConfiguration();
+        configuration.options().parseComments(true);
+        configuration.loadFromString("# 中文配置注释\nenabled: false\n");
+        configuration.set("enabled", true);
+
+        AtomicYamlWriter.save(configuration, target.toFile());
+
+        String saved = Files.readString(target, StandardCharsets.UTF_8);
+        assertTrue(saved.contains("# 中文配置注释"));
+        assertTrue(saved.contains("enabled: true"));
+    }
+}
@@ -1,27 +0,0 @@
-plugins {
-    id 'java-library'
-    id 'io.papermc.paperweight.userdev'
-}
-
-repositories {
-    mavenCentral()
-    maven {
-        name = 'papermc'
-        url = uri('https://repo.papermc.io/repository/maven-public/')
-    }
-}
-
-dependencies {
-    api project(':compat-api')
-    paperweight.paperDevBundle('1.21.11-R0.1-SNAPSHOT')
-}
-
-java {
-    toolchain.languageVersion.set(JavaLanguageVersion.of(21))
-}
-
-paperweight.reobfArtifactConfiguration = io.papermc.paperweight.userdev.ReobfArtifactConfiguration.getMOJANG_PRODUCTION()
-
-tasks.withType(JavaCompile).configureEach {
-    options.encoding = 'UTF-8'
-}
@@ -1,239 +0,0 @@
-package cn.infstar.essentialsC.v1_21_11.jei;
-
-import cn.infstar.essentialsC.compat.jei.JeiRecipeSyncAdapter;
-import io.netty.buffer.Unpooled;
-import net.minecraft.core.registries.BuiltInRegistries;
-import net.minecraft.network.RegistryFriendlyByteBuf;
-import net.minecraft.network.protocol.common.ClientboundCustomPayloadPacket;
-import net.minecraft.network.protocol.common.custom.DiscardedPayload;
-import net.minecraft.resources.Identifier;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.world.item.crafting.RecipeHolder;
-import net.minecraft.world.item.crafting.RecipeMap;
-import net.minecraft.world.item.crafting.RecipeSerializer;
-import org.bukkit.craftbukkit.entity.CraftPlayer;
-import org.bukkit.entity.Player;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.logging.Logger;
-
-public final class JeiRecipeSyncAdapterImpl implements JeiRecipeSyncAdapter {
-
-    @Override
-    @SuppressWarnings({"unchecked", "deprecation"})
-    public void sendFabricRecipeSync(Player player, Logger logger, boolean debug) {
-        ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle();
-        MinecraftServer server = serverPlayer.level().getServer();
-        if (server == null) {
-            if (debug) {
-                logger.warning("服务端实例为 null");
-            }
-            return;
-        }
-
-        RecipeMap recipeMap = server.getRecipeManager().recipes;
-        if (debug) {
-            logger.info("开始构建 Fabric 配方数据");
-        }
-
-        var list = new ArrayList<FabricRecipeEntry>();
-        var seen = new HashSet<RecipeSerializer<?>>();
-
-        for (RecipeSerializer<?> serializer : BuiltInRegistries.RECIPE_SERIALIZER) {
-            if (!seen.add(serializer)) {
-                continue;
-            }
-
-            List<RecipeHolder<?>> recipes = new ArrayList<>();
-            for (RecipeHolder<?> holder : recipeMap.values()) {
-                if (holder.value().getSerializer() == serializer) {
-                    recipes.add(holder);
-                }
-            }
-
-            if (!recipes.isEmpty()) {
-                RecipeSerializer<?> entrySerializer = recipes.get(0).value().getSerializer();
-                list.add(new FabricRecipeEntry(entrySerializer, recipes));
-            }
-        }
-
-        var payload = new FabricRecipeSyncPayload(list);
-        if (debug) {
-            logger.info("Fabric 配方条目数: " + list.size());
-        }
-
-        RegistryFriendlyByteBuf buffer = new RegistryFriendlyByteBuf(Unpooled.buffer(), server.registryAccess());
-        getFabricCodec().encode(buffer, payload);
-
-        byte[] bytes = new byte[buffer.writerIndex()];
-        buffer.getBytes(0, bytes);
-
-        Identifier id = Identifier.fromNamespaceAndPath("fabric", "recipe_sync");
-        DiscardedPayload discardedPayload = new DiscardedPayload(id, bytes);
-        serverPlayer.connection.send(new ClientboundCustomPayloadPacket(discardedPayload));
-
-        if (debug) {
-            logger.info("已发送 Fabric 配方同步 [" + id + "], 大小: " + bytes.length + " bytes");
-        }
-    }
-
-    @Override
-    @SuppressWarnings({"unchecked", "deprecation"})
-    public void sendNeoForgeRecipeSync(Player player, Logger logger, boolean debug) {
-        ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle();
-        MinecraftServer server = serverPlayer.level().getServer();
-        if (server == null) {
-            if (debug) {
-                logger.warning("服务端实例为 null");
-            }
-            return;
-        }
-
-        RecipeMap recipeMap = server.getRecipeManager().recipes;
-        if (debug) {
-            logger.info("开始构建 NeoForge 配方数据");
-        }
-
-        java.util.List<net.minecraft.world.item.crafting.RecipeType<?>> allRecipeTypes =
-            BuiltInRegistries.RECIPE_TYPE.stream().toList();
-        if (debug) {
-            logger.info("NeoForge 配方类型数: " + allRecipeTypes.size());
-        }
-
-        var payload = createNeoForgePayload(allRecipeTypes, recipeMap);
-        RegistryFriendlyByteBuf buffer = new RegistryFriendlyByteBuf(Unpooled.buffer(), server.registryAccess());
-        getNeoForgeStreamCodec().encode(buffer, payload);
-
-        byte[] bytes = new byte[buffer.writerIndex()];
-        buffer.getBytes(0, bytes);
-
-        Identifier id = Identifier.fromNamespaceAndPath("neoforge", "recipe_content");
-        DiscardedPayload discardedPayload = new DiscardedPayload(id, bytes);
-        serverPlayer.connection.send(new ClientboundCustomPayloadPacket(discardedPayload));
-        serverPlayer.connection.send(new net.minecraft.network.protocol.common.ClientboundUpdateTagsPacket(
-            net.minecraft.tags.TagNetworkSerialization.serializeTagsToNetwork(server.registries())
-        ));
-
-        if (debug) {
-            logger.info("已发送 NeoForge 配方同步 [" + id + "], 大小: " + bytes.length + " bytes");
-        }
-    }
-
-    @SuppressWarnings({"unchecked", "deprecation"})
-    private net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, FabricRecipeSyncPayload> getFabricCodec() {
-        return FabricRecipeEntry.CODEC.apply(net.minecraft.network.codec.ByteBufCodecs.list())
-            .map(FabricRecipeSyncPayload::new, FabricRecipeSyncPayload::entries);
-    }
-
-    private NeoForgeRecipeSyncPayload createNeoForgePayload(
-        java.util.List<net.minecraft.world.item.crafting.RecipeType<?>> recipeTypes,
-        RecipeMap recipeMap
-    ) {
-        var recipeTypeSet = new java.util.HashSet<>(recipeTypes);
-        if (recipeTypeSet.isEmpty()) {
-            return new NeoForgeRecipeSyncPayload(recipeTypeSet, java.util.List.of());
-        }
-
-        var recipeSubset = recipeMap.values().stream()
-            .filter(h -> recipeTypeSet.contains(h.value().getType()))
-            .toList();
-        return new NeoForgeRecipeSyncPayload(recipeTypeSet, recipeSubset);
-    }
-
-    @SuppressWarnings({"unchecked", "deprecation"})
-    private net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, NeoForgeRecipeSyncPayload> getNeoForgeStreamCodec() {
-        return net.minecraft.network.codec.StreamCodec.composite(
-            net.minecraft.network.codec.ByteBufCodecs.registry(net.minecraft.core.registries.Registries.RECIPE_TYPE)
-                .apply(net.minecraft.network.codec.ByteBufCodecs.collection(java.util.HashSet::new)),
-            NeoForgeRecipeSyncPayload::recipeTypes,
-            RecipeHolder.STREAM_CODEC.apply(net.minecraft.network.codec.ByteBufCodecs.list()),
-            NeoForgeRecipeSyncPayload::recipes,
-            NeoForgeRecipeSyncPayload::new
-        );
-    }
-
-    @SuppressWarnings("deprecation")
-    private static class FabricRecipeEntry {
-        final Object serializer;
-        final List<RecipeHolder<?>> recipes;
-
-        FabricRecipeEntry(Object serializer, List<RecipeHolder<?>> recipes) {
-            this.serializer = serializer;
-            this.recipes = recipes;
-        }
-
-        static final net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, FabricRecipeEntry> CODEC =
-            net.minecraft.network.codec.StreamCodec.ofMember(
-                FabricRecipeEntry::write,
-                FabricRecipeEntry::read
-            );
-
-        @SuppressWarnings("unchecked")
-        private static FabricRecipeEntry read(RegistryFriendlyByteBuf buf) {
-            Identifier recipeSerializerId = buf.readIdentifier();
-            RecipeSerializer<?> recipeSerializer = BuiltInRegistries.RECIPE_SERIALIZER.getValue(recipeSerializerId);
-
-            if (recipeSerializer == null) {
-                throw new RuntimeException("Tried syncing unsupported packet serializer '" + recipeSerializerId + "'!");
-            }
-
-            int count = buf.readVarInt();
-            var list = new ArrayList<RecipeHolder<?>>();
-            for (int i = 0; i < count; i++) {
-                net.minecraft.resources.ResourceKey<net.minecraft.world.item.crafting.Recipe<?>> id =
-                    buf.readResourceKey(net.minecraft.core.registries.Registries.RECIPE);
-
-                try {
-                    var streamCodecMethod = recipeSerializer.getClass().getMethod("streamCodec");
-                    var streamCodec = streamCodecMethod.invoke(recipeSerializer);
-                    net.minecraft.world.item.crafting.Recipe<?> recipe =
-                        ((net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, net.minecraft.world.item.crafting.Recipe<?>>) streamCodec)
-                            .decode(buf);
-                    list.add(new RecipeHolder<>(id, recipe));
-                } catch (Exception e) {
-                    throw new RuntimeException("Failed to decode recipe: " + e.getMessage(), e);
-                }
-            }
-
-            return new FabricRecipeEntry(recipeSerializer, list);
-        }
-
-        private void write(RegistryFriendlyByteBuf buf) {
-            try {
-                var getKeyMethod = BuiltInRegistries.RECIPE_SERIALIZER.getClass().getMethod("getKey", Object.class);
-                Identifier identifier = (Identifier) getKeyMethod.invoke(BuiltInRegistries.RECIPE_SERIALIZER, this.serializer);
-                buf.writeIdentifier(identifier);
-            } catch (Exception e) {
-                throw new RuntimeException("Failed to get serializer key: " + e.getMessage(), e);
-            }
-
-            buf.writeVarInt(this.recipes.size());
-
-            try {
-                var streamCodecMethod = this.serializer.getClass().getMethod("streamCodec");
-                @SuppressWarnings("unchecked")
-                var codec = (net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, net.minecraft.world.item.crafting.Recipe<?>>)
-                    streamCodecMethod.invoke(this.serializer);
-
-                for (RecipeHolder<?> recipe : this.recipes) {
-                    buf.writeResourceKey(recipe.id());
-                    codec.encode(buf, recipe.value());
-                }
-            } catch (Exception e) {
-                throw new RuntimeException("Failed to encode recipe: " + e.getMessage(), e);
-            }
-        }
-    }
-
-    private record FabricRecipeSyncPayload(List<FabricRecipeEntry> entries) {
-    }
-
-    private record NeoForgeRecipeSyncPayload(
-        java.util.Set<net.minecraft.world.item.crafting.RecipeType<?>> recipeTypes,
-        java.util.List<RecipeHolder<?>> recipes
-    ) {
-    }
-}
@@ -1,27 +0,0 @@
-plugins {
-    id 'java-library'
-    id 'io.papermc.paperweight.userdev'
-}
-
-repositories {
-    mavenCentral()
-    maven {
-        name = 'papermc'
-        url = uri('https://repo.papermc.io/repository/maven-public/')
-    }
-}
-
-dependencies {
-    api project(':compat-api')
-    paperweight.paperDevBundle('26.1.2.build.72-stable')
-}
-
-java {
-    toolchain.languageVersion.set(JavaLanguageVersion.of(25))
-}
-
-paperweight.reobfArtifactConfiguration = io.papermc.paperweight.userdev.ReobfArtifactConfiguration.getMOJANG_PRODUCTION()
-
-tasks.withType(JavaCompile).configureEach {
-    options.encoding = 'UTF-8'
-}
@@ -1,240 +0,0 @@
-package cn.infstar.essentialsC.v26_1_2.jei;
-
-import cn.infstar.essentialsC.compat.jei.JeiRecipeSyncAdapter;
-import io.netty.buffer.Unpooled;
-import net.minecraft.core.registries.BuiltInRegistries;
-import net.minecraft.network.RegistryFriendlyByteBuf;
-import net.minecraft.network.protocol.common.ClientboundCustomPayloadPacket;
-import net.minecraft.network.protocol.common.custom.DiscardedPayload;
-import net.minecraft.resources.Identifier;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.world.item.crafting.RecipeHolder;
-import net.minecraft.world.item.crafting.RecipeMap;
-import net.minecraft.world.item.crafting.RecipeSerializer;
-import org.bukkit.craftbukkit.entity.CraftPlayer;
-import org.bukkit.entity.Player;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.logging.Logger;
-
-public final class JeiRecipeSyncAdapterImpl implements JeiRecipeSyncAdapter {
-
-    @Override
-    @SuppressWarnings({"unchecked", "deprecation"})
-    public void sendFabricRecipeSync(Player player, Logger logger, boolean debug) {
-        ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle();
-        MinecraftServer server = serverPlayer.level().getServer();
-        if (server == null) {
-            if (debug) {
-                logger.warning("服务端实例为 null");
-            }
-            return;
-        }
-
-        RecipeMap recipeMap = server.getRecipeManager().recipes;
-        if (debug) {
-            logger.info("开始构建 Fabric 配方数据");
-        }
-
-        var list = new ArrayList<FabricRecipeEntry>();
-        var seen = new HashSet<RecipeSerializer<?>>();
-
-        for (RecipeSerializer<?> serializer : BuiltInRegistries.RECIPE_SERIALIZER) {
-            if (!seen.add(serializer)) {
-                continue;
-            }
-
-            List<RecipeHolder<?>> recipes = new ArrayList<>();
-            for (RecipeHolder<?> holder : recipeMap.values()) {
-                if (holder.value().getSerializer() == serializer) {
-                    recipes.add(holder);
-                }
-            }
-
-            if (!recipes.isEmpty()) {
-                RecipeSerializer<?> entrySerializer = recipes.get(0).value().getSerializer();
-                list.add(new FabricRecipeEntry(entrySerializer, recipes));
-            }
-        }
-
-        var payload = new FabricRecipeSyncPayload(list);
-        if (debug) {
-            logger.info("Fabric 配方条目数: " + list.size());
-        }
-
-        RegistryFriendlyByteBuf buffer = new RegistryFriendlyByteBuf(Unpooled.buffer(), server.registryAccess());
-        getFabricCodec().encode(buffer, payload);
-
-        byte[] bytes = new byte[buffer.writerIndex()];
-        buffer.getBytes(0, bytes);
-
-        Identifier id = Identifier.fromNamespaceAndPath("fabric", "recipe_sync");
-        DiscardedPayload discardedPayload = new DiscardedPayload(id, bytes);
-        serverPlayer.connection.send(new ClientboundCustomPayloadPacket(discardedPayload));
-
-        if (debug) {
-            logger.info("已发送 Fabric 配方同步 [" + id + "], 大小: " + bytes.length + " bytes");
-        }
-    }
-
-    @Override
-    @SuppressWarnings({"unchecked", "deprecation"})
-    public void sendNeoForgeRecipeSync(Player player, Logger logger, boolean debug) {
-        ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle();
-        MinecraftServer server = serverPlayer.level().getServer();
-        if (server == null) {
-            if (debug) {
-                logger.warning("服务端实例为 null");
-            }
-            return;
-        }
-
-        RecipeMap recipeMap = server.getRecipeManager().recipes;
-        if (debug) {
-            logger.info("开始构建 NeoForge 配方数据");
-        }
-
-        java.util.List<net.minecraft.world.item.crafting.RecipeType<?>> allRecipeTypes =
-            BuiltInRegistries.RECIPE_TYPE.stream().toList();
-        if (debug) {
-            logger.info("NeoForge 配方类型数: " + allRecipeTypes.size());
-        }
-
-        var payload = createNeoForgePayload(allRecipeTypes, recipeMap);
-        RegistryFriendlyByteBuf buffer = new RegistryFriendlyByteBuf(Unpooled.buffer(), server.registryAccess());
-        getNeoForgeStreamCodec().encode(buffer, payload);
-
-        byte[] bytes = new byte[buffer.writerIndex()];
-        buffer.getBytes(0, bytes);
-
-        Identifier id = Identifier.fromNamespaceAndPath("neoforge", "recipe_content");
-        DiscardedPayload discardedPayload = new DiscardedPayload(id, bytes);
-        serverPlayer.connection.send(new ClientboundCustomPayloadPacket(discardedPayload));
-        serverPlayer.connection.send(new net.minecraft.network.protocol.common.ClientboundUpdateTagsPacket(
-            net.minecraft.tags.TagNetworkSerialization.serializeTagsToNetwork(server.registries())
-        ));
-
-        if (debug) {
-            logger.info("已发送 NeoForge 配方同步 [" + id + "], 大小: " + bytes.length + " bytes");
-        }
-    }
-
-    @SuppressWarnings({"unchecked", "deprecation"})
-    private net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, FabricRecipeSyncPayload> getFabricCodec() {
-        return FabricRecipeEntry.CODEC.apply(net.minecraft.network.codec.ByteBufCodecs.list())
-            .map(FabricRecipeSyncPayload::new, FabricRecipeSyncPayload::entries);
-    }
-
-    private NeoForgeRecipeSyncPayload createNeoForgePayload(
-        java.util.List<net.minecraft.world.item.crafting.RecipeType<?>> recipeTypes,
-        RecipeMap recipeMap
-    ) {
-        var recipeTypeSet = new java.util.HashSet<>(recipeTypes);
-        if (recipeTypeSet.isEmpty()) {
-            return new NeoForgeRecipeSyncPayload(recipeTypeSet, java.util.List.of());
-        }
-
-        var recipeSubset = recipeMap.values().stream()
-            .filter(h -> recipeTypeSet.contains(h.value().getType()))
-            .toList();
-        return new NeoForgeRecipeSyncPayload(recipeTypeSet, recipeSubset);
-    }
-
-    @SuppressWarnings({"unchecked", "deprecation"})
-    private net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, NeoForgeRecipeSyncPayload> getNeoForgeStreamCodec() {
-        return net.minecraft.network.codec.StreamCodec.composite(
-            net.minecraft.network.codec.ByteBufCodecs.registry(net.minecraft.core.registries.Registries.RECIPE_TYPE)
-                .apply(net.minecraft.network.codec.ByteBufCodecs.collection(java.util.HashSet::new)),
-            NeoForgeRecipeSyncPayload::recipeTypes,
-            RecipeHolder.STREAM_CODEC.apply(net.minecraft.network.codec.ByteBufCodecs.list()),
-            NeoForgeRecipeSyncPayload::recipes,
-            NeoForgeRecipeSyncPayload::new
-        );
-    }
-
-    @SuppressWarnings("deprecation")
-    private static class FabricRecipeEntry {
-        final Object serializer;
-        final List<RecipeHolder<?>> recipes;
-
-        FabricRecipeEntry(Object serializer, List<RecipeHolder<?>> recipes) {
-            this.serializer = serializer;
-            this.recipes = recipes;
-        }
-
-        static final net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, FabricRecipeEntry> CODEC =
-            net.minecraft.network.codec.StreamCodec.ofMember(
-                FabricRecipeEntry::write,
-                FabricRecipeEntry::read
-            );
-
-        @SuppressWarnings("unchecked")
-        private static FabricRecipeEntry read(RegistryFriendlyByteBuf buf) {
-            Identifier recipeSerializerId = buf.readIdentifier();
-            RecipeSerializer<?> recipeSerializer = BuiltInRegistries.RECIPE_SERIALIZER.getValue(recipeSerializerId);
-
-            if (recipeSerializer == null) {
-                throw new RuntimeException("Tried syncing unsupported packet serializer '" + recipeSerializerId + "'!");
-            }
-
-            int count = buf.readVarInt();
-            var list = new ArrayList<RecipeHolder<?>>();
-            for (int i = 0; i < count; i++) {
-                net.minecraft.resources.ResourceKey<net.minecraft.world.item.crafting.Recipe<?>> id =
-                    buf.readResourceKey(net.minecraft.core.registries.Registries.RECIPE);
-
-                try {
-                    var streamCodecMethod = recipeSerializer.getClass().getMethod("streamCodec");
-                    var streamCodec = streamCodecMethod.invoke(recipeSerializer);
-                    net.minecraft.world.item.crafting.Recipe<?> recipe =
-                        ((net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, net.minecraft.world.item.crafting.Recipe<?>>) streamCodec)
-                            .decode(buf);
-                    list.add(new RecipeHolder<>(id, recipe));
-                } catch (Exception e) {
-                    throw new RuntimeException("Failed to decode recipe: " + e.getMessage(), e);
-                }
-            }
-
-            return new FabricRecipeEntry(recipeSerializer, list);
-        }
-
-        private void write(RegistryFriendlyByteBuf buf) {
-            try {
-                var getKeyMethod = BuiltInRegistries.RECIPE_SERIALIZER.getClass().getMethod("getKey", Object.class);
-                Identifier identifier = (Identifier) getKeyMethod.invoke(BuiltInRegistries.RECIPE_SERIALIZER, this.serializer);
-                buf.writeIdentifier(identifier);
-            } catch (Exception e) {
-                throw new RuntimeException("Failed to get serializer key: " + e.getMessage(), e);
-            }
-
-            buf.writeVarInt(this.recipes.size());
-
-            try {
-                var streamCodecMethod = this.serializer.getClass().getMethod("streamCodec");
-                @SuppressWarnings("unchecked")
-                var codec = (net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, net.minecraft.world.item.crafting.Recipe<?>>)
-                    streamCodecMethod.invoke(this.serializer);
-
-                for (RecipeHolder<?> recipe : this.recipes) {
-                    buf.writeResourceKey(recipe.id());
-                    codec.encode(buf, recipe.value());
-                }
-            } catch (Exception e) {
-                throw new RuntimeException("Failed to encode recipe: " + e.getMessage(), e);
-            }
-        }
-    }
-
-    private record FabricRecipeSyncPayload(List<FabricRecipeEntry> entries) {
-    }
-
-    private record NeoForgeRecipeSyncPayload(
-        java.util.Set<net.minecraft.world.item.crafting.RecipeType<?>> recipeTypes,
-        java.util.List<RecipeHolder<?>> recipes
-    ) {
-    }
-}
-
@@ -1,27 +0,0 @@
-plugins {
-    id 'java-library'
-    id 'io.papermc.paperweight.userdev'
-}
-
-repositories {
-    mavenCentral()
-    maven {
-        name = 'papermc'
-        url = uri('https://repo.papermc.io/repository/maven-public/')
-    }
-}
-
-dependencies {
-    api project(':compat-api')
-    paperweight.paperDevBundle('26.2.build.31-alpha')
-}
-
-java {
-    toolchain.languageVersion.set(JavaLanguageVersion.of(25))
-}
-
-paperweight.reobfArtifactConfiguration = io.papermc.paperweight.userdev.ReobfArtifactConfiguration.getMOJANG_PRODUCTION()
-
-tasks.withType(JavaCompile).configureEach {
-    options.encoding = 'UTF-8'
-}
@@ -1,240 +0,0 @@
-package cn.infstar.essentialsC.v26_2.jei;
-
-import cn.infstar.essentialsC.compat.jei.JeiRecipeSyncAdapter;
-import io.netty.buffer.Unpooled;
-import net.minecraft.core.registries.BuiltInRegistries;
-import net.minecraft.network.RegistryFriendlyByteBuf;
-import net.minecraft.network.protocol.common.ClientboundCustomPayloadPacket;
-import net.minecraft.network.protocol.common.custom.DiscardedPayload;
-import net.minecraft.resources.Identifier;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.world.item.crafting.RecipeHolder;
-import net.minecraft.world.item.crafting.RecipeMap;
-import net.minecraft.world.item.crafting.RecipeSerializer;
-import org.bukkit.craftbukkit.entity.CraftPlayer;
-import org.bukkit.entity.Player;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.logging.Logger;
-
-public final class JeiRecipeSyncAdapterImpl implements JeiRecipeSyncAdapter {
-
-    @Override
-    @SuppressWarnings({"unchecked", "deprecation"})
-    public void sendFabricRecipeSync(Player player, Logger logger, boolean debug) {
-        ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle();
-        MinecraftServer server = serverPlayer.level().getServer();
-        if (server == null) {
-            if (debug) {
-                logger.warning("服务端实例为 null");
-            }
-            return;
-        }
-
-        RecipeMap recipeMap = server.getRecipeManager().recipes;
-        if (debug) {
-            logger.info("开始构建 Fabric 配方数据");
-        }
-
-        var list = new ArrayList<FabricRecipeEntry>();
-        var seen = new HashSet<RecipeSerializer<?>>();
-
-        for (RecipeSerializer<?> serializer : BuiltInRegistries.RECIPE_SERIALIZER) {
-            if (!seen.add(serializer)) {
-                continue;
-            }
-
-            List<RecipeHolder<?>> recipes = new ArrayList<>();
-            for (RecipeHolder<?> holder : recipeMap.values()) {
-                if (holder.value().getSerializer() == serializer) {
-                    recipes.add(holder);
-                }
-            }
-
-            if (!recipes.isEmpty()) {
-                RecipeSerializer<?> entrySerializer = recipes.get(0).value().getSerializer();
-                list.add(new FabricRecipeEntry(entrySerializer, recipes));
-            }
-        }
-
-        var payload = new FabricRecipeSyncPayload(list);
-        if (debug) {
-            logger.info("Fabric 配方条目数: " + list.size());
-        }
-
-        RegistryFriendlyByteBuf buffer = new RegistryFriendlyByteBuf(Unpooled.buffer(), server.registryAccess());
-        getFabricCodec().encode(buffer, payload);
-
-        byte[] bytes = new byte[buffer.writerIndex()];
-        buffer.getBytes(0, bytes);
-
-        Identifier id = Identifier.fromNamespaceAndPath("fabric", "recipe_sync");
-        DiscardedPayload discardedPayload = new DiscardedPayload(id, bytes);
-        serverPlayer.connection.send(new ClientboundCustomPayloadPacket(discardedPayload));
-
-        if (debug) {
-            logger.info("已发送 Fabric 配方同步 [" + id + "], 大小: " + bytes.length + " bytes");
-        }
-    }
-
-    @Override
-    @SuppressWarnings({"unchecked", "deprecation"})
-    public void sendNeoForgeRecipeSync(Player player, Logger logger, boolean debug) {
-        ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle();
-        MinecraftServer server = serverPlayer.level().getServer();
-        if (server == null) {
-            if (debug) {
-                logger.warning("服务端实例为 null");
-            }
-            return;
-        }
-
-        RecipeMap recipeMap = server.getRecipeManager().recipes;
-        if (debug) {
-            logger.info("开始构建 NeoForge 配方数据");
-        }
-
-        java.util.List<net.minecraft.world.item.crafting.RecipeType<?>> allRecipeTypes =
-            BuiltInRegistries.RECIPE_TYPE.stream().toList();
-        if (debug) {
-            logger.info("NeoForge 配方类型数: " + allRecipeTypes.size());
-        }
-
-        var payload = createNeoForgePayload(allRecipeTypes, recipeMap);
-        RegistryFriendlyByteBuf buffer = new RegistryFriendlyByteBuf(Unpooled.buffer(), server.registryAccess());
-        getNeoForgeStreamCodec().encode(buffer, payload);
-
-        byte[] bytes = new byte[buffer.writerIndex()];
-        buffer.getBytes(0, bytes);
-
-        Identifier id = Identifier.fromNamespaceAndPath("neoforge", "recipe_content");
-        DiscardedPayload discardedPayload = new DiscardedPayload(id, bytes);
-        serverPlayer.connection.send(new ClientboundCustomPayloadPacket(discardedPayload));
-        serverPlayer.connection.send(new net.minecraft.network.protocol.common.ClientboundUpdateTagsPacket(
-            net.minecraft.tags.TagNetworkSerialization.serializeTagsToNetwork(server.registries())
-        ));
-
-        if (debug) {
-            logger.info("已发送 NeoForge 配方同步 [" + id + "], 大小: " + bytes.length + " bytes");
-        }
-    }
-
-    @SuppressWarnings({"unchecked", "deprecation"})
-    private net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, FabricRecipeSyncPayload> getFabricCodec() {
-        return FabricRecipeEntry.CODEC.apply(net.minecraft.network.codec.ByteBufCodecs.list())
-            .map(FabricRecipeSyncPayload::new, FabricRecipeSyncPayload::entries);
-    }
-
-    private NeoForgeRecipeSyncPayload createNeoForgePayload(
-        java.util.List<net.minecraft.world.item.crafting.RecipeType<?>> recipeTypes,
-        RecipeMap recipeMap
-    ) {
-        var recipeTypeSet = new java.util.HashSet<>(recipeTypes);
-        if (recipeTypeSet.isEmpty()) {
-            return new NeoForgeRecipeSyncPayload(recipeTypeSet, java.util.List.of());
-        }
-
-        var recipeSubset = recipeMap.values().stream()
-            .filter(h -> recipeTypeSet.contains(h.value().getType()))
-            .toList();
-        return new NeoForgeRecipeSyncPayload(recipeTypeSet, recipeSubset);
-    }
-
-    @SuppressWarnings({"unchecked", "deprecation"})
-    private net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, NeoForgeRecipeSyncPayload> getNeoForgeStreamCodec() {
-        return net.minecraft.network.codec.StreamCodec.composite(
-            net.minecraft.network.codec.ByteBufCodecs.registry(net.minecraft.core.registries.Registries.RECIPE_TYPE)
-                .apply(net.minecraft.network.codec.ByteBufCodecs.collection(java.util.HashSet::new)),
-            NeoForgeRecipeSyncPayload::recipeTypes,
-            RecipeHolder.STREAM_CODEC.apply(net.minecraft.network.codec.ByteBufCodecs.list()),
-            NeoForgeRecipeSyncPayload::recipes,
-            NeoForgeRecipeSyncPayload::new
-        );
-    }
-
-    @SuppressWarnings("deprecation")
-    private static class FabricRecipeEntry {
-        final Object serializer;
-        final List<RecipeHolder<?>> recipes;
-
-        FabricRecipeEntry(Object serializer, List<RecipeHolder<?>> recipes) {
-            this.serializer = serializer;
-            this.recipes = recipes;
-        }
-
-        static final net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, FabricRecipeEntry> CODEC =
-            net.minecraft.network.codec.StreamCodec.ofMember(
-                FabricRecipeEntry::write,
-                FabricRecipeEntry::read
-            );
-
-        @SuppressWarnings("unchecked")
-        private static FabricRecipeEntry read(RegistryFriendlyByteBuf buf) {
-            Identifier recipeSerializerId = buf.readIdentifier();
-            RecipeSerializer<?> recipeSerializer = BuiltInRegistries.RECIPE_SERIALIZER.getValue(recipeSerializerId);
-
-            if (recipeSerializer == null) {
-                throw new RuntimeException("Tried syncing unsupported packet serializer '" + recipeSerializerId + "'!");
-            }
-
-            int count = buf.readVarInt();
-            var list = new ArrayList<RecipeHolder<?>>();
-            for (int i = 0; i < count; i++) {
-                net.minecraft.resources.ResourceKey<net.minecraft.world.item.crafting.Recipe<?>> id =
-                    buf.readResourceKey(net.minecraft.core.registries.Registries.RECIPE);
-
-                try {
-                    var streamCodecMethod = recipeSerializer.getClass().getMethod("streamCodec");
-                    var streamCodec = streamCodecMethod.invoke(recipeSerializer);
-                    net.minecraft.world.item.crafting.Recipe<?> recipe =
-                        ((net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, net.minecraft.world.item.crafting.Recipe<?>>) streamCodec)
-                            .decode(buf);
-                    list.add(new RecipeHolder<>(id, recipe));
-                } catch (Exception e) {
-                    throw new RuntimeException("Failed to decode recipe: " + e.getMessage(), e);
-                }
-            }
-
-            return new FabricRecipeEntry(recipeSerializer, list);
-        }
-
-        private void write(RegistryFriendlyByteBuf buf) {
-            try {
-                var getKeyMethod = BuiltInRegistries.RECIPE_SERIALIZER.getClass().getMethod("getKey", Object.class);
-                Identifier identifier = (Identifier) getKeyMethod.invoke(BuiltInRegistries.RECIPE_SERIALIZER, this.serializer);
-                buf.writeIdentifier(identifier);
-            } catch (Exception e) {
-                throw new RuntimeException("Failed to get serializer key: " + e.getMessage(), e);
-            }
-
-            buf.writeVarInt(this.recipes.size());
-
-            try {
-                var streamCodecMethod = this.serializer.getClass().getMethod("streamCodec");
-                @SuppressWarnings("unchecked")
-                var codec = (net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, net.minecraft.world.item.crafting.Recipe<?>>)
-                    streamCodecMethod.invoke(this.serializer);
-
-                for (RecipeHolder<?> recipe : this.recipes) {
-                    buf.writeResourceKey(recipe.id());
-                    codec.encode(buf, recipe.value());
-                }
-            } catch (Exception e) {
-                throw new RuntimeException("Failed to encode recipe: " + e.getMessage(), e);
-            }
-        }
-    }
-
-    private record FabricRecipeSyncPayload(List<FabricRecipeEntry> entries) {
-    }
-
-    private record NeoForgeRecipeSyncPayload(
-        java.util.Set<net.minecraft.world.item.crafting.RecipeType<?>> recipeTypes,
-        java.util.List<RecipeHolder<?>> recipes
-    ) {
-    }
-}
-
Author	SHA1	Message	Date
Coldsmile	94197e6bfa	fix: 限制 Paper 冒烟测试退出等待 Build / build (push) Has been cancelled Details Release / build (push) Has been cancelled Details Build / Paper 1.21.11 / Java 21 (push) Has been cancelled Details Build / Paper 26.1.2 / Java 25 (push) Has been cancelled Details Build / Paper 26.2 / Java 25 (push) Has been cancelled Details	2026-08-16 22:02:58 +08:00
Coldsmile	518c9c2f38	fix: 避免 Paper 冒烟测试清理竞态	2026-08-16 20:28:04 +08:00
Coldsmile	45cb8de544	fix: 清理误生成的发布元数据文件	2026-08-16 20:22:36 +08:00
Coldsmile	c9bc102d9a	release: 发布 1.3.1	2026-08-16 20:22:10 +08:00
Coldsmile	ba730cf45f	release: 发布 1.3.0	2026-08-05 23:20:18 +08:00
Coldsmile	292b93e842	fix: 修复 1.3.0 实机测试问题 Build / build (push) Has been cancelled Details Build / Paper 1.21.11 / Java 21 (push) Has been cancelled Details Build / Paper 26.1.2 / Java 25 (push) Has been cancelled Details Build / Paper 26.2 / Java 25 (push) Has been cancelled Details	2026-08-05 00:42:24 +08:00
Coldsmile	7816b75325	feat: 准备 1.3.0 稳定版本	2026-08-02 12:18:04 +08:00
Coldsmile	92ef7f6030	feat: 完善稳定性并重构潜影盒安全机制	2026-08-02 03:36:19 +08:00
Coldsmile	d9b1312e0c	feat: 完善插件稳定性与兼容性	2026-08-01 00:36:17 +08:00
Coldsmile	f8f731f927	feat: 完善 TPA 并整理插件配置	2026-07-31 19:07:50 +08:00
Coldsmile	66bf93b10d	merge: 合并 SkinBridge 皮肤兼容功能	2026-07-21 23:45:55 +08:00
Coldsmile	d6c8db6019	feat: 添加 SkinBridge 皮肤兼容	2026-07-21 23:45:19 +08:00
Coldsmile	5d86f0e3eb	feat: 完整实现 TPA 并添加多版本适配	2026-06-25 23:40:30 +08:00
Coldsmile	061c3be2b1	feat: 完善维护模式与运行期功能管理	2026-06-12 00:08:40 +08:00