fix(xp): prioritize repairing equipped mending items before giving leftover xp to player

Specifies what counts as "tested" for this repo, the local test
commands the bot treats as gates, and how pragent reads the repo
config (`.pr-review.json` + static architecture.md from Nexus
raw-hosted).

.gitea/pull_request_template.md

@@ -0,0 +1,53 @@
+## What
+
+<!-- 1-2 sentences. What does this PR change? -->
+
+## Why
+
+<!-- Link the issue, design doc, or chat thread. Without a "why" the reviewer
+has to guess whether the change is wanted at all. -->
+
+Refs: #<!-- issue or N/A -->
+
+## How to test
+
+```bash
+# Commands the reviewer can run to reproduce / verify:
+docker run --rm -v "$PWD":/work -v "$HOME/.m2":/root/.m2 -w /work \
+  maven:3.9-eclipse-temurin-25 mvn -B test
+```
+
+<!-- Manual test steps (if any): load a save, join a server, trigger a
+death in the void, etc. State what you observed. -->
+
+<!-- Server console output if relevant (translatable components render
+in English there — that's normal). -->
+
+## Risk
+
+<!-- Which surface is touched? chat-only / item-loss / chunk-load / permissions.
+Is a rollback plan needed? Does it need a config.yml default? -->
+
+- [ ] chat message flow (immutable after send)
+- [ ] pt-BR singular-form rule (`5.966 blocos de Pedra`, not `5.966 Pedras`)
+- [ ] Bedrock equivalent (`comando:` typed fallback, `texto:` ASCII label)
+- [ ] stats path (`<world>/players/stats`, not `<world>/stats`)
+- [ ] reaction late-window (`reacao-validade-minutos`)
+- [ ] Bukkit main thread (no async chunk loads in event handlers)
+- [ ] new `comando:` added to `plugin.yml`
+- [ ] new permission declared in `plugin.yml`
+
+## Checklist
+
+- [ ] `mvn -B test` passes locally (JDK 25)
+- [ ] new behaviour has a test (`src/test/java/...`)
+- [ ] no hand edits to generated sources (none in this repo)
+- [ ] PR title is conventional-commit style
+- [ ] branch is up to date with `main`
+
+## AI review
+
+Label this PR **`AI-REVIEW`** to trigger `pragent`. Add **`AI-USAGE`** for a
+token/cost report on the review. The bot reads `.pr-review.json` from `main`
++ a static `architecture.md` from Nexus raw-hosted — so house rules (chat
+immutability, singular-form, Bedrock fallback, JDK 25) are baked in.

.pr-review.json

@@ -0,0 +1,30 @@
+{
+  "focus": [
+    "correctness",
+    "security",
+    "performance"
+  ],
+  "exclude_paths": [
+    "target/**",
+    "*.class"
+  ],
+  "languages": [
+    "java"
+  ],
+  "style": "balanced",
+  "require_tests": true,
+  "exclude_tests": false,
+  "max_findings": 15,
+  "severity_threshold": "low",
+  "patterns": {
+    "deny": [
+      "**/README.md",
+      "**/*.md"
+    ]
+  },
+  "cost_target": "claude-sonnet-5",
+  "additional_context_urls": [
+    "http://nexus-service.nexus.svc.cluster.local:8081/repository/raw-hosted/canalhandia/architecture.md"
+  ],
+  "instructions": "Minecraft plugin (Paper 26.2, pt-BR, JDK 25 build). Chat-only — never touch gameplay. Watch thread-safety on event handlers (PlayerDeathEvent, PlayerInteractEvent) — the Bukkit main thread is single-threaded but async chunks/events cross it. Avoid main-thread I/O; defer expensive scans (chunk loading, spiral search) to scheduled tasks or async paths. Flag mutable shared state across listener invocations. Hard constraints: chat messages are immutable after send (counts baked into buttons freeze at send time); names go out as translatable components so the singular-form rule applies (number never agrees with the noun); Geyser/Bedrock cannot click and cannot show emoji (every click has a typed fallback); vanilla statistics are the only data source (offline path is <world>/players/stats/<uuid>.json, NOT <world>/stats); reactions keep counting late (reacao-validade-minutos); Floodgate is optional runtime dep. Flag: real bugs, missing persistence of new settings, comando/permission not in plugin.yml, breaking Bedrock equivalent invariant, removing the frozen-at-send assumption, violating singular-form rule, missing Stats.resolve() on renames."
+}

CONTRIBUTING.md

@@ -0,0 +1,93 @@
+# Contributing — Canalhandia (Canalhandia Minecraft plugin)
+
+Canalhandia is a Minecraft Paper plugin that adds PT-BR chat games, item
+protection, and other in-game commands for the Canalhandia server. This repo
+holds the plugin source. The companion server config lives at
+`gitea_admin/canalhandia-config`.
+
+## Before you open a PR
+
+1. **Fill in the PR template** (`.gitea/pull_request_template.md`). The
+   *Risk* checklist is the part pragent scores you on — check the boxes that
+   apply, delete the ones that don't.
+2. **Update the static context** if your change introduces new house rules.
+   See `## Adding house rules` below.
+3. **Run the gates locally** (see *Test commands*). CI is a single
+   `mvn -B test` against JDK 25 — there's no other infra in this repo.
+
+## Test commands
+
+```bash
+# Run the test suite (JDK 25 required). Same command CI uses:
+mvn -B test
+
+# Compile only (faster):
+mvn -B -DskipTests package
+
+# Integration: copy the resulting jar into a test Paper server's plugins/
+# directory, start the server, exercise the affected commands. The chat
+# and stats paths are NOT covered by unit tests — they need a live server.
+```
+
+### What counts as "tested"
+
+For pragent (and reviewers) to consider a change tested, the PR must show:
+
+- [ ] `mvn -B test` output from your machine pasted in the PR, **OR** a CI
+      run URL.
+- [ ] A new behaviour has a JUnit test in `src/test/java/...` that exercises
+      the new code path. New `comando:` blocks need at least one test that
+      sends a fake event and asserts the message format.
+- [ ] If the change touches the chat immutability rule, the singular-form
+      rule, or the Bedrock fallback, a manual test on a Paper server is
+      required **and** a one-line note pasted in the PR.
+- [ ] If the change touches `<world>/players/stats`, you must show the
+      file path on a running server (`ls <world>/players/stats/*.json`)
+      and confirm the stats file is updated, not the wrong path.
+
+### Out of scope for tests
+
+- Performance / load tests (none in this repo).
+- E2E against the live server (manual; verify in `canalhandia-config` repo).
+- UI / browser tests (no web surface).
+
+## Commit messages
+
+Conventional commits. Examples:
+
+- `feat: add per-player cobblestone counter command`
+- `fix(void): keep inventory when dying in lava void`
+- `docs: update README build instructions`
+- `chore: bump pom parent to 1.4.2`
+
+## Branch names
+
+`<type>/<short-kebab-description>` matching commit type. Example:
+`fix/void-keep-inventory`.
+
+## PR review
+
+- The bot (`pragent`) reviews every PR labelled `AI-REVIEW`. It reads
+  `.pr-review.json` from `main` + the static `architecture.md` from Nexus
+  raw-hosted. Adding a new house rule? Update both.
+- Add the `AI-USAGE` label if you want the bot to also post a token /
+  cost-equivalent report on the review.
+
+## Adding house rules
+
+If your PR changes how translatable components behave, how chat edits work,
+how stats are read, or how the Bedrock fallback is rendered, you must:
+
+1. Update the relevant section in the static `architecture.md` (upload a new
+   copy to Nexus raw-hosted at `canalhandia/architecture.md`).
+2. Bump `.pr-review.json:instructions` with a one-paragraph summary.
+3. Add a finding-checklist item to `.gitea/pull_request_template.md` *Risk*
+   section so PR authors know to confirm the rule.
+
+Bot does not detect house-rule drift automatically — these three updates
+together are the maintainer contract.
+
+## Rollback
+
+A single PR that bumps the plugin jar in `canalhandia-config` rolls back.
+Plugins are jar-swapped, no migrations.

README.md

@@ -610,3 +610,5 @@ phrase it so the count never has to agree with a translated noun.
 Statistic constants get renamed between Minecraft releases, so resolve them via
 `Stats.resolve("NEW_NAME", "OLD_NAME")` — a rename then degrades one curiosity
 instead of breaking the whole announcement.
+
+

specs/chunk-loader-module/plan.md

@@ -0,0 +1,37 @@
+# Plan: Módulo Nativo de Chunk Loader
+
+## Arquitetura
+1. **`ChunkLoader.java` (Record puro)**
+   - `id`, `ownerUuid`, `ownerName`, `world`, `x`, `y`, `z`, `chunkX`, `chunkZ`, `createdAt`.
+   - Métodos utilitários: `chunkCoords()`, `blockCoords()`, etc.
+
+2. **`ChunkLoaders.java` (Gerenciador e Persistência)**
+   - Gerencia lista em memória sincronizada `List<ChunkLoader>`.
+   - Persistência em `plugins/Canalhandia/chunks.yml` com salvamento assíncrono.
+   - Métodos: `add()`, `remove()`, `byChunk()`, `byOwner()`, `loadAll()`, `unloadAll()`, `playerLimit(Player)`.
+   - Executa `world.addPluginChunkTicket` e `world.removePluginChunkTicket`.
+
+3. **`Module.java` & `Settings.java`**
+   - Adiciona `CHUNKLOADER("chunkloader", "Âncoras de carregamento contínuo de chunks")` no enum `Module`.
+   - Adiciona configurações em `Settings.java` (limite padrão, material do bloco, raio de partículas).
+
+4. **`ChunkLoaderListener.java` (Eventos do Mundo)**
+   - `BlockPlaceEvent`: Detecta colocação da Âncora, verifica permissões/limites LuckPerms, registra loader e ticket.
+   - `BlockBreakEvent`: Protege quebra por não-donos, remove ticket e devolve o item customizado.
+   - `BlockExplodeEvent` / `EntityExplodeEvent`: Impede destruição por explosão.
+   - `BlockPistonExtendEvent` / `BlockPistonRetractEvent`: Impede movimentação por pistão.
+
+5. **`CanalhandiaCommand.java` & `ChunkLoaderCommand.java`**
+   - Subcomandos de `/chunkloader` / `/ancora` e tab-completion completo.
+
+6. **`BlueMapBridge.java`**
+   - Cria conjunto de marcadores para chunk loaders no mapa web.
+
+7. **Testes Unitários (`ChunkLoaderTest.java`)**
+   - Validação de regras de permissão, cálculo de limite, serialização em YAML e exclusão de duplicatas na mesma chunk.
+
+## Riscos & Mitigações
+- **Risco:** Descarregamento incorreto no shutdown do servidor gerando tickets órfãos.
+  - **Mitigação:** `unloadAll()` limpo em `onDisable()`, e tickets do Paper (`PluginChunkTicket`) são re-validados no `onEnable()`.
+- **Risco:** Jogador contornar limite colocando em mundos não permitidos ou múltiplas na mesma chunk.
+  - **Mitigação:** Validação estrita de unicidade de chunk (`byChunk(world, cx, cz) != null`) e verificação de limite antes de aceitar o evento.

specs/chunk-loader-module/spec.md

@@ -0,0 +1,72 @@
+# Spec: Módulo Nativo de Chunk Loader (Canalhandia)
+
+## 1. Visão Geral
+Adiciona ao plugin `Canalhandia` um módulo nativo, performático e equilibrado de **Chunk Loading** para o Paper 1.21.x.
+Permite que jogadores mantenham áreas/chunks específicas carregadas para farms, redstone e sistemas automatizados usando a API nativa de tickets do Paper (`addPluginChunkTicket`), com permissões granulares e limites por cargo configuráveis via **LuckPerms**.
+
+---
+
+## 2. Requisitos e Mecânicas
+
+### 2.1. Bloco e Item Customizado: "Âncora de Chunk" (Chunk Anchor)
+- **Item Base:** `RESPAWN_ANCHOR` ou `LODESTONE` com nome formatado (`§b§lÂncora de Chunk`), lore explicativa e `PersistentDataContainer` identificando o item customizado.
+- **Receita de Crafting:**
+  - Configurada em `config.yml` (ex: 4 Obsidianas Choronas, 4 Diamantes, 1 Estrela do Nether ou Olho do Fim).
+  - Desbloqueia automaticamente no livro de receitas ao obter os ingredientes.
+
+### 2.2. Colocação e Restrições
+- Ao colocar o bloco (`BlockPlaceEvent`):
+  - Verifica se o jogador possui permissão `canalhandia.chunkloader`.
+  - Verifica o limite de loaders do jogador no LuckPerms:
+    - Lê permissões numéricas: `canalhandia.chunkloader.limite.<N>` (ex: `limite.1`, `limite.2`, `limite.5`, `limite.10`).
+    - Pega o maior `<N>` encontrado nas permissões do jogador.
+    - Se não houver permissão numérica explícita, usa `chunkloader.limite-padrao` do `config.yml` (padrão: 1).
+    - Administradores com `canalhandia.admin` não têm limite.
+  - Verifica se já existe um loader ativo na mesma chunk (máximo 1 por chunk).
+  - Se aprovado:
+    - Ativa o ticket na chunk: `world.addPluginChunkTicket(chunkX, chunkZ, plugin)`.
+    - Salva em `chunks.yml`.
+    - Cria partícula/efeito sonoro de ativação.
+    - Registra marcador no BlueMap (opcional/configurável).
+    - Envia mensagem de confirmação informando quantas âncoras o jogador está usando (ex: `1/3 ativas`).
+
+### 2.3. Remoção e Proteção
+- **Proteção:** Apenas o dono da âncora ou administradores (`canalhandia.admin`) podem quebrar o bloco (`BlockBreakEvent`).
+- **Explosões / Pistões:** Protegido contra destruição acidental por TNT/Creeper (`EntityExplodeEvent`, `BlockExplodeEvent`) e empurrão por pistão (`BlockPistonExtendEvent`).
+- Ao quebrar:
+  - Remove o ticket de chunk do Paper: `world.removePluginChunkTicket(chunkX, chunkZ, plugin)`.
+  - Remove de `chunks.yml` e do BlueMap.
+  - Devolve o item "Âncora de Chunk" ao jogador.
+
+### 2.4. Persistência e Ciclo de Vida
+- Arquivo `plugins/Canalhandia/chunks.yml`:
+  - Armazena ID, UUID do dono, nome, mundo, coordenadas (x, y, z), chunk (cx, cz) e data de criação.
+- **No `onEnable()` do plugin:** Carrega `chunks.yml` e registra `addPluginChunkTicket` em todas as chunks salvas.
+- **No `onDisable()` do plugin:** Remove os tickets do plugin de forma limpa.
+
+### 2.5. Comandos (`/chunkloader` ou `/ancora`)
+- `/chunkloader` ou `/ancora`:
+  - `/chunkloader info` — Mostra o status da chunk atual (se está carregada por um loader e por quem) e seus limites de uso.
+  - `/chunkloader listar` — Lista todas as âncoras ativas do jogador com coordenadas e link para deletar/desativar.
+  - `/chunkloader remover <id>` — Desativa remotamente uma âncora do próprio jogador.
+  - `/chunkloader receita` — Mostra a receita de crafting.
+  - `/chunkloader admin listar [jogador]` — (Admin) Lista todos os chunk loaders do servidor.
+  - `/chunkloader admin remover <id>` — (Admin) Força a remoção de qualquer loader.
+  - `/chunkloader reload` — (Admin) Recarrega configurações e sincroniza tickets.
+
+---
+
+## 3. Integração com LuckPerms
+Nós de permissão:
+- `canalhandia.chunkloader` — Habilita o jogador a craftar, colocar e gerenciar âncoras.
+- `canalhandia.chunkloader.limite.<N>` — Define o limite máximo de âncoras ativas para o cargo (ex: `canalhandia.chunkloader.limite.3` para VIP).
+- `canalhandia.chunkloader.admin` — Acesso total aos comandos administrativos de chunk loading.
+
+---
+
+## 4. Critérios de Aceite
+1. Módulo pode ser ativado/desativado via `config.yml` e `/canalhandia modulo chunkloader`.
+2. Bloco colocado registra ticket via `world.addPluginChunkTicket` que sobrevive a reboots via `chunks.yml`.
+3. Limites de permissão do LuckPerms são respeitados estritamente.
+4. Blocos não podem ser roubados ou quebrados por terceiros.
+5. Suíte de testes unitários (`ChunkLoaderTest.java`) com 100% de aprovação.

specs/chunk-loader-module/tasks.md

@@ -0,0 +1,28 @@
+# Tasks: Módulo Nativo de Chunk Loader
+
+- [x] **Task 1: Modelo de Dados e Gerenciador (`ChunkLoader.java`, `ChunkLoaders.java` e `ChunkLoaderTest.java`)**
+  - Implementar record `ChunkLoader` puro.
+  - Implementar `ChunkLoaders` com persistência em `chunks.yml`, `playerLimit(Player)` (LuckPerms `canalhandia.chunkloader.limite.<N>`), registro de tickets no Paper e busca por chunk/dono.
+  - Criar suíte de testes unitários `ChunkLoaderTest.java` validando regras de limites, unicidade e serialização.
+
+- [x] **Task 2: Configuração e Item Customizado (`Module.java`, `Settings.java` e `ChunkAnchorItem.java`)**
+  - Adicionar `CHUNKLOADER` ao enum `Module`.
+  - Adicionar chaves de configuração em `config.yml` e `Settings.java`.
+  - Criar utilitário `ChunkAnchorItem` para gerar o ItemStack com nome, lore e `PersistentDataContainer`, e registrar receita de crafting.
+
+- [x] **Task 3: Listeners de Proteção e Colocação (`ChunkLoaderListener.java`)**
+  - Tratar `BlockPlaceEvent` (validação de permissão, cálculo de limite LuckPerms, ativação de ticket).
+  - Tratar `BlockBreakEvent` (proteção de dono/admin, remoção de ticket, drop do item).
+  - Tratar explosões e pistões.
+
+- [x] **Task 4: Comandos e Tab-Completion (`CanalhandiaCommand.java`)**
+  - Adicionar `/chunkloader` e alias `/ancora` (`listar`, `info`, `remover`, `receita`, `admin`).
+  - Implementar tab-completion completo com permissões.
+
+- [x] **Task 5: Integração no Ciclo de Vida e BlueMap (`Canalhandia.java` & `BlueMapBridge.java`)**
+  - Inicializar `ChunkLoaders` no `onEnable` e descarregar tickets no `onDisable`.
+  - Adicionar marcadores no BlueMap.
+
+- [x] **Task 6: Testes, PR e Deploy (`mvn test`, `mvn package`, PR no Gitea)**
+  - Executar suíte completa de testes.
+  - Criar branch `feat/chunk-loader-module`, abrir PR com labels `AI-REVIEW` e `AI-USAGE`.

specs/void-protection/spec.md

@@ -0,0 +1,23 @@
+# Spec: Proteção de Itens no Vácuo (Void Protection)
+
+## 1. Problema e Motivação
+Quando um jogador morre no vácuo (caindo no The End, Nether ou Overworld profundo), todos os itens e armaduras caem abaixo de Y = -64 e são excluídos pelo motor do Minecraft, impossibilitando qualquer recuperação legítima e gerando frustração.
+
+## 2. Solução
+Implementar o módulo `salvavoid` no plugin Canalhandia:
+1. **Detecção:** Identifica mortes por vácuo (`DamageCause.VOID` ou coordenada Y abaixo da altura mínima do mundo).
+2. **Busca de Terreno Seguro:** Procura o bloco sólido mais próximo da posição horizontal onde o jogador caiu (raio configurável, padrão 32 blocos).
+3. **Opção A (Baú de Resgate):** Se encontrar terreno seguro:
+   - Cria um baú (ou baú duplo se necessário) sobre o bloco seguro.
+   - Guarda todos os itens e armaduras do jogador dentro do baú.
+   - Limpa os drops do evento de morte (para não cair no vácuo).
+   - Informa ao jogador a localização exata (coordenadas X, Y, Z) do baú no chat.
+4. **Opção B (Preservação Direta no Inventário):** Se NÃO houver nenhum bloco seguro por perto (ex: caiu no meio do vácuo infinito do End):
+   - Preserva o inventário e nível de XP do jogador (`keepInventory = true`, `keepLevel = true`).
+   - Limpa os drops do evento de morte.
+   - Envia mensagem confortando o jogador e avisando que os itens foram mantidos no inventário.
+
+## 3. Critérios de Aceitação
+- Módulo integrado ao `/canalhandia modulo salvavoid <on|off>`.
+- Configurações em `Settings.java`: `voidProtectionEnabled`, `voidProtectionRadius`, `voidProtectionKeepXp`.
+- Testes unitários cobrindo detecção de morte no vácuo, cálculo de busca e empacotamento de inventário.

src/main/java/dev/marcospaulo/canalhandia/BlueMapBridge.java

@@ -27,18 +27,26 @@ final class BlueMapBridge {
     /** Id and label of the marker set this plugin owns on the map. */
     private static final String SET_ID = "canalhandia-notas";
     private static final String SET_LABEL = "Anotações";
+    private static final String SET_LOADERS_ID = "canalhandia-chunkloaders";
+    private static final String SET_LOADERS_LABEL = "Âncoras de Chunk";
 
     private final Notes notes;
+    private final java.util.function.Supplier<ChunkLoaders> chunkLoaders;
     private final Logger logger;
     private final java.util.function.BooleanSupplier enabled;
+    private final java.util.function.BooleanSupplier chunkLoadersEnabled;
 
     /** False once we know BlueMap is not usable, so we stop retrying. */
     private boolean available = true;
 
-    BlueMapBridge(Notes notes, Logger logger, java.util.function.BooleanSupplier enabled) {
+    BlueMapBridge(Notes notes, java.util.function.Supplier<ChunkLoaders> chunkLoaders,
+                  Logger logger, java.util.function.BooleanSupplier enabled,
+                  java.util.function.BooleanSupplier chunkLoadersEnabled) {
         this.notes = notes;
+        this.chunkLoaders = chunkLoaders;
         this.logger = logger;
         this.enabled = enabled;
+        this.chunkLoadersEnabled = chunkLoadersEnabled;
     }
 
     /**
@@ -47,20 +55,19 @@ final class BlueMapBridge {
      */
     void hook() {
         try {
-            de.bluecolored.bluemap.api.BlueMapAPI.onEnable(api -> sync());
-            logger.info("BlueMap encontrado — anotações públicas vão para o mapa.");
+            de.bluecolored.bluemap.api.BlueMapAPI.onEnable(api -> {
+                sync();
+                syncChunkLoaders();
+            });
+            logger.info("BlueMap encontrado — marcadores vão para o mapa.");
         } catch (NoClassDefFoundError | Exception e) {
             available = false;
-            logger.fine("BlueMap não está instalado; anotações ficam só no chat.");
+            logger.fine("BlueMap não está instalado; marcadores desativados.");
         }
     }
 
     /**
      * Rebuilds the marker set from the current public notes.
-     *
-     * <p>Rebuild rather than incremental add/remove: the note list is tiny, and
-     * a full rebuild cannot drift out of sync with the notes file the way a
-     * missed delete would.
      */
     void sync() {
         if (!available || !enabled.getAsBoolean()) {
@@ -79,9 +86,6 @@ final class BlueMapBridge {
                         .label(SET_LABEL)
                         .build();
                 for (Note note : publicNotes) {
-                    // Only notes from the world this map renders. Without the
-                    // check, a Nether note would be drawn at the same numeric
-                    // coordinates in the overworld map, pointing at nothing.
                     if (!sameWorld(map, note.world())) {
                         continue;
                     }
@@ -96,13 +100,66 @@ final class BlueMapBridge {
                 map.getMarkerSets().put(SET_ID, set);
             }
         } catch (NoClassDefFoundError | Exception e) {
-            // One line, then stop trying: a broken bridge must never turn into
-            // a log flood on every note edit.
             available = false;
             logger.warning("Não consegui atualizar os marcadores do BlueMap: " + e);
         }
     }
 
+    void syncChunkLoaders() {
+        if (!available || !chunkLoadersEnabled.getAsBoolean() || chunkLoaders == null) {
+            return;
+        }
+        ChunkLoaders loaders = chunkLoaders.get();
+        if (loaders == null) {
+            return;
+        }
+        try {
+            var maybeApi = de.bluecolored.bluemap.api.BlueMapAPI.getInstance();
+            if (maybeApi.isEmpty()) {
+                return;
+            }
+            var api = maybeApi.get();
+            for (var map : api.getMaps()) {
+                var set = de.bluecolored.bluemap.api.markers.MarkerSet.builder()
+                        .label(SET_LOADERS_LABEL)
+                        .build();
+                for (ChunkLoader loader : loaders.all()) {
+                    if (!mapMatchesWorld(map, loader.world())) {
+                        continue;
+                    }
+                    String statusHtml = loader.enabled()
+                            ? "<span style='color:#55ff55'>Ativo</span>"
+                            : "<span style='color:#ff5555'>Pausado</span>";
+                    var marker = de.bluecolored.bluemap.api.markers.POIMarker.builder()
+                            .label(loader.simpleName() + " (" + loader.ownerName() + ")" + (loader.enabled() ? "" : " [Pausado]"))
+                            .detail("<b>" + escape(loader.displayName()) + "</b><br>Status: "
+                                    + statusHtml + "<br>Dono: "
+                                    + escape(loader.ownerName()) + "<br>Chunk: " + loader.chunkCoords())
+                            .position(loader.x(), loader.y(), loader.z())
+                            .build();
+                    set.getMarkers().put("loader-" + loader.id(), marker);
+                }
+                map.getMarkerSets().put(SET_LOADERS_ID, set);
+            }
+        } catch (NoClassDefFoundError | Exception ignored) {
+        }
+    }
+
+    private boolean mapMatchesWorld(de.bluecolored.bluemap.api.BlueMapMap map, String world) {
+        if (world == null || world.isBlank()) {
+            return false;
+        }
+        String mapId = map.getId().toLowerCase(java.util.Locale.ROOT);
+        String w = world.toLowerCase(java.util.Locale.ROOT);
+        if (w.endsWith("_nether") || w.equals("nether") || w.equals("world_nether")) {
+            return mapId.contains("nether");
+        }
+        if (w.endsWith("_the_end") || w.equals("the_end") || w.equals("world_the_end") || w.equals("end")) {
+            return mapId.contains("end");
+        }
+        return !mapId.contains("nether") && !mapId.contains("end");
+    }
+
     /**
      * Whether a map renders the world a note was written in.
      *

src/main/java/dev/marcospaulo/canalhandia/Canalhandia.java

@@ -86,6 +86,7 @@ public final class Canalhandia extends JavaPlugin implements Listener {
     private Achievements achievements;
     private WeeklyStats weeklyStats;
     private PlayerMemory playerMemory;
+    private ChunkLoaders chunkLoaders;
     /** Gate for spontaneous AI lines; see Budget for why this is strict. */
     private Budget aiBudget;
     private BlueMapBridge blueMap;
@@ -127,13 +128,20 @@ public final class Canalhandia extends JavaPlugin implements Listener {
         milestones.resyncSilently();
         weeklyStats = new WeeklyStats(new java.io.File(getDataFolder(), "semana.yml"));
         playerMemory = new PlayerMemory(new java.io.File(getDataFolder(), "ia-memoria.yml"));
+        chunkLoaders = new ChunkLoaders(this, new java.io.File(getDataFolder(), "chunks.yml"));
+        if (settings.moduleEnabled(Module.CHUNKLOADER)) {
+            chunkLoaders.loadAllTickets();
+            chunkLoaders.startSimulation();
+            ChunkAnchorItem.registerRecipe(this);
+        }
         aiBudget = new Budget(settings.aiSpontaneousPerDay(),
                 settings.aiSpontaneousGapMinutes() * 60_000L,
                 settings.aiSubjectCooldownMinutes() * 60_000L);
         ai = new Ai(this);
         // Optional: does nothing (and logs nothing loud) without BlueMap.
-        blueMap = new BlueMapBridge(notes, getLogger(),
-                () -> settings.moduleEnabled(Module.NOTAS) && settings.notesOnMap());
+        blueMap = new BlueMapBridge(notes, () -> chunkLoaders, getLogger(),
+                () -> settings.moduleEnabled(Module.NOTAS) && settings.notesOnMap(),
+                () -> settings.moduleEnabled(Module.CHUNKLOADER) && settings.chunkLoaderBlueMap());
         blueMap.hook();
         // Snapshot the server's recipes on the main thread; RecipeBook.describe
         // reads from the async answer path and Bukkit.recipeIterator() is not
@@ -146,12 +154,14 @@ public final class Canalhandia extends JavaPlugin implements Listener {
         for (String name : List.of("canalhandia", "curiosidade", "adivinha", "enquete", "ranking",
                 "reagir", "reacoes", "palpite", "votar", "legal", "wow", "top", "f", "ia", "iap",
                 "errado", "nota", "save", "recado", "recados", "mortes", "conquistas",
-                "perfil", "titulo")) {
+                "perfil", "titulo", "chunkloader")) {
             register(name, root);
         }
 
         getServer().getPluginManager().registerEvents(this, this);
         getServer().getPluginManager().registerEvents(new TitleChatListener(this), this);
+        getServer().getPluginManager().registerEvents(new ChunkLoaderListener(this), this);
+        getServer().getPluginManager().registerEvents(new XpAndItemMergeListener(this), this);
         rescheduleTimer();
         rescheduleMilestones();
 
@@ -183,6 +193,12 @@ public final class Canalhandia extends JavaPlugin implements Listener {
         if (poll != null) {
             poll.hide();
         }
+        if (chunkLoaders != null) {
+            chunkLoaders.stopSimulation();
+            chunkLoaders.unloadAllTickets();
+            chunkLoaders.close();
+            ChunkAnchorItem.unregisterRecipe(this);
+        }
     }
 
     Settings settings() {
@@ -227,6 +243,11 @@ public final class Canalhandia extends JavaPlugin implements Listener {
         return achievements;
     }
 
+    /** Active chunk loaders. Never null. */
+    ChunkLoaders chunkLoaders() {
+        return chunkLoaders;
+    }
+
     /** The title each player has chosen to wear in chat. Never null. */
     Titles titles() {
         return titles;
@@ -819,6 +840,60 @@ public final class Canalhandia extends JavaPlugin implements Listener {
         }, settings.reactionWindowSeconds() * 20L);
     }
 
+    /**
+     * Rescues player items when falling into the void. Places a chest on the nearest
+     * safe ground block, or preserves items directly in the inventory if no solid ground is nearby.
+     */
+    @EventHandler(priority = EventPriority.HIGH)
+    public void onVoidDeath(PlayerDeathEvent event) {
+        if (!settings.moduleEnabled(Module.SALVAVOID)) {
+            return;
+        }
+        Player player = event.getEntity();
+        EntityDamageEvent damage = player.getLastDamageCause();
+        EntityDamageEvent.DamageCause cause = damage == null ? null : damage.getCause();
+
+        if (!VoidProtection.isVoidDeath(player.getLocation().getY(), player.getWorld().getMinHeight(), cause)) {
+            return;
+        }
+
+        List<ItemStack> drops = new ArrayList<>(event.getDrops());
+        Location safeLoc = VoidProtection.findSafeChestLocation(player.getWorld(), player.getLocation(), settings.voidProtectionRadius());
+
+        if (safeLoc != null && !drops.isEmpty() && VoidProtection.rescueToChest(drops, safeLoc)) {
+            event.getDrops().clear();
+            if (settings.voidProtectionKeepXp()) {
+                event.setKeepLevel(true);
+                event.setDroppedExp(0);
+            }
+            int x = safeLoc.getBlockX();
+            int y = safeLoc.getBlockY();
+            int z = safeLoc.getBlockZ();
+            getServer().getScheduler().runTaskLater(this, () -> {
+                if (player.isOnline()) {
+                    player.sendMessage(Component.text("[Canalhandia] ", NamedTextColor.GOLD)
+                            .append(Component.text("Você caiu no vácuo! Seus itens foram guardados em segurança num baú em ", NamedTextColor.YELLOW))
+                            .append(Component.text(x + ", " + y + ", " + z, NamedTextColor.AQUA, TextDecoration.BOLD))
+                            .append(Component.text(".", NamedTextColor.YELLOW)));
+                }
+            }, 20L);
+        } else {
+            // No safe ground found within radius: keep inventory directly
+            event.setKeepInventory(true);
+            event.getDrops().clear();
+            if (settings.voidProtectionKeepXp()) {
+                event.setKeepLevel(true);
+                event.setDroppedExp(0);
+            }
+            getServer().getScheduler().runTaskLater(this, () -> {
+                if (player.isOnline()) {
+                    player.sendMessage(Component.text("[Canalhandia] ", NamedTextColor.GOLD)
+                            .append(Component.text("Você caiu no vácuo sem terra firme por perto! Seus itens foram mantidos no seu inventário.", NamedTextColor.GREEN)));
+                }
+            }, 20L);
+        }
+    }
+
     /**
      * Comic death broadcast + private coordinates, gated by the {@code mortes}
      * module. Replaces the vanilla translatable death message with a pt-BR
@@ -862,7 +937,7 @@ public final class Canalhandia extends JavaPlugin implements Listener {
         Location loc = player.getLocation();
         String coords = loc.getBlockX() + " " + loc.getBlockY() + " " + loc.getBlockZ()
                 + " (" + loc.getWorld().getName() + ")";
-        boolean keepInventory = Boolean.TRUE.equals(
+        boolean keepInventory = event.getKeepInventory() || Boolean.TRUE.equals(
                 loc.getWorld().getGameRuleValue(GameRule.KEEP_INVENTORY));
         pendingDeathCoords.put(player.getUniqueId(), new DeathCoords(coords, keepInventory));
 

src/main/java/dev/marcospaulo/canalhandia/CanalhandiaCommand.java

@@ -5,11 +5,14 @@ import net.kyori.adventure.text.event.ClickEvent;
 import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabCompleter;
 import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -62,6 +65,7 @@ final class CanalhandiaCommand implements CommandExecutor, TabCompleter {
             case "conquistas" -> conquistas(sender, args);
             case "perfil" -> perfil(sender, args);
             case "titulo" -> titulo(sender, args);
+            case "chunkloader", "ancora", "ancoras", "chunkloaders" -> chunkloader(sender, args);
             // Typed twin of the [F] mourning button — "f" is not a configured
             // reaction (the mourning set is hardcoded), so it can't be found via
             // reactionForCommand; route it directly. Acts on the latest message,
@@ -563,6 +567,18 @@ final class CanalhandiaCommand implements CommandExecutor, TabCompleter {
         }
         boolean on = args[1].equalsIgnoreCase("on");
         plugin.settings().moduleEnabled(module, on);
+        if (module == Module.CHUNKLOADER) {
+            if (on) {
+                plugin.chunkLoaders().loadAllTickets();
+                plugin.chunkLoaders().startSimulation();
+                ChunkAnchorItem.registerRecipe(plugin);
+            } else {
+                plugin.chunkLoaders().stopSimulation();
+                plugin.chunkLoaders().unloadAllTickets();
+                ChunkAnchorItem.unregisterRecipe(plugin);
+            }
+            plugin.blueMap().syncChunkLoaders();
+        }
         plugin.rescheduleTimer();
         plugin.rescheduleMilestones();
         Msg.ok(sender, "Módulo " + module.label() + " " + (on ? "ativado" : "desativado") + ".");
@@ -1514,8 +1530,10 @@ final class CanalhandiaCommand implements CommandExecutor, TabCompleter {
             }
             return true;
         }
-        String arg = String.join(" ", args);
-        if (arg.equalsIgnoreCase("limpar") || arg.equalsIgnoreCase("nenhum")) {
+        String arg = String.join(" ", args).trim();
+        if (arg.equalsIgnoreCase("limpar") || arg.equalsIgnoreCase("nenhum")
+                || arg.equalsIgnoreCase("remover") || arg.equalsIgnoreCase("remove")
+                || arg.equalsIgnoreCase("clear")) {
             plugin.titles().clear(player.getUniqueId());
             Msg.ok(player, Lang.tr("canalhandia.cmd.titulo.removido"));
             return true;
@@ -1530,20 +1548,37 @@ final class CanalhandiaCommand implements CommandExecutor, TabCompleter {
         return true;
     }
 
-    /** Matches typed text to an earned achievement by key or (case-insensitive) title. */
+    /** Matches typed text to an earned achievement by key, title, or accent-normalized text. */
     static Achievement matchEarned(String text, List<Achievement> earned) {
-        Achievement byKey = Achievement.byKey(text);
+        if (text == null || text.isBlank() || earned == null || earned.isEmpty()) {
+            return null;
+        }
+        String clean = text.trim();
+        Achievement byKey = Achievement.byKey(clean);
         if (byKey != null && earned.contains(byKey)) {
             return byKey;
         }
         for (Achievement achievement : earned) {
-            if (achievement.title().equalsIgnoreCase(text.trim())) {
+            if (achievement.title().equalsIgnoreCase(clean)) {
+                return achievement;
+            }
+        }
+        String normalizedClean = normalizeText(clean);
+        for (Achievement achievement : earned) {
+            if (normalizeText(achievement.title()).equalsIgnoreCase(normalizedClean)
+                    || normalizeText(achievement.key()).equalsIgnoreCase(normalizedClean)) {
                 return achievement;
             }
         }
         return null;
     }
 
+    private static String normalizeText(String input) {
+        if (input == null) return "";
+        return java.text.Normalizer.normalize(input, java.text.Normalizer.Form.NFD)
+                .replaceAll("\\p{M}", "");
+    }
+
     private static String titlesList(List<Achievement> earned) {
         List<String> names = new ArrayList<>();
         for (Achievement achievement : earned) {
@@ -1783,6 +1818,451 @@ final class CanalhandiaCommand implements CommandExecutor, TabCompleter {
         return true;
     }
 
+    // --- /chunkloader -------------------------------------------------------
+
+    private boolean chunkloader(CommandSender sender, String[] args) {
+        if (!plugin.settings().moduleEnabled(Module.CHUNKLOADER)) {
+            Msg.error(sender, "O módulo de Âncoras de Chunk está desativado.");
+            return true;
+        }
+        if (!sender.hasPermission("canalhandia.chunkloader")) {
+            return denied(sender);
+        }
+
+        if (args.length == 0) {
+            return chunkloaderHelp(sender);
+        }
+
+        String sub = args[0].toLowerCase(Locale.ROOT);
+        String[] rest = Arrays.copyOfRange(args, 1, args.length);
+
+        switch (sub) {
+            case "listar", "list" -> chunkloaderList(sender, rest);
+            case "info", "chunk" -> chunkloaderInfo(sender);
+            case "remover", "remove", "del" -> chunkloaderRemove(sender, rest);
+            case "receita", "craft" -> chunkloaderRecipe(sender);
+            case "limite", "limit" -> chunkloaderLimit(sender, rest);
+            case "nome", "renomear", "rename" -> chunkloaderRename(sender, rest);
+            case "ativar", "enable" -> chunkloaderSetEnabled(sender, rest, true);
+            case "desativar", "pausar", "disable", "pause" -> chunkloaderSetEnabled(sender, rest, false);
+            case "tempo", "abastecer", "fuel" -> chunkloaderTime(sender, rest);
+            case "admin" -> chunkloaderAdmin(sender, rest);
+            case "dar", "give" -> {
+                if (admin(sender)) {
+                    chunkloaderGive(sender, rest);
+                }
+            }
+            default -> chunkloaderHelp(sender);
+        }
+        return true;
+    }
+
+    private void chunkloaderList(CommandSender sender, String[] args) {
+        if (!(sender instanceof Player player)) {
+            chunkloaderAdminList(sender, args.length > 0 ? args[0] : null);
+            return;
+        }
+
+        List<ChunkLoader> mine = plugin.chunkLoaders().byOwner(player.getUniqueId().toString());
+        int limit = ChunkLoaders.playerLimit(player, plugin.settings().chunkLoaderDefaultLimit());
+        String limitStr = limit == Integer.MAX_VALUE ? "ilimitado" : String.valueOf(limit);
+
+        Msg.header(sender, "Suas Âncoras de Chunk (" + mine.size() + "/" + limitStr + ")");
+        if (mine.isEmpty()) {
+            sender.sendMessage(Component.text("  Você não possui nenhuma Âncora de Chunk ativa.", NamedTextColor.GRAY));
+            sender.sendMessage(Component.text("  Use ", NamedTextColor.GRAY)
+                    .append(Component.text("/chunkloader receita", NamedTextColor.AQUA))
+                    .append(Component.text(" para ver como criar uma.", NamedTextColor.GRAY)));
+            return;
+        }
+
+        boolean bedrock = isBedrock(sender);
+        for (ChunkLoader loader : mine) {
+            String statusText = loader.enabled() ? "[Ativa]" : "[Pausada]";
+            NamedTextColor statusColor = loader.enabled() ? NamedTextColor.GREEN : NamedTextColor.RED;
+
+            Component line = Component.text("  " + loader.displayName() + " ", NamedTextColor.AQUA)
+                    .append(Component.text(loader.place() + " " + loader.chunkCoords() + " ", NamedTextColor.WHITE))
+                    .append(Component.text(statusText + " ", statusColor))
+                    .append(Component.text("[" + loader.timeLeft() + "]", NamedTextColor.GOLD));
+
+            if (!bedrock) {
+                if (loader.enabled()) {
+                    line = line.append(Component.text(" [Pausar]", NamedTextColor.YELLOW)
+                            .hoverEvent(net.kyori.adventure.text.event.HoverEvent.showText(
+                                    Component.text("Clique para pausar " + loader.displayName(), NamedTextColor.GRAY)))
+                            .clickEvent(net.kyori.adventure.text.event.ClickEvent.runCommand(
+                                    "/chunkloader desativar " + loader.id())));
+                } else {
+                    line = line.append(Component.text(" [Ativar]", NamedTextColor.GREEN)
+                            .hoverEvent(net.kyori.adventure.text.event.HoverEvent.showText(
+                                    Component.text("Clique para reativar " + loader.displayName(), NamedTextColor.GRAY)))
+                            .clickEvent(net.kyori.adventure.text.event.ClickEvent.runCommand(
+                                    "/chunkloader ativar " + loader.id())));
+                }
+                line = line.append(Component.text(" [Remover]", NamedTextColor.RED)
+                        .hoverEvent(net.kyori.adventure.text.event.HoverEvent.showText(
+                                Component.text("Clique para recolher " + loader.displayName(), NamedTextColor.GRAY)))
+                        .clickEvent(net.kyori.adventure.text.event.ClickEvent.suggestCommand(
+                                "/chunkloader remover " + loader.id())));
+            }
+            sender.sendMessage(line);
+        }
+    }
+
+    private void chunkloaderInfo(CommandSender sender) {
+        if (!(sender instanceof Player player)) {
+            Msg.error(sender, "Comando exclusivo para jogadores.");
+            return;
+        }
+
+        Location loc = player.getLocation();
+        String world = loc.getWorld().getName();
+        int cx = loc.getBlockX() >> 4;
+        int cz = loc.getBlockZ() >> 4;
+
+        ChunkLoader here = plugin.chunkLoaders().byChunk(world, cx, cz);
+        int limit = ChunkLoaders.playerLimit(player, plugin.settings().chunkLoaderDefaultLimit());
+        int used = plugin.chunkLoaders().byOwner(player.getUniqueId().toString()).size();
+        String limitStr = limit == Integer.MAX_VALUE ? "ilimitado" : String.valueOf(limit);
+
+        Msg.header(sender, "Informações da Chunk");
+        sender.sendMessage(Component.text("  Chunk atual: ", NamedTextColor.GRAY)
+                .append(Component.text("[" + cx + ", " + cz + "]", NamedTextColor.AQUA))
+                .append(Component.text(" em " + world, NamedTextColor.WHITE)));
+
+        if (here != null) {
+            String status = here.enabled() ? "Ativa" : "Pausada";
+            NamedTextColor statusCol = here.enabled() ? NamedTextColor.GREEN : NamedTextColor.RED;
+            sender.sendMessage(Component.text("  Status: ", NamedTextColor.GRAY)
+                    .append(Component.text(here.displayName() + " (" + status + ")", statusCol))
+                    .append(Component.text(" de " + here.ownerName(), NamedTextColor.WHITE)));
+            sender.sendMessage(Component.text("  Tempo restante: ", NamedTextColor.GRAY)
+                    .append(Component.text(here.timeLeft(), NamedTextColor.GOLD)));
+        } else {
+            sender.sendMessage(Component.text("  Status: ", NamedTextColor.GRAY)
+                    .append(Component.text("Carregamento normal (sem âncora)", NamedTextColor.DARK_GRAY)));
+        }
+
+        sender.sendMessage(Component.text("  Suas âncoras ativas: ", NamedTextColor.GRAY)
+                .append(Component.text(used + "/" + limitStr, NamedTextColor.YELLOW)));
+    }
+
+    private void chunkloaderRename(CommandSender sender, String[] args) {
+        if (args.length < 2) {
+            Msg.error(sender, "Uso: /chunkloader nome <id|nome_antigo> <novo_nome>");
+            return;
+        }
+        ChunkLoader loader = plugin.chunkLoaders().find(args[0]);
+        if (loader == null) {
+            Msg.error(sender, "Nenhuma âncora encontrada para '" + args[0] + "'.");
+            return;
+        }
+        boolean isOwner = sender instanceof Player player && player.getUniqueId().toString().equalsIgnoreCase(loader.ownerUuid());
+        boolean isAdmin = sender.hasPermission(ADMIN) || sender.hasPermission("canalhandia.chunkloader.admin");
+        if (!isOwner && !isAdmin) {
+            Msg.error(sender, "Esta âncora pertence a " + loader.ownerName() + ".");
+            return;
+        }
+        String newName = String.join(" ", Arrays.copyOfRange(args, 1, args.length)).trim();
+        if (newName.length() > 32) {
+            Msg.error(sender, "Nome muito longo (máximo 32 caracteres).");
+            return;
+        }
+        plugin.chunkLoaders().rename(loader.id(), newName);
+        plugin.blueMap().syncChunkLoaders();
+        Msg.ok(sender, "Âncora #" + loader.id() + " renomeada para '" + newName + "'.");
+    }
+
+    private void chunkloaderSetEnabled(CommandSender sender, String[] args, boolean enabled) {
+        if (args.length < 1) {
+            Msg.error(sender, "Uso: /chunkloader " + (enabled ? "ativar" : "desativar") + " <id|nome>");
+            return;
+        }
+        ChunkLoader loader = plugin.chunkLoaders().find(args[0]);
+        if (loader == null) {
+            Msg.error(sender, "Nenhuma âncora encontrada para '" + args[0] + "'.");
+            return;
+        }
+        boolean isOwner = sender instanceof Player player && player.getUniqueId().toString().equalsIgnoreCase(loader.ownerUuid());
+        boolean isAdmin = sender.hasPermission(ADMIN) || sender.hasPermission("canalhandia.chunkloader.admin");
+        if (!isOwner && !isAdmin) {
+            Msg.error(sender, "Esta âncora pertence a " + loader.ownerName() + ".");
+            return;
+        }
+        if (loader.enabled() == enabled) {
+            Msg.error(sender, "A âncora " + loader.displayName() + " já está " + (enabled ? "ativa" : "pausada") + ".");
+            return;
+        }
+        if (enabled && loader.isExpired()) {
+            Msg.error(sender, "A âncora " + loader.displayName() + " está expirada! Adicione tempo (/chunkloader tempo " + loader.id() + " <horas>) ou abasteça com combustível antes de reativar.");
+            return;
+        }
+        plugin.chunkLoaders().setEnabled(loader.id(), enabled);
+        plugin.blueMap().syncChunkLoaders();
+        Msg.ok(sender, "Âncora " + loader.displayName() + " " + (enabled ? "ATIVADA." : "PAUSADA/DESATIVADA."));
+    }
+
+    private void chunkloaderTime(CommandSender sender, String[] args) {
+        if (args.length < 2) {
+            Msg.error(sender, "Uso: /chunkloader tempo <id|nome> <horas>");
+            return;
+        }
+        ChunkLoader loader = plugin.chunkLoaders().find(args[0]);
+        if (loader == null) {
+            Msg.error(sender, "Nenhuma âncora encontrada para '" + args[0] + "'.");
+            return;
+        }
+        boolean isOwner = sender instanceof Player player && player.getUniqueId().toString().equalsIgnoreCase(loader.ownerUuid());
+        boolean isAdmin = sender.hasPermission(ADMIN) || sender.hasPermission("canalhandia.chunkloader.admin");
+        if (!isOwner && !isAdmin) {
+            Msg.error(sender, "Esta âncora pertence a " + loader.ownerName() + ".");
+            return;
+        }
+        try {
+            double hours = Double.parseDouble(args[1]);
+            if (hours <= 0) {
+                if (isAdmin) {
+                    plugin.chunkLoaders().setExpiresAt(loader.id(), 0L); // permanent
+                    Msg.ok(sender, "Âncora " + loader.displayName() + " definida como PERMANENTE.");
+                } else {
+                    Msg.error(sender, "A quantidade de horas deve ser maior que zero.");
+                }
+                return;
+            }
+            long millis = (long) (hours * 3600_000L);
+            plugin.chunkLoaders().addTime(loader.id(), millis);
+            ChunkLoader updated = plugin.chunkLoaders().byId(loader.id());
+            String time = (updated != null) ? updated.timeLeft() : "Permanente";
+            Msg.ok(sender, "Adicionado " + hours + "h à âncora " + loader.displayName() + ". Tempo restante: " + time);
+            plugin.blueMap().syncChunkLoaders();
+        } catch (NumberFormatException e) {
+            Msg.error(sender, "Horas inválidas: " + args[1]);
+        }
+    }
+
+    private void chunkloaderRemove(CommandSender sender, String[] args) {
+        if (args.length < 1) {
+            Msg.error(sender, "Uso: /chunkloader remover <id|nome>");
+            return;
+        }
+
+        ChunkLoader loader = plugin.chunkLoaders().find(args[0]);
+        if (loader == null) {
+            Msg.error(sender, "Nenhuma Âncora de Chunk encontrada para '" + args[0] + "'.");
+            return;
+        }
+
+        long id = loader.id();
+        boolean isOwner = sender instanceof Player player && player.getUniqueId().toString().equalsIgnoreCase(loader.ownerUuid());
+        boolean isAdmin = sender.hasPermission(ADMIN) || sender.hasPermission("canalhandia.chunkloader.admin");
+
+        if (!isOwner && !isAdmin) {
+            Msg.error(sender, "Esta âncora pertence a " + loader.ownerName() + ".");
+            return;
+        }
+
+        plugin.chunkLoaders().remove(id);
+        plugin.blueMap().syncChunkLoaders();
+
+        try {
+            org.bukkit.World w = Bukkit.getWorld(loader.world());
+            if (w != null && w.isChunkLoaded(loader.chunkX(), loader.chunkZ())) {
+                Block b = w.getBlockAt(loader.x(), loader.y(), loader.z());
+                if (b.getType() == Material.RESPAWN_ANCHOR) {
+                    b.setType(Material.AIR);
+                }
+            }
+        } catch (Exception ignored) {
+        }
+
+        if (sender instanceof Player player) {
+            Map<Integer, ItemStack> overflow = player.getInventory().addItem(ChunkAnchorItem.create(plugin, 1));
+            for (ItemStack drop : overflow.values()) {
+                player.getWorld().dropItemNaturally(player.getLocation(), drop);
+            }
+            Msg.ok(sender, "Âncora de Chunk " + loader.displayName() + " desativada e devolvida ao inventário.");
+        } else {
+            try {
+                org.bukkit.World w = Bukkit.getWorld(loader.world());
+                if (w != null) {
+                    w.dropItemNaturally(new Location(w, loader.x() + 0.5, loader.y() + 0.5, loader.z() + 0.5),
+                            ChunkAnchorItem.create(plugin, 1));
+                }
+            } catch (Exception ignored) {
+            }
+            Msg.ok(sender, "Âncora de Chunk " + loader.displayName() + " desativada e dropada em " + loader.place() + ".");
+        }
+    }
+
+    private void chunkloaderRecipe(CommandSender sender) {
+        Msg.header(sender, "Receita da Âncora de Chunk");
+        sender.sendMessage(Component.text("  Na Bancada de Trabalho:", NamedTextColor.GRAY));
+        sender.sendMessage(Component.text("    [ D ] [ O ] [ D ]", NamedTextColor.AQUA));
+        sender.sendMessage(Component.text("    [ O ] [ E ] [ O ]", NamedTextColor.LIGHT_PURPLE));
+        sender.sendMessage(Component.text("    [ D ] [ O ] [ D ]", NamedTextColor.AQUA));
+        sender.sendMessage(Component.text("  D = Diamante  |  O = Obsidiana Chorona  |  E = Olho do Fim", NamedTextColor.YELLOW));
+    }
+
+    private void chunkloaderAdmin(CommandSender sender, String[] args) {
+        if (!admin(sender)) {
+            return;
+        }
+        if (args.length == 0) {
+            Msg.header(sender, "Admin Chunk Loaders");
+            sender.sendMessage(Component.text("  /chunkloader admin listar [jogador]", NamedTextColor.AQUA));
+            sender.sendMessage(Component.text("  /chunkloader admin remover <id>", NamedTextColor.AQUA));
+            sender.sendMessage(Component.text("  /chunkloader dar <jogador> [quantidade]", NamedTextColor.AQUA));
+            return;
+        }
+
+        switch (args[0].toLowerCase(Locale.ROOT)) {
+            case "listar", "list" -> chunkloaderAdminList(sender, args.length > 1 ? args[1] : null);
+            case "remover", "del" -> {
+                if (args.length < 2) {
+                    Msg.error(sender, "Uso: /chunkloader admin remover <id>");
+                    return;
+                }
+                chunkloaderRemove(sender, new String[]{args[1]});
+            }
+            case "dar", "give" -> chunkloaderGive(sender, Arrays.copyOfRange(args, 1, args.length));
+            default -> Msg.error(sender, "Subcomando de admin desconhecido.");
+        }
+    }
+
+    private void chunkloaderAdminList(CommandSender sender, String targetName) {
+        List<ChunkLoader> all = plugin.chunkLoaders().all();
+        if (targetName != null && !targetName.isBlank()) {
+            all = all.stream().filter(l -> l.ownerName().equalsIgnoreCase(targetName)).toList();
+        }
+
+        Msg.header(sender, "Todas as Âncoras do Servidor (" + all.size() + ")");
+        if (all.isEmpty()) {
+            sender.sendMessage(Component.text("  Nenhuma âncora ativa encontrada.", NamedTextColor.GRAY));
+            return;
+        }
+
+        for (ChunkLoader loader : all) {
+            sender.sendMessage(Component.text("  #" + loader.id() + " ", NamedTextColor.AQUA)
+                    .append(Component.text(loader.ownerName(), NamedTextColor.YELLOW))
+                    .append(Component.text(" — " + loader.place() + " " + loader.chunkCoords(), NamedTextColor.WHITE)));
+        }
+    }
+
+    private void chunkloaderGive(CommandSender sender, String[] args) {
+        if (args.length < 1) {
+            Msg.error(sender, "Uso: /chunkloader dar <jogador> [quantidade]");
+            return;
+        }
+
+        Player target = Bukkit.getPlayer(args[0]);
+        if (target == null) {
+            Msg.error(sender, "Jogador não encontrado: " + args[0]);
+            return;
+        }
+
+        int amount = 1;
+        if (args.length >= 2) {
+            try {
+                amount = Math.max(1, Integer.parseInt(args[1]));
+            } catch (NumberFormatException ignored) {
+            }
+        }
+
+        target.getInventory().addItem(ChunkAnchorItem.create(plugin, amount));
+        Msg.ok(sender, "Entregue " + amount + "x Âncora de Chunk para " + target.getName() + ".");
+        Msg.ok(target, "Você recebeu " + amount + "x Âncora de Chunk!");
+    }
+
+    private void chunkloaderLimit(CommandSender sender, String[] args) {
+        if (args.length == 0) {
+            int defaultLimit = plugin.settings().chunkLoaderDefaultLimit();
+            Msg.header(sender, "Limite de Âncoras de Chunk");
+            sender.sendMessage(Component.text("  Limite padrão global: ", NamedTextColor.GRAY)
+                    .append(Component.text(defaultLimit, NamedTextColor.YELLOW)));
+            if (sender instanceof Player player) {
+                int myLimit = ChunkLoaders.playerLimit(player, defaultLimit);
+                String myLimitStr = myLimit == Integer.MAX_VALUE ? "ilimitado" : String.valueOf(myLimit);
+                int current = plugin.chunkLoaders().byOwner(player.getUniqueId().toString()).size();
+                sender.sendMessage(Component.text("  Seu limite atual: ", NamedTextColor.GRAY)
+                        .append(Component.text(current + "/" + myLimitStr, NamedTextColor.AQUA)));
+            }
+            if (admin(sender)) {
+                sender.sendMessage(Component.text("  Alterar padrão global: ", NamedTextColor.GRAY)
+                        .append(Component.text("/chunkloader limite padrao <quantidade>", NamedTextColor.YELLOW)));
+                sender.sendMessage(Component.text("  Definir por jogador (LuckPerms): ", NamedTextColor.GRAY)
+                        .append(Component.text("/chunkloader limite <jogador> <quantidade>", NamedTextColor.YELLOW)));
+            }
+            return;
+        }
+
+        if (!admin(sender)) {
+            return;
+        }
+
+        if (args[0].equalsIgnoreCase("padrao") || args[0].equalsIgnoreCase("default")) {
+            if (args.length < 2) {
+                Msg.error(sender, "Uso: /chunkloader limite padrao <quantidade>");
+                return;
+            }
+            try {
+                int newLimit = Math.max(0, Integer.parseInt(args[1]));
+                plugin.settings().chunkLoaderDefaultLimit(newLimit);
+                Msg.ok(sender, "Limite padrão global de Âncoras alterado para " + newLimit + ".");
+            } catch (NumberFormatException e) {
+                Msg.error(sender, "Quantidade inválida: " + args[1]);
+            }
+            return;
+        }
+
+        Player target = Bukkit.getPlayerExact(args[0]);
+        if (target == null) {
+            Msg.error(sender, "Jogador '" + args[0] + "' não encontrado online.");
+            return;
+        }
+        if (args.length < 2) {
+            int targetLimit = ChunkLoaders.playerLimit(target, plugin.settings().chunkLoaderDefaultLimit());
+            String str = targetLimit == Integer.MAX_VALUE ? "ilimitado" : String.valueOf(targetLimit);
+            int current = plugin.chunkLoaders().byOwner(target.getUniqueId().toString()).size();
+            Msg.ok(sender, "Limite de " + target.getName() + ": " + current + "/" + str + " âncoras ativas.");
+            return;
+        }
+        try {
+            int newLimit = Math.max(0, Integer.parseInt(args[1]));
+            Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "lp user " + target.getName() + " permission set canalhandia.chunkloader.limite." + newLimit);
+            Msg.ok(sender, "Limite de " + target.getName() + " definido para " + newLimit + " âncoras.");
+        } catch (NumberFormatException e) {
+            Msg.error(sender, "Quantidade inválida: " + args[1]);
+        }
+    }
+
+    private boolean chunkloaderHelp(CommandSender sender) {
+        Msg.header(sender, "Âncoras de Chunk");
+        sender.sendMessage(Component.text("  /chunkloader info", NamedTextColor.AQUA)
+                .append(Component.text(" — Informações sobre a chunk onde você está", NamedTextColor.GRAY)));
+        sender.sendMessage(Component.text("  /chunkloader listar", NamedTextColor.AQUA)
+                .append(Component.text(" — Lista suas âncoras, nomes, status e coordenadas", NamedTextColor.GRAY)));
+        sender.sendMessage(Component.text("  /chunkloader nome <id|nome> <novo_nome>", NamedTextColor.AQUA)
+                .append(Component.text(" — Define um nome/rótulo para a âncora", NamedTextColor.GRAY)));
+        sender.sendMessage(Component.text("  /chunkloader ativar <id|nome>", NamedTextColor.AQUA)
+                .append(Component.text(" — Reativa o carregamento contínuo da âncora", NamedTextColor.GRAY)));
+        sender.sendMessage(Component.text("  /chunkloader desativar <id|nome>", NamedTextColor.AQUA)
+                .append(Component.text(" — Pausa o carregamento sem quebrar o bloco", NamedTextColor.GRAY)));
+        sender.sendMessage(Component.text("  /chunkloader remover <id|nome>", NamedTextColor.AQUA)
+                .append(Component.text(" — Desativa e recolhe uma de suas âncoras", NamedTextColor.GRAY)));
+        sender.sendMessage(Component.text("  /chunkloader receita", NamedTextColor.AQUA)
+                .append(Component.text(" — Mostra a receita de criação do bloco", NamedTextColor.GRAY)));
+        sender.sendMessage(Component.text("  /chunkloader tempo <id|nome> <horas>", NamedTextColor.AQUA)
+                .append(Component.text(" — Adiciona tempo ou abastece a âncora", NamedTextColor.GRAY)));
+        sender.sendMessage(Component.text("  /chunkloader limite", NamedTextColor.AQUA)
+                .append(Component.text(" — Mostra ou configura os limites de âncoras", NamedTextColor.GRAY)));
+        if (sender.hasPermission(ADMIN) || sender.hasPermission("canalhandia.chunkloader.admin")) {
+            sender.sendMessage(Component.text("  /chunkloader admin", NamedTextColor.YELLOW)
+                    .append(Component.text(" — Comandos de administração", NamedTextColor.GRAY)));
+        }
+        return true;
+    }
+
     // --- tab completion -----------------------------------------------------
 
     @Override
@@ -1943,6 +2423,45 @@ final class CanalhandiaCommand implements CommandExecutor, TabCompleter {
                 return filter(List.of("on", "off"), args[2]);
             }
         }
+        if (name.equals("chunkloader") || name.equals("ancora") || name.equals("ancoras")) {
+            if (args.length == 1) {
+                List<String> options = new ArrayList<>(List.of("info", "listar", "nome", "ativar", "desativar", "tempo", "remover", "receita", "limite"));
+                if (sender.hasPermission(ADMIN) || sender.hasPermission("canalhandia.chunkloader.admin")) {
+                    options.addAll(List.of("admin", "dar"));
+                }
+                return filter(options, args[0]);
+            }
+            if (args.length == 2 && (args[0].equalsIgnoreCase("remover") || args[0].equalsIgnoreCase("del")
+                    || args[0].equalsIgnoreCase("nome") || args[0].equalsIgnoreCase("renomear")
+                    || args[0].equalsIgnoreCase("ativar") || args[0].equalsIgnoreCase("desativar")
+                    || args[0].equalsIgnoreCase("pausar") || args[0].equalsIgnoreCase("tempo")
+                    || args[0].equalsIgnoreCase("abastecer"))) {
+                if (sender instanceof Player player) {
+                    List<String> identifiers = new ArrayList<>();
+                    for (ChunkLoader loader : plugin.chunkLoaders().byOwner(player.getUniqueId().toString())) {
+                        identifiers.add(String.valueOf(loader.id()));
+                        if (loader.name() != null && !loader.name().isBlank()) {
+                            identifiers.add(loader.name());
+                        }
+                    }
+                    return filter(identifiers, args[1]);
+                }
+            }
+            if (args.length == 2 && args[0].equalsIgnoreCase("limite")) {
+                List<String> opts = new ArrayList<>(List.of("padrao"));
+                opts.addAll(onlineNames());
+                return filter(opts, args[1]);
+            }
+            if (args.length == 2 && args[0].equalsIgnoreCase("admin")) {
+                return filter(List.of("listar", "remover", "dar"), args[1]);
+            }
+            if (args.length == 2 && args[0].equalsIgnoreCase("dar")) {
+                return filter(onlineNames(), args[1]);
+            }
+            if (args.length == 3 && args[0].equalsIgnoreCase("admin") && args[1].equalsIgnoreCase("dar")) {
+                return filter(onlineNames(), args[2]);
+            }
+        }
         return List.of();
     }
 

src/main/java/dev/marcospaulo/canalhandia/ChunkAnchorItem.java

@@ -0,0 +1,97 @@
+package dev.marcospaulo.canalhandia;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.format.TextDecoration;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.ShapedRecipe;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.persistence.PersistentDataType;
+import org.bukkit.plugin.Plugin;
+
+import java.util.List;
+
+/**
+ * Creates and validates the "Âncora de Chunk" custom block item and its crafting recipe.
+ */
+final class ChunkAnchorItem {
+
+    private static final String KEY_NAME = "chunk_anchor";
+    private static final String RECIPE_NAME = "ancora_de_chunk";
+
+    static NamespacedKey key(Plugin plugin) {
+        return new NamespacedKey(plugin, KEY_NAME);
+    }
+
+    static NamespacedKey recipeKey(Plugin plugin) {
+        return new NamespacedKey(plugin, RECIPE_NAME);
+    }
+
+    /**
+     * Creates a new Chunk Anchor item stack.
+     */
+    static ItemStack create(Plugin plugin, int amount) {
+        ItemStack item = new ItemStack(Material.RESPAWN_ANCHOR, Math.max(1, amount));
+        ItemMeta meta = item.getItemMeta();
+        if (meta != null) {
+            meta.displayName(Component.text("Âncora de Chunk", NamedTextColor.AQUA)
+                    .decoration(TextDecoration.ITALIC, false)
+                    .decoration(TextDecoration.BOLD, true));
+            meta.lore(List.of(
+                    Component.text("Coloque no chão para manter esta chunk", NamedTextColor.GRAY)
+                            .decoration(TextDecoration.ITALIC, false),
+                    Component.text("carregada continuamente no servidor.", NamedTextColor.GRAY)
+                            .decoration(TextDecoration.ITALIC, false),
+                    Component.text("Canalhandia Chunk Loader", NamedTextColor.DARK_GRAY)
+                            .decoration(TextDecoration.ITALIC, false)
+            ));
+            meta.getPersistentDataContainer().set(key(plugin), PersistentDataType.BYTE, (byte) 1);
+            item.setItemMeta(meta);
+        }
+        return item;
+    }
+
+    /**
+     * Tests if an item is a valid Chunk Anchor.
+     */
+    static boolean isAnchor(Plugin plugin, ItemStack item) {
+        if (item == null || item.getType() != Material.RESPAWN_ANCHOR) {
+            return false;
+        }
+        ItemMeta meta = item.getItemMeta();
+        if (meta == null) {
+            return false;
+        }
+        return meta.getPersistentDataContainer().has(key(plugin), PersistentDataType.BYTE);
+    }
+
+    /**
+     * Registers the shaped crafting recipe for the Chunk Anchor.
+     */
+    static void registerRecipe(Plugin plugin) {
+        try {
+            NamespacedKey rKey = recipeKey(plugin);
+            if (Bukkit.getRecipe(rKey) != null) {
+                return;
+            }
+            ShapedRecipe recipe = new ShapedRecipe(rKey, create(plugin, 1));
+            recipe.shape("DOD", "OEO", "DOD");
+            recipe.setIngredient('D', Material.DIAMOND);
+            recipe.setIngredient('O', Material.CRYING_OBSIDIAN);
+            recipe.setIngredient('E', Material.ENDER_EYE);
+
+            Bukkit.addRecipe(recipe);
+        } catch (Exception ignored) {
+        }
+    }
+
+    static void unregisterRecipe(Plugin plugin) {
+        try {
+            Bukkit.removeRecipe(recipeKey(plugin));
+        } catch (Exception ignored) {
+        }
+    }
+}

src/main/java/dev/marcospaulo/canalhandia/ChunkLoader.java

@@ -0,0 +1,85 @@
+package dev.marcospaulo.canalhandia;
+
+/**
+ * A persistent chunk loader anchor placed in the world.
+ *
+ * <p>A plain immutable record with no Bukkit types, so the model, coordinate
+ * math, and persistence rules are testable without a running server.
+ */
+record ChunkLoader(
+        long id,
+        String name,
+        boolean enabled,
+        long expiresAt,
+        String ownerUuid,
+        String ownerName,
+        String world,
+        int x,
+        int y,
+        int z,
+        int chunkX,
+        int chunkZ,
+        long createdAt) {
+
+    ChunkLoader(long id, String ownerUuid, String ownerName, String world, int x, int y, int z, int chunkX, int chunkZ, long createdAt) {
+        this(id, "", true, 0L, ownerUuid, ownerName, world, x, y, z, chunkX, chunkZ, createdAt);
+    }
+
+    ChunkLoader(long id, String name, boolean enabled, String ownerUuid, String ownerName, String world, int x, int y, int z, int chunkX, int chunkZ, long createdAt) {
+        this(id, name, enabled, 0L, ownerUuid, ownerName, world, x, y, z, chunkX, chunkZ, createdAt);
+    }
+
+    String blockCoords() {
+        return x + ", " + y + ", " + z;
+    }
+
+    String chunkCoords() {
+        return "[" + chunkX + ", " + chunkZ + "]";
+    }
+
+    String place() {
+        return blockCoords() + (world == null || world.isBlank() ? "" : " (" + world + ")");
+    }
+
+    String displayName() {
+        return (name != null && !name.isBlank()) ? name + " (#" + id + ")" : "#" + id;
+    }
+
+    String simpleName() {
+        return (name != null && !name.isBlank()) ? name : "#" + id;
+    }
+
+    boolean isExpired() {
+        return expiresAt > 0 && System.currentTimeMillis() >= expiresAt;
+    }
+
+    String timeLeft() {
+        if (expiresAt <= 0) {
+            return "Permanente";
+        }
+        long diff = expiresAt - System.currentTimeMillis();
+        if (diff <= 0) {
+            return "Expirado";
+        }
+        long hours = diff / (3600_000L);
+        long minutes = (diff % (3600_000L)) / 60_000L;
+        if (hours >= 24) {
+            long days = hours / 24;
+            hours = hours % 24;
+            return days + "d " + hours + "h";
+        }
+        return hours + "h " + minutes + "m";
+    }
+
+    ChunkLoader withName(String newName) {
+        return new ChunkLoader(id, newName == null ? "" : newName.trim(), enabled, expiresAt, ownerUuid, ownerName, world, x, y, z, chunkX, chunkZ, createdAt);
+    }
+
+    ChunkLoader withEnabled(boolean newEnabled) {
+        return new ChunkLoader(id, name, newEnabled, expiresAt, ownerUuid, ownerName, world, x, y, z, chunkX, chunkZ, createdAt);
+    }
+
+    ChunkLoader withExpiresAt(long newExpiresAt) {
+        return new ChunkLoader(id, name, enabled, Math.max(0L, newExpiresAt), ownerUuid, ownerName, world, x, y, z, chunkX, chunkZ, createdAt);
+    }
+}

src/main/java/dev/marcospaulo/canalhandia/ChunkLoaderListener.java

@@ -0,0 +1,317 @@
+package dev.marcospaulo.canalhandia;
+
+import org.bukkit.GameMode;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Particle;
+import org.bukkit.Sound;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Mob;
+import org.bukkit.entity.Player;
+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.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockExplodeEvent;
+import org.bukkit.event.block.BlockPistonExtendEvent;
+import org.bukkit.event.block.BlockPistonRetractEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.event.entity.EntityExplodeEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * Protects and handles block placement, removal, and explosions for Chunk Anchors.
+ */
+final class ChunkLoaderListener implements Listener {
+
+    private final Canalhandia plugin;
+
+    ChunkLoaderListener(Canalhandia plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onBlockPlace(BlockPlaceEvent event) {
+        if (!ChunkAnchorItem.isAnchor(plugin, event.getItemInHand())) {
+            return;
+        }
+
+        Player player = event.getPlayer();
+        if (!plugin.settings().moduleEnabled(Module.CHUNKLOADER)) {
+            Msg.error(player, "O módulo de Âncoras de Chunk está desativado.");
+            event.setCancelled(true);
+            return;
+        }
+
+        if (!player.hasPermission("canalhandia.chunkloader")) {
+            Msg.error(player, "Você não tem permissão para usar Âncoras de Chunk.");
+            event.setCancelled(true);
+            return;
+        }
+
+        int limit = ChunkLoaders.playerLimit(player, plugin.settings().chunkLoaderDefaultLimit());
+        int current = plugin.chunkLoaders().byOwner(player.getUniqueId().toString()).size();
+
+        if (current >= limit) {
+            Msg.error(player, "Você atingiu seu limite de Âncoras de Chunk ativas (" + current + "/" + limit + ").");
+            event.setCancelled(true);
+            return;
+        }
+
+        Location loc = event.getBlockPlaced().getLocation();
+        String world = loc.getWorld().getName();
+        int chunkX = loc.getBlockX() >> 4;
+        int chunkZ = loc.getBlockZ() >> 4;
+
+        ChunkLoader existing = plugin.chunkLoaders().byChunk(world, chunkX, chunkZ);
+        if (existing != null) {
+            Msg.error(player, "Esta chunk já possui uma Âncora de Chunk ativa em " + existing.blockCoords()
+                    + " (" + existing.ownerName() + ").");
+            event.setCancelled(true);
+            return;
+        }
+
+        String customName = "";
+        var meta = event.getItemInHand().getItemMeta();
+        if (meta != null && meta.hasDisplayName()) {
+            try {
+                String raw = net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer.plainText()
+                        .serialize(meta.displayName()).trim();
+                if (!raw.equalsIgnoreCase("Âncora de Chunk") && !raw.isBlank()) {
+                    customName = raw;
+                }
+            } catch (Exception ignored) {
+            }
+        }
+
+        ChunkLoader loader = plugin.chunkLoaders().add(
+                player.getUniqueId().toString(),
+                player.getName(),
+                world,
+                loc.getBlockX(),
+                loc.getBlockY(),
+                loc.getBlockZ(),
+                customName
+        );
+
+        try {
+            loc.getWorld().spawnParticle(Particle.PORTAL, loc.clone().add(0.5, 1.2, 0.5), 35, 0.3, 0.3, 0.3, 0.05);
+            loc.getWorld().playSound(loc, Sound.BLOCK_RESPAWN_ANCHOR_SET_SPAWN, 1.0f, 1.2f);
+        } catch (Exception ignored) {
+        }
+
+        plugin.blueMap().syncChunkLoaders();
+
+        String limitStr = limit == Integer.MAX_VALUE ? "ilimitado" : String.valueOf(limit);
+        Msg.ok(player, "Âncora de Chunk " + loader.displayName() + " ativada! Esta chunk [" + chunkX + ", " + chunkZ + "] ficará carregada continuamente ("
+                + (current + 1) + "/" + limitStr + ").");
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onBlockBreak(BlockBreakEvent event) {
+        Block block = event.getBlock();
+        ChunkLoader loader = plugin.chunkLoaders().byLocation(
+                block.getWorld().getName(),
+                block.getX(),
+                block.getY(),
+                block.getZ()
+        );
+
+        if (loader == null) {
+            return;
+        }
+
+        Player player = event.getPlayer();
+        boolean isOwner = player.getUniqueId().toString().equalsIgnoreCase(loader.ownerUuid());
+        boolean isAdmin = player.hasPermission("canalhandia.admin") || player.hasPermission("canalhandia.chunkloader.admin");
+
+        if (!isOwner && !isAdmin) {
+            Msg.error(player, "Esta Âncora de Chunk pertence a " + loader.ownerName() + " e só pode ser quebrada por ele.");
+            event.setCancelled(true);
+            return;
+        }
+
+        plugin.chunkLoaders().remove(loader.id());
+        event.setDropItems(false);
+        event.setExpToDrop(0);
+
+        if (player.getGameMode() == GameMode.CREATIVE) {
+            Msg.ok(player, "Âncora de Chunk " + loader.displayName() + " desativada (Modo Criativo).");
+        } else {
+            Map<Integer, ItemStack> overflow = player.getInventory().addItem(ChunkAnchorItem.create(plugin, 1));
+            for (ItemStack drop : overflow.values()) {
+                player.getWorld().dropItemNaturally(player.getLocation(), drop);
+            }
+            Msg.ok(player, "Âncora de Chunk " + loader.displayName() + " desativada e recolhida para o seu inventário.");
+        }
+
+        try {
+            var loc = block.getLocation().add(0.5, 0.5, 0.5);
+            loc.getWorld().playSound(loc, Sound.BLOCK_RESPAWN_ANCHOR_DEPLETE, 1.0f, 0.8f);
+        } catch (Exception ignored) {
+        }
+
+        plugin.blueMap().syncChunkLoaders();
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onPlayerInteract(PlayerInteractEvent event) {
+        if (!plugin.settings().moduleEnabled(Module.CHUNKLOADER)) {
+            return;
+        }
+        if (event.getHand() != org.bukkit.inventory.EquipmentSlot.HAND) {
+            return;
+        }
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
+            return;
+        }
+        Block block = event.getClickedBlock();
+        if (block == null || block.getType() != Material.RESPAWN_ANCHOR) {
+            return;
+        }
+        ChunkLoader loader = plugin.chunkLoaders().byLocation(
+                block.getWorld().getName(),
+                block.getX(),
+                block.getY(),
+                block.getZ()
+        );
+        if (loader != null) {
+            event.setCancelled(true);
+            Player player = event.getPlayer();
+            boolean isOwner = player.getUniqueId().toString().equalsIgnoreCase(loader.ownerUuid());
+            boolean isAdmin = player.hasPermission("canalhandia.admin") || player.hasPermission("canalhandia.chunkloader.admin");
+
+            ItemStack inHand = player.getInventory().getItemInMainHand();
+            long fuelMillis = fuelDuration(inHand.getType());
+            if (fuelMillis > 0 && (isOwner || isAdmin)) {
+                if (player.getGameMode() != GameMode.CREATIVE) {
+                    inHand.subtract(1);
+                }
+                plugin.chunkLoaders().addTime(loader.id(), fuelMillis);
+                ChunkLoader updated = plugin.chunkLoaders().byId(loader.id());
+                Location l = block.getLocation().add(0.5, 0.5, 0.5);
+                try {
+                    l.getWorld().playSound(l, Sound.BLOCK_RESPAWN_ANCHOR_CHARGE, 1.0f, 1.2f);
+                    l.getWorld().spawnParticle(Particle.FIREWORK, l, 15, 0.2, 0.2, 0.2, 0.05);
+                } catch (Exception ignored) {
+                }
+                plugin.blueMap().syncChunkLoaders();
+                String time = (updated != null) ? updated.timeLeft() : "Permanente";
+                Msg.ok(player, "Âncora " + loader.displayName() + " abastecida! Tempo restante: " + time);
+                return;
+            }
+
+            if (player.isSneaking() && (isOwner || isAdmin)) {
+                if (!loader.enabled() && loader.isExpired()) {
+                    Msg.error(player, "A âncora " + loader.displayName() + " está expirada! Clique com combustível (Pérola do End, Blaze, Diamante, etc.) ou adicione tempo antes de reativar.");
+                    return;
+                }
+                boolean newState = !loader.enabled();
+                plugin.chunkLoaders().setEnabled(loader.id(), newState);
+                Location l = block.getLocation().add(0.5, 0.5, 0.5);
+                if (newState) {
+                    try {
+                        l.getWorld().playSound(l, Sound.BLOCK_BEACON_ACTIVATE, 1.0f, 1.2f);
+                        l.getWorld().spawnParticle(Particle.PORTAL, l, 25, 0.2, 0.2, 0.2, 0.05);
+                    } catch (Exception ignored) {
+                    }
+                    Msg.ok(player, "Âncora " + loader.displayName() + " ATIVADA.");
+                } else {
+                    try {
+                        l.getWorld().playSound(l, Sound.BLOCK_BEACON_DEACTIVATE, 1.0f, 0.8f);
+                        l.getWorld().spawnParticle(Particle.SMOKE, l, 20, 0.2, 0.2, 0.2, 0.02);
+                    } catch (Exception ignored) {
+                    }
+                    Msg.ok(player, "Âncora " + loader.displayName() + " PAUSADA/DESATIVADA.");
+                }
+                plugin.blueMap().syncChunkLoaders();
+                return;
+            }
+
+            String stateStr = loader.enabled() ? "ATIVA" : "PAUSADA";
+            Msg.ok(player, "Âncora " + loader.displayName() + " (" + loader.ownerName() + ") está " + stateStr
+                    + " [Tempo: " + loader.timeLeft() + "]. (Shift + Clique Direito para pausar/ativar | Clique com combustível para abastecer)");
+        }
+    }
+
+    private static long fuelDuration(Material type) {
+        if (type == Material.REDSTONE || type == Material.GLOWSTONE_DUST) {
+            return 30 * 60_000L; // 30 min
+        }
+        if (type == Material.GLOWSTONE || type == Material.AMETHYST_SHARD) {
+            return 2 * 3600_000L; // 2h
+        }
+        if (type == Material.ENDER_PEARL || type == Material.BLAZE_POWDER || type == Material.BLAZE_ROD) {
+            return 4 * 3600_000L; // 4h
+        }
+        if (type == Material.ENDER_EYE || type == Material.DIAMOND || type == Material.EMERALD) {
+            return 12 * 3600_000L; // 12h
+        }
+        if (type == Material.NETHER_STAR || type == Material.NETHERITE_INGOT || type == Material.END_CRYSTAL) {
+            return 7 * 24 * 3600_000L; // 7 dias
+        }
+        return 0L;
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onBlockExplode(BlockExplodeEvent event) {
+        protectExplosions(event.blockList().iterator());
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onEntityExplode(EntityExplodeEvent event) {
+        protectExplosions(event.blockList().iterator());
+    }
+
+    private void protectExplosions(Iterator<Block> it) {
+        while (it.hasNext()) {
+            Block b = it.next();
+            if (plugin.chunkLoaders().byLocation(b.getWorld().getName(), b.getX(), b.getY(), b.getZ()) != null) {
+                it.remove();
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onPistonExtend(BlockPistonExtendEvent event) {
+        for (Block b : event.getBlocks()) {
+            if (plugin.chunkLoaders().byLocation(b.getWorld().getName(), b.getX(), b.getY(), b.getZ()) != null) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onPistonRetract(BlockPistonRetractEvent event) {
+        for (Block b : event.getBlocks()) {
+            if (plugin.chunkLoaders().byLocation(b.getWorld().getName(), b.getX(), b.getY(), b.getZ()) != null) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onCreatureSpawn(CreatureSpawnEvent event) {
+        if (!plugin.settings().moduleEnabled(Module.CHUNKLOADER)) {
+            return;
+        }
+        Location loc = event.getLocation();
+        World w = loc.getWorld();
+        if (w == null) {
+            return;
+        }
+        ChunkLoader loader = plugin.chunkLoaders().byChunk(w.getName(), loc.getBlockX() >> 4, loc.getBlockZ() >> 4);
+        if (loader != null && event.getEntity() instanceof Mob mob) {
+            mob.setRemoveWhenFarAway(false);
+        }
+    }
+}

src/main/java/dev/marcospaulo/canalhandia/ChunkLoaders.java

@@ -0,0 +1,639 @@
+package dev.marcospaulo.canalhandia;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockState;
+import org.bukkit.block.CreatureSpawner;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Mob;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.permissions.PermissionAttachmentInfo;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.scheduler.BukkitTask;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Manages active chunk loader anchors, ticket registration in Paper, and persistence in chunks.yml.
+ */
+final class ChunkLoaders {
+
+    private static final String PERM_LIMIT_PREFIX = "canalhandia.chunkloader.limite.";
+
+    private final Canalhandia plugin;
+    private final File file;
+    private final List<ChunkLoader> loaders = new ArrayList<>();
+    private final AtomicLong nextId = new AtomicLong(1);
+    private BukkitTask simulationTask;
+
+    private final ExecutorService io = Executors.newSingleThreadExecutor(r -> {
+        Thread t = new Thread(r, "canalhandia-chunkloaders-io");
+        t.setDaemon(true);
+        return t;
+    });
+
+    ChunkLoaders(Canalhandia plugin, File file) {
+        this.plugin = plugin;
+        this.file = file;
+        load();
+    }
+
+    void load() {
+        YamlConfiguration yaml = file.exists() ? YamlConfiguration.loadConfiguration(file) : null;
+        synchronized (loaders) {
+            loaders.clear();
+            if (yaml == null) {
+                return;
+            }
+            ConfigurationSection root = yaml.getConfigurationSection("loaders");
+            if (root == null) {
+                return;
+            }
+            long maxId = 0;
+            for (String key : root.getKeys(false)) {
+                try {
+                    long id = Long.parseLong(key);
+                    String name = root.getString(key + ".name", "");
+                    boolean enabled = root.getBoolean(key + ".enabled", true);
+                    long expiresAt = root.getLong(key + ".expires_at", 0L);
+                    String ownerUuid = root.getString(key + ".owner_uuid", "");
+                    String ownerName = root.getString(key + ".owner_name", "?");
+                    String world = root.getString(key + ".world", "world");
+                    int x = root.getInt(key + ".x");
+                    int y = root.getInt(key + ".y");
+                    int z = root.getInt(key + ".z");
+                    int chunkX = root.getInt(key + ".chunk_x", x >> 4);
+                    int chunkZ = root.getInt(key + ".chunk_z", z >> 4);
+                    long createdAt = root.getLong(key + ".created_at", System.currentTimeMillis());
+
+                    loaders.add(new ChunkLoader(id, name, enabled, expiresAt, ownerUuid, ownerName, world, x, y, z, chunkX, chunkZ, createdAt));
+                    if (id > maxId) {
+                        maxId = id;
+                    }
+                } catch (NumberFormatException ignored) {
+                }
+            }
+            nextId.set(maxId + 1);
+        }
+    }
+
+    /**
+     * Registers a new chunk loader and activates the ticket in the world.
+     */
+    ChunkLoader add(String ownerUuid, String ownerName, String world, int x, int y, int z) {
+        return add(ownerUuid, ownerName, world, x, y, z, "", defaultInitialExpiration());
+    }
+
+    ChunkLoader add(String ownerUuid, String ownerName, String world, int x, int y, int z, String name) {
+        return add(ownerUuid, ownerName, world, x, y, z, name, defaultInitialExpiration());
+    }
+
+    private long defaultInitialExpiration() {
+        if (plugin != null && plugin.settings() != null && plugin.settings().chunkLoaderRequiresTime()) {
+            double hours = plugin.settings().chunkLoaderInitialHours();
+            if (hours > 0) {
+                return System.currentTimeMillis() + (long) (hours * 3600_000L);
+            }
+        }
+        return 0L;
+    }
+
+    ChunkLoader add(String ownerUuid, String ownerName, String world, int x, int y, int z, String name, long expiresAt) {
+        int chunkX = x >> 4;
+        int chunkZ = z >> 4;
+        long id = nextId.getAndIncrement();
+        ChunkLoader loader = new ChunkLoader(id, name == null ? "" : name.trim(), true, expiresAt, ownerUuid, ownerName, world, x, y, z, chunkX, chunkZ, System.currentTimeMillis());
+
+        synchronized (loaders) {
+            loaders.add(loader);
+        }
+        addTicket(loader);
+        save();
+        return loader;
+    }
+
+    /**
+     * Adds duration (in milliseconds) to a chunk loader's expiration timer.
+     */
+    boolean addTime(long id, long millisToAdd) {
+        ChunkLoader updated = null;
+        synchronized (loaders) {
+            for (int i = 0; i < loaders.size(); i++) {
+                ChunkLoader curr = loaders.get(i);
+                if (curr.id() == id) {
+                    long now = System.currentTimeMillis();
+                    long base = (curr.expiresAt() > now) ? curr.expiresAt() : now;
+                    long newExpires = base + millisToAdd;
+                    updated = curr.withExpiresAt(newExpires).withEnabled(true);
+                    loaders.set(i, updated);
+                    break;
+                }
+            }
+        }
+        if (updated != null) {
+            addTicket(updated);
+            save();
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Sets a specific expiration timestamp (or 0 for permanent) for a chunk loader.
+     */
+    boolean setExpiresAt(long id, long expiresAt) {
+        ChunkLoader updated = null;
+        synchronized (loaders) {
+            for (int i = 0; i < loaders.size(); i++) {
+                ChunkLoader curr = loaders.get(i);
+                if (curr.id() == id) {
+                    updated = curr.withExpiresAt(expiresAt).withEnabled(true);
+                    loaders.set(i, updated);
+                    break;
+                }
+            }
+        }
+        if (updated != null) {
+            addTicket(updated);
+            save();
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Renames an existing chunk loader.
+     */
+    boolean rename(long id, String newName) {
+        synchronized (loaders) {
+            for (int i = 0; i < loaders.size(); i++) {
+                ChunkLoader curr = loaders.get(i);
+                if (curr.id() == id) {
+                    loaders.set(i, curr.withName(newName));
+                    save();
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Enables or disables (pauses) a chunk loader without destroying the block.
+     */
+    boolean setEnabled(long id, boolean enabled) {
+        ChunkLoader oldLoader = null;
+        ChunkLoader updated = null;
+        synchronized (loaders) {
+            for (int i = 0; i < loaders.size(); i++) {
+                ChunkLoader curr = loaders.get(i);
+                if (curr.id() == id) {
+                    oldLoader = curr;
+                    updated = curr.withEnabled(enabled);
+                    loaders.set(i, updated);
+                    break;
+                }
+            }
+        }
+        if (oldLoader != null && updated != null) {
+            if (enabled) {
+                addTicket(updated);
+            } else {
+                removeTicket(oldLoader);
+            }
+            save();
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Finds a chunk loader by its numeric ID (with '#' prefix or plain ID) or custom name.
+     * Custom names take precedence over raw numeric IDs to avoid shadowing named loaders.
+     */
+    ChunkLoader find(String query) {
+        if (query == null || query.isBlank()) {
+            return null;
+        }
+        String trimmed = query.trim();
+        if (trimmed.startsWith("#")) {
+            try {
+                long id = Long.parseLong(trimmed.substring(1));
+                ChunkLoader loader = byId(id);
+                if (loader != null) {
+                    return loader;
+                }
+            } catch (NumberFormatException ignored) {
+            }
+        }
+
+        synchronized (loaders) {
+            for (ChunkLoader loader : loaders) {
+                if (loader.name() != null && loader.name().equalsIgnoreCase(trimmed)) {
+                    return loader;
+                }
+            }
+        }
+
+        try {
+            long id = Long.parseLong(trimmed);
+            ChunkLoader loader = byId(id);
+            if (loader != null) {
+                return loader;
+            }
+        } catch (NumberFormatException ignored) {
+        }
+        return null;
+    }
+
+    /**
+     * Removes a chunk loader by its unique ID and releases the chunk ticket.
+     */
+    boolean remove(long id) {
+        ChunkLoader removed = null;
+        synchronized (loaders) {
+            for (int i = 0; i < loaders.size(); i++) {
+                if (loaders.get(i).id() == id) {
+                    removed = loaders.remove(i);
+                    break;
+                }
+            }
+        }
+        if (removed != null) {
+            removeTicket(removed);
+            save();
+            return true;
+        }
+        return false;
+    }
+
+    ChunkLoader byId(long id) {
+        synchronized (loaders) {
+            for (ChunkLoader loader : loaders) {
+                if (loader.id() == id) {
+                    return loader;
+                }
+            }
+            return null;
+        }
+    }
+
+    ChunkLoader byChunk(String world, int chunkX, int chunkZ) {
+        synchronized (loaders) {
+            for (ChunkLoader loader : loaders) {
+                if (loader.world().equalsIgnoreCase(world) && loader.chunkX() == chunkX && loader.chunkZ() == chunkZ) {
+                    return loader;
+                }
+            }
+            return null;
+        }
+    }
+
+    ChunkLoader byLocation(String world, int x, int y, int z) {
+        synchronized (loaders) {
+            for (ChunkLoader loader : loaders) {
+                if (loader.world().equalsIgnoreCase(world) && loader.x() == x && loader.y() == y && loader.z() == z) {
+                    return loader;
+                }
+            }
+            return null;
+        }
+    }
+
+    List<ChunkLoader> byOwner(String ownerUuid) {
+        List<ChunkLoader> out = new ArrayList<>();
+        synchronized (loaders) {
+            for (ChunkLoader loader : loaders) {
+                if (loader.ownerUuid().equalsIgnoreCase(ownerUuid)) {
+                    out.add(loader);
+                }
+            }
+        }
+        return Collections.unmodifiableList(out);
+    }
+
+    List<ChunkLoader> all() {
+        synchronized (loaders) {
+            return Collections.unmodifiableList(new ArrayList<>(loaders));
+        }
+    }
+
+    int size() {
+        synchronized (loaders) {
+            return loaders.size();
+        }
+    }
+
+    /**
+     * Computes the maximum chunk loaders allowed for a player based on LuckPerms permissions.
+     */
+    static int playerLimit(Player player, int defaultLimit) {
+        if (player == null) {
+            return 0;
+        }
+        if (player.hasPermission("canalhandia.admin") || player.hasPermission("canalhandia.chunkloader.admin")) {
+            return Integer.MAX_VALUE;
+        }
+        if (!player.hasPermission("canalhandia.chunkloader")) {
+            return 0;
+        }
+
+        int max = -1;
+        for (PermissionAttachmentInfo info : player.getEffectivePermissions()) {
+            String perm = info.getPermission().toLowerCase(Locale.ROOT);
+            if (info.getValue() && perm.startsWith(PERM_LIMIT_PREFIX)) {
+                String valStr = perm.substring(PERM_LIMIT_PREFIX.length());
+                try {
+                    int val = Integer.parseInt(valStr);
+                    if (val > max) {
+                        max = val;
+                    }
+                } catch (NumberFormatException ignored) {
+                }
+            }
+        }
+        return max >= 0 ? max : defaultLimit;
+    }
+
+    void loadAllTickets() {
+        synchronized (loaders) {
+            for (ChunkLoader loader : loaders) {
+                if (loader.enabled()) {
+                    addTicket(loader);
+                }
+            }
+        }
+    }
+
+    void unloadAllTickets() {
+        synchronized (loaders) {
+            for (ChunkLoader loader : loaders) {
+                removeTicket(loader);
+            }
+        }
+    }
+
+    void startSimulation() {
+        if (plugin == null || simulationTask != null) {
+            return;
+        }
+        simulationTask = Bukkit.getScheduler().runTaskTimer(plugin, this::tickMobSimulation, 20L, 20L);
+    }
+
+    void stopSimulation() {
+        if (simulationTask != null) {
+            simulationTask.cancel();
+            simulationTask = null;
+        }
+    }
+
+    void tickMobSimulation() {
+        if (plugin == null) {
+            return;
+        }
+        List<ChunkLoader> currentLoaders;
+        synchronized (loaders) {
+            currentLoaders = new ArrayList<>(loaders);
+        }
+
+        for (ChunkLoader loader : currentLoaders) {
+            if (loader.isExpired() && loader.enabled()) {
+                setEnabled(loader.id(), false);
+                continue;
+            }
+            if (!loader.enabled()) {
+                continue;
+            }
+            try {
+                World w = Bukkit.getWorld(loader.world());
+                if (w == null || !w.isChunkLoaded(loader.chunkX(), loader.chunkZ())) {
+                    continue;
+                }
+                Chunk chunk = w.getChunkAt(loader.chunkX(), loader.chunkZ());
+
+                boolean spawnersActive = plugin.settings() == null || plugin.settings().chunkLoaderSpawnersActive();
+                boolean monsterSpawning = plugin.settings() == null || plugin.settings().chunkLoaderMonsterSpawning();
+                int monsterCap = plugin.settings() != null ? plugin.settings().chunkLoaderMonsterCap() : 20;
+
+                // 1. Keep mob spawners (dungeon / blaze / skeleton cages) active if enabled
+                if (spawnersActive) {
+                    for (BlockState state : chunk.getTileEntities()) {
+                        if (state instanceof CreatureSpawner spawner) {
+                            if (spawner.getRequiredPlayerRange() < 1024) {
+                                spawner.setRequiredPlayerRange(2048);
+                                spawner.update(true, false);
+                            }
+                        }
+                    }
+                }
+
+                // 2. Simulate natural mob spawning (dark platforms / slime / nether farms) if enabled
+                if (monsterSpawning) {
+                    long mobCount = 0;
+                    for (Entity entity : chunk.getEntities()) {
+                        if (entity instanceof Mob) {
+                            mobCount++;
+                        }
+                    }
+                    if (mobCount < monsterCap) {
+                        simulateNaturalSpawning(w, loader, chunk);
+                    }
+                }
+            } catch (Exception ignored) {
+            }
+        }
+    }
+
+    private void simulateNaturalSpawning(World w, ChunkLoader loader, Chunk chunk) {
+        int baseX = loader.chunkX() << 4;
+        int baseZ = loader.chunkZ() << 4;
+        ThreadLocalRandom rnd = ThreadLocalRandom.current();
+
+        for (int i = 0; i < 4; i++) {
+            int rx = baseX + rnd.nextInt(16);
+            int rz = baseZ + rnd.nextInt(16);
+            int topY = Math.max(w.getMinHeight() + 2, Math.min(w.getMaxHeight() - 2, loader.y() + rnd.nextInt(-24, 25)));
+
+            Block ground = w.getBlockAt(rx, topY - 1, rz);
+            Block space = w.getBlockAt(rx, topY, rz);
+            Block spaceAbove = w.getBlockAt(rx, topY + 1, rz);
+
+            if (!ground.getType().isSolid() || ground.isLiquid() || ground.getType() == Material.LAVA || ground.getType() == Material.WATER) {
+                continue;
+            }
+            if (!space.getType().isAir()) {
+                continue;
+            }
+
+            boolean isAirAbove = spaceAbove.getType().isAir();
+            boolean isTrapdoorAbove = isTrapdoor(spaceAbove.getType());
+            if (!isAirAbove && !isTrapdoorAbove) {
+                continue;
+            }
+
+            int light = space.getLightLevel();
+            EntityType toSpawn;
+            if (isTrapdoorAbove) {
+                if (light > 0) {
+                    continue;
+                }
+                toSpawn = EntityType.CREEPER;
+            } else {
+                toSpawn = pickEntityType(w, space, light);
+            }
+
+            if (toSpawn == null) {
+                continue;
+            }
+
+            try {
+                Entity spawned = w.spawnEntity(space.getLocation().add(0.5, 0, 0.5), toSpawn, CreatureSpawnEvent.SpawnReason.NATURAL);
+                if (spawned instanceof Mob mob) {
+                    mob.setRemoveWhenFarAway(false);
+                }
+            } catch (Exception ignored) {
+            }
+        }
+    }
+
+    static boolean isTrapdoor(Material mat) {
+        if (mat == null) return false;
+        return mat.name().endsWith("_TRAPDOOR");
+    }
+
+    static EntityType pickEntityType(World w, Block space, int light) {
+        boolean isSlime = false;
+        try {
+            isSlime = space.getChunk().isSlimeChunk();
+        } catch (Exception ignored) {
+        }
+        return pickEntityType(w.getEnvironment(), isSlime, space.getY(), light, ThreadLocalRandom.current().nextInt(100));
+    }
+
+    static EntityType pickEntityType(World.Environment env, boolean isSlimeChunk, int y, int light, int roll) {
+        if (env == World.Environment.NETHER) {
+            if (light > 11) return null;
+            int r = Math.floorMod(roll, 100);
+            if (r < 45) return EntityType.ZOMBIFIED_PIGLIN;
+            if (r < 65) return EntityType.WITHER_SKELETON;
+            if (r < 85) return EntityType.BLAZE;
+            return EntityType.MAGMA_CUBE;
+        }
+
+        if (env == World.Environment.THE_END) {
+            return EntityType.ENDERMAN;
+        }
+
+        if (isSlimeChunk && y < 40 && light <= 7 && roll % 3 == 0) {
+            return EntityType.SLIME;
+        }
+
+        if (light > 0) {
+            return null;
+        }
+
+        int r = Math.floorMod(roll, 100);
+        if (r < 35) return EntityType.ZOMBIE;
+        if (r < 65) return EntityType.SKELETON;
+        if (r < 85) return EntityType.CREEPER;
+        if (r < 95) return EntityType.SPIDER;
+        return EntityType.WITCH;
+    }
+
+    private void addTicket(ChunkLoader loader) {
+        if (plugin == null) {
+            return;
+        }
+        try {
+            World w = Bukkit.getWorld(loader.world());
+            if (w != null) {
+                w.setChunkForceLoaded(loader.chunkX(), loader.chunkZ(), true);
+                w.addPluginChunkTicket(loader.chunkX(), loader.chunkZ(), plugin);
+            }
+        } catch (Exception ignored) {
+        }
+    }
+
+    private void removeTicket(ChunkLoader loader) {
+        if (plugin == null) {
+            return;
+        }
+        try {
+            World w = Bukkit.getWorld(loader.world());
+            if (w != null) {
+                w.removePluginChunkTicket(loader.chunkX(), loader.chunkZ(), plugin);
+                w.setChunkForceLoaded(loader.chunkX(), loader.chunkZ(), false);
+                if (w.isChunkLoaded(loader.chunkX(), loader.chunkZ())) {
+                    Chunk chunk = w.getChunkAt(loader.chunkX(), loader.chunkZ());
+                    for (BlockState state : chunk.getTileEntities()) {
+                        if (state instanceof CreatureSpawner spawner && spawner.getRequiredPlayerRange() > 16) {
+                            spawner.setRequiredPlayerRange(16);
+                            spawner.update(true, false);
+                        }
+                    }
+                }
+            }
+        } catch (Exception ignored) {
+        }
+    }
+
+    private YamlConfiguration buildYaml() {
+        YamlConfiguration yaml = new YamlConfiguration();
+        synchronized (loaders) {
+            for (ChunkLoader l : loaders) {
+                String key = "loaders." + l.id();
+                yaml.set(key + ".name", l.name());
+                yaml.set(key + ".enabled", l.enabled());
+                yaml.set(key + ".expires_at", l.expiresAt());
+                yaml.set(key + ".owner_uuid", l.ownerUuid());
+                yaml.set(key + ".owner_name", l.ownerName());
+                yaml.set(key + ".world", l.world());
+                yaml.set(key + ".x", l.x());
+                yaml.set(key + ".y", l.y());
+                yaml.set(key + ".z", l.z());
+                yaml.set(key + ".chunk_x", l.chunkX());
+                yaml.set(key + ".chunk_z", l.chunkZ());
+                yaml.set(key + ".created_at", l.createdAt());
+            }
+        }
+        return yaml;
+    }
+
+    private void save() {
+        YamlConfiguration yaml = buildYaml();
+        io.execute(() -> {
+            try {
+                yaml.save(file);
+            } catch (Exception ignored) {
+            }
+        });
+    }
+
+    void flush() {
+        try {
+            io.submit(() -> {}).get(2, TimeUnit.SECONDS);
+        } catch (Exception ignored) {
+        }
+    }
+
+    void close() {
+        flush();
+        io.shutdown();
+    }
+}

src/main/java/dev/marcospaulo/canalhandia/Module.java

@@ -14,7 +14,9 @@ enum Module {
     NOTAS("notas", "Anotações públicas e privadas no chat"),
     RECADOS("recados", "Recados entregues quando o jogador entra"),
     CONQUISTAS("conquistas", "Conquistas com nome, além dos marcos numéricos"),
-    IA("ia", "Perguntas para a IA");
+    IA("ia", "Perguntas para a IA"),
+    CHUNKLOADER("chunkloader", "Âncoras de carregamento de chunks"),
+    SALVAVOID("salvavoid", "Proteção de itens no vácuo");
 
     private final String key;
     private final String label;

src/main/java/dev/marcospaulo/canalhandia/PlayerMemory.java

@@ -205,7 +205,8 @@ final class PlayerMemory {
         if (text == null) {
             return null;
         }
-        String lower = text.toLowerCase(Locale.ROOT).trim();
+        String clean = text.trim();
+        String lower = clean.toLowerCase(Locale.ROOT);
         String[] triggers = {
             "minha base", "meu spawn", "minha casa", "estou construindo",
             "meu plano", "meu objetivo", "sou especialista em", "moro em"
@@ -213,7 +214,7 @@ final class PlayerMemory {
         for (String trigger : triggers) {
             int idx = lower.indexOf(trigger);
             if (idx >= 0) {
-                String candidate = text.substring(idx).trim();
+                String candidate = clean.substring(idx).trim();
                 candidate = candidate.replaceAll("[?!.]+$", "").trim();
                 if (candidate.length() > 60) {
                     candidate = candidate.substring(0, 60) + "…";

src/main/java/dev/marcospaulo/canalhandia/Settings.java

@@ -579,6 +579,90 @@ final class Settings {
         set("categorias." + category.key(), enabled);
     }
 
+    // --- chunkloader --------------------------------------------------------
+
+    int chunkLoaderDefaultLimit() {
+        return Math.max(0, plugin.getConfig().getInt("chunkloader.limite-padrao", 1));
+    }
+
+    void chunkLoaderDefaultLimit(int limit) {
+        set("chunkloader.limite-padrao", Math.max(0, limit));
+    }
+
+    boolean chunkLoaderBlueMap() {
+        return plugin.getConfig().getBoolean("chunkloader.bluemap", true);
+    }
+
+    void chunkLoaderBlueMap(boolean enabled) {
+        set("chunkloader.bluemap", enabled);
+    }
+
+    boolean chunkLoaderSpawnersActive() {
+        return plugin.getConfig().getBoolean("chunkloader.simulacao.gaiolas-ativas", true);
+    }
+
+    void chunkLoaderSpawnersActive(boolean active) {
+        set("chunkloader.simulacao.gaiolas-ativas", active);
+    }
+
+    boolean chunkLoaderMonsterSpawning() {
+        return plugin.getConfig().getBoolean("chunkloader.simulacao.spawn-monstros", true);
+    }
+
+    void chunkLoaderMonsterSpawning(boolean spawning) {
+        set("chunkloader.simulacao.spawn-monstros", spawning);
+    }
+
+    int chunkLoaderMonsterCap() {
+        return Math.max(1, plugin.getConfig().getInt("chunkloader.simulacao.limite-monstros-chunk", 20));
+    }
+
+    void chunkLoaderMonsterCap(int cap) {
+        set("chunkloader.simulacao.limite-monstros-chunk", Math.max(1, cap));
+    }
+
+    boolean chunkLoaderPassiveEntities() {
+        return plugin.getConfig().getBoolean("chunkloader.simulacao.tick-entidades-passivas", true);
+    }
+
+    void chunkLoaderPassiveEntities(boolean active) {
+        set("chunkloader.simulacao.tick-entidades-passivas", active);
+    }
+
+    boolean chunkLoaderRequiresTime() {
+        return plugin.getConfig().getBoolean("chunkloader.combustivel.requer-tempo", true);
+    }
+
+    void chunkLoaderRequiresTime(boolean required) {
+        set("chunkloader.combustivel.requer-tempo", required);
+    }
+
+    double chunkLoaderInitialHours() {
+        return Math.max(0.0, plugin.getConfig().getDouble("chunkloader.combustivel.tempo-inicial-horas", 24.0));
+    }
+
+    void chunkLoaderInitialHours(double hours) {
+        set("chunkloader.combustivel.tempo-inicial-horas", Math.max(0.0, hours));
+    }
+
+    // --- salvavoid ----------------------------------------------------------
+
+    int voidProtectionRadius() {
+        return Math.max(1, plugin.getConfig().getInt("salvavoid.raio-busca", 32));
+    }
+
+    void voidProtectionRadius(int radius) {
+        set("salvavoid.raio-busca", Math.max(1, radius));
+    }
+
+    boolean voidProtectionKeepXp() {
+        return plugin.getConfig().getBoolean("salvavoid.preservar-xp", true);
+    }
+
+    void voidProtectionKeepXp(boolean keep) {
+        set("salvavoid.preservar-xp", keep);
+    }
+
     // --- plumbing -----------------------------------------------------------
 
     private void set(String path, Object value) {

src/main/java/dev/marcospaulo/canalhandia/VoidProtection.java

@@ -0,0 +1,273 @@
+package dev.marcospaulo.canalhandia;
+
+import org.bukkit.HeightMap;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockState;
+import org.bukkit.block.Chest;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Rescues player items on void death, either into a safe nearby chest
+ * on solid ground or directly retained in the player's inventory.
+ */
+public final class VoidProtection {
+
+    private static final int MAX_CHECKED_COLUMNS = 120;
+
+    private VoidProtection() {
+    }
+
+    /**
+     * Determines whether a death was caused by falling into the void.
+     */
+    public static boolean isVoidDeath(double y, double minHeight, EntityDamageEvent.DamageCause cause) {
+        if (cause == EntityDamageEvent.DamageCause.VOID) {
+            return true;
+        }
+        return y < minHeight;
+    }
+
+    /**
+     * Finds the nearest safe solid block with air space above it within the given horizontal radius.
+     * Only checks already-loaded chunks and caps checked columns to prevent server hitches.
+     */
+    public static Location findSafeChestLocation(World world, Location deathLoc, int radius) {
+        if (world == null || deathLoc == null || radius <= 0) {
+            return null;
+        }
+        int centerX = deathLoc.getBlockX();
+        int centerZ = deathLoc.getBlockZ();
+        int minHeight = world.getMinHeight();
+        int checked = 0;
+
+        for (int r = 0; r <= radius; r += (r > 8 ? 2 : 1)) {
+            Location ringBest = null;
+            double ringBestDistSq = Double.MAX_VALUE;
+
+            for (int dx = -r; dx <= r; dx += (r > 8 ? 2 : 1)) {
+                for (int dz = -r; dz <= r; dz += (r > 8 ? 2 : 1)) {
+                    if (r > 0 && Math.abs(dx) != r && Math.abs(dz) != r) {
+                        continue;
+                    }
+                    if (++checked > MAX_CHECKED_COLUMNS) {
+                        return ringBest;
+                    }
+
+                    int x = centerX + dx;
+                    int z = centerZ + dz;
+
+                    // Do not load or generate new chunks synchronously on death
+                    if (!world.isChunkLoaded(x >> 4, z >> 4)) {
+                        continue;
+                    }
+
+                    int topY;
+                    try {
+                        topY = world.getHighestBlockYAt(x, z, HeightMap.MOTION_BLOCKING_NO_LEAVES);
+                    } catch (Exception e) {
+                        continue;
+                    }
+
+                    int maxHeight = world.getMaxHeight();
+                    if (topY <= minHeight || topY >= maxHeight - 1) {
+                        continue;
+                    }
+
+                    Block ground;
+                    Block space;
+                    try {
+                        ground = world.getBlockAt(x, topY, z);
+                        space = world.getBlockAt(x, topY + 1, z);
+                    } catch (Exception e) {
+                        continue;
+                    }
+
+                    if (isSafeGround(ground) && isReplaceable(space)) {
+                        double distSq = (dx * dx) + (dz * dz);
+                        if (distSq < ringBestDistSq) {
+                            ringBestDistSq = distSq;
+                            ringBest = space.getLocation();
+                        }
+                    }
+                }
+            }
+            if (ringBest != null) {
+                return ringBest;
+            }
+        }
+        return null;
+    }
+
+    static boolean isSafeGround(Block block) {
+        return block != null && isSafeGroundMaterial(block.getType());
+    }
+
+    public static boolean isSafeGroundMaterial(Material mat) {
+        if (mat == null || mat == Material.AIR || mat == Material.CAVE_AIR || mat == Material.VOID_AIR) {
+            return false;
+        }
+        if (mat == Material.LAVA || mat == Material.WATER || mat == Material.FIRE || mat == Material.SOUL_FIRE
+                || mat == Material.CACTUS || mat == Material.MAGMA_BLOCK || mat == Material.SWEET_BERRY_BUSH
+                || mat == Material.WITHER_ROSE || mat == Material.POWDER_SNOW) {
+            return false;
+        }
+        try {
+            return mat.isSolid();
+        } catch (Exception | LinkageError e) {
+            return true;
+        }
+    }
+
+    static boolean isReplaceable(Block block) {
+        return block != null && isReplaceableMaterial(block.getType());
+    }
+
+    public static boolean isReplaceableMaterial(Material mat) {
+        if (mat == null) {
+            return false;
+        }
+        return mat == Material.AIR || mat == Material.CAVE_AIR || mat == Material.VOID_AIR
+                || mat == Material.SHORT_GRASS || mat == Material.TALL_GRASS
+                || mat == Material.SNOW || mat == Material.FERN || mat == Material.LARGE_FERN;
+    }
+
+    /**
+     * Calculates the estimated number of inventory slots needed to store the given items.
+     */
+    public static int calculateRequiredSlots(List<ItemStack> items) {
+        if (items == null || items.isEmpty()) {
+            return 0;
+        }
+        int slots = 0;
+        for (ItemStack item : items) {
+            if (item != null && item.getType() != Material.AIR && item.getAmount() > 0) {
+                int maxStack = Math.max(1, item.getMaxStackSize());
+                slots += (int) Math.ceil((double) item.getAmount() / maxStack);
+            }
+        }
+        return slots;
+    }
+
+    public static boolean canFitInSingleChest(List<ItemStack> items) {
+        return calculateRequiredSlots(items) <= 27;
+    }
+
+    public static boolean canFitInDoubleChest(List<ItemStack> items) {
+        return calculateRequiredSlots(items) <= 54;
+    }
+
+    /**
+     * Stores items into a chest (and an adjacent chest if needed) at the target location.
+     * All items must be stored without overflow; on any failure, blocks are rolled back
+     * and false is returned so caller can safely fall back to keepInventory.
+     */
+    public static boolean rescueToChest(List<ItemStack> items, Location chestLoc) {
+        if (items == null || items.isEmpty() || chestLoc == null) {
+            return false;
+        }
+
+        Block chestBlock = chestLoc.getBlock();
+        Material orig1 = chestBlock.getType();
+        Block adjacent = null;
+        Material orig2 = null;
+
+        try {
+            chestBlock.setType(Material.CHEST, false);
+            BlockState state = chestBlock.getState();
+            if (!(state instanceof Chest chest)) {
+                chestBlock.setType(orig1, false);
+                return false;
+            }
+
+            Inventory inv = chest.getInventory();
+            List<ItemStack> remaining = new ArrayList<>();
+
+            for (ItemStack item : items) {
+                if (item != null && !item.getType().isAir()) {
+                    Map<Integer, ItemStack> leftover = inv.addItem(item.clone());
+                    remaining.addAll(leftover.values());
+                }
+            }
+
+            if (!remaining.isEmpty()) {
+                adjacent = findAdjacentSpace(chestLoc);
+                if (adjacent == null) {
+                    // Cannot fit all items and no space for second chest -> rollback
+                    inv.clear();
+                    chestBlock.setType(orig1, false);
+                    return false;
+                }
+
+                orig2 = adjacent.getType();
+                adjacent.setType(Material.CHEST, false);
+                BlockState adjState = adjacent.getState();
+                if (!(adjState instanceof Chest adjChest)) {
+                    inv.clear();
+                    chestBlock.setType(orig1, false);
+                    adjacent.setType(orig2, false);
+                    return false;
+                }
+
+                Inventory adjInv = adjChest.getInventory();
+                List<ItemStack> secondLeftover = new ArrayList<>();
+                for (ItemStack rem : remaining) {
+                    Map<Integer, ItemStack> leftover = adjInv.addItem(rem);
+                    secondLeftover.addAll(leftover.values());
+                }
+
+                if (!secondLeftover.isEmpty()) {
+                    // Still overflowed double chest -> rollback everything
+                    inv.clear();
+                    adjInv.clear();
+                    chestBlock.setType(orig1, false);
+                    adjacent.setType(orig2, false);
+                    return false;
+                }
+            }
+
+            return true;
+        } catch (Exception e) {
+            try {
+                if (chestBlock.getType() == Material.CHEST) {
+                    BlockState s = chestBlock.getState();
+                    if (s instanceof Chest c) c.getInventory().clear();
+                    chestBlock.setType(orig1, false);
+                }
+                if (adjacent != null && adjacent.getType() == Material.CHEST) {
+                    BlockState s2 = adjacent.getState();
+                    if (s2 instanceof Chest c2) c2.getInventory().clear();
+                    adjacent.setType(orig2 != null ? orig2 : Material.AIR, false);
+                }
+            } catch (Exception ignored) {
+            }
+            return false;
+        }
+    }
+
+    private static Block findAdjacentSpace(Location loc) {
+        World w = loc.getWorld();
+        if (w == null) return null;
+        int x = loc.getBlockX();
+        int y = loc.getBlockY();
+        int z = loc.getBlockZ();
+
+        int[][] offsets = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+        for (int[] off : offsets) {
+            Block b = w.getBlockAt(x + off[0], y, z + off[1]);
+            Block ground = w.getBlockAt(x + off[0], y - 1, z + off[1]);
+            if (isReplaceable(b) && isSafeGround(ground)) {
+                return b;
+            }
+        }
+        return null;
+    }
+}

src/main/java/dev/marcospaulo/canalhandia/XpAndItemMergeListener.java

@@ -0,0 +1,187 @@
+package dev.marcospaulo.canalhandia;
+
+import com.destroystokyo.paper.event.player.PlayerPickupExperienceEvent;
+import org.bukkit.Location;
+import org.bukkit.Sound;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.ExperienceOrb;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.ItemSpawnEvent;
+import org.bukkit.inventory.ItemStack;
+
+import org.bukkit.Material;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.inventory.meta.Damageable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Optimises XP and Item collection by instantly vacuuming nearby XP orbs into the player's
+ * XP bar (bypassing Vanilla's 2-tick per orb delay), repairing Mending equipment first,
+ * and consolidating spawned item drops into full stacks.
+ */
+public final class XpAndItemMergeListener implements Listener {
+
+    private final Canalhandia plugin;
+
+    public XpAndItemMergeListener(Canalhandia plugin) {
+        this.plugin = plugin;
+    }
+
+    /**
+     * Vacuums all experience orbs within radius instantly on player contact and repairs Mending items.
+     */
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onPlayerPickupXp(PlayerPickupExperienceEvent event) {
+        Player player = event.getPlayer();
+        Location loc = player.getLocation();
+        if (loc.getWorld() == null) {
+            return;
+        }
+
+        int totalExp = 0;
+        try {
+            for (Entity entity : loc.getWorld().getNearbyEntities(loc, 6.0, 6.0, 6.0)) {
+                if (entity instanceof ExperienceOrb orb && orb.isValid()) {
+                    totalExp += orb.getExperience();
+                    orb.remove();
+                }
+            }
+        } catch (Exception ignored) {
+        }
+
+        if (totalExp > 0) {
+            int leftoverExp = applyMending(player, totalExp);
+            if (leftoverExp > 0) {
+                player.giveExp(leftoverExp);
+            }
+            try {
+                player.playSound(loc, Sound.ENTITY_EXPERIENCE_ORB_PICKUP, 0.5f, 1.2f);
+            } catch (Exception ignored) {
+            }
+            event.setCancelled(true);
+        }
+    }
+
+    /**
+     * Repairs equipped items with Mending enchantment using the collected XP.
+     * Returns remaining XP to be added to the player's experience bar.
+     */
+    public static int applyMending(Player player, int totalExp) {
+        if (player == null || totalExp <= 0) {
+            return totalExp;
+        }
+        int remainingXp = totalExp;
+        PlayerInventory inv = player.getInventory();
+
+        List<ItemStack> candidates = new ArrayList<>();
+        ItemStack main = inv.getItemInMainHand();
+        if (isDamagedMending(main)) candidates.add(main);
+
+        ItemStack off = inv.getItemInOffHand();
+        if (isDamagedMending(off)) candidates.add(off);
+
+        for (ItemStack armor : inv.getArmorContents()) {
+            if (isDamagedMending(armor)) candidates.add(armor);
+        }
+
+        for (ItemStack item : candidates) {
+            if (remainingXp <= 0) {
+                break;
+            }
+            if (item.getItemMeta() instanceof Damageable dmg && dmg.hasDamage()) {
+                int damage = dmg.getDamage();
+                int[] repair = calculateMendingRepair(damage, remainingXp);
+                int repaired = repair[0];
+                int xpUsed = repair[1];
+                if (repaired > 0) {
+                    dmg.setDamage(damage - repaired);
+                    item.setItemMeta(dmg);
+                    remainingXp -= xpUsed;
+                }
+            }
+        }
+        return remainingXp;
+    }
+
+    private static boolean isDamagedMending(ItemStack item) {
+        if (item == null || item.getType() == Material.AIR || !item.hasItemMeta()) {
+            return false;
+        }
+        if (!item.containsEnchantment(Enchantment.MENDING)) {
+            return false;
+        }
+        if (item.getItemMeta() instanceof Damageable dmg) {
+            return dmg.hasDamage() && dmg.getDamage() > 0;
+        }
+        return false;
+    }
+
+    /**
+     * Calculates repair amount and used XP for a given damage and available XP.
+     * Returns an int array: [durabilityRepaired, xpUsed].
+     */
+    public static int[] calculateMendingRepair(int damage, int availableXp) {
+        if (damage <= 0 || availableXp <= 0) {
+            return new int[]{0, 0};
+        }
+        int durabilityToRepair = Math.min(damage, availableXp * 2);
+        int xpUsed = (durabilityToRepair + 1) / 2;
+        return new int[]{durabilityToRepair, xpUsed};
+    }
+
+    /**
+     * Consolidates spawned items of the same type in a 4-block radius into unified stacks.
+     */
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onItemSpawn(ItemSpawnEvent event) {
+        Item item = event.getEntity();
+        ItemStack stack = item.getItemStack();
+        if (stack.getAmount() >= stack.getMaxStackSize() || item.getWorld() == null) {
+            return;
+        }
+
+        try {
+            for (Entity e : item.getWorld().getNearbyEntities(item.getLocation(), 4.0, 4.0, 4.0)) {
+                if (e instanceof Item other && other != item && other.isValid()) {
+                    ItemStack otherStack = other.getItemStack();
+                    if (otherStack.isSimilar(stack)) {
+                        int toTransfer = calculateTransfer(stack.getAmount(), stack.getMaxStackSize(), otherStack.getAmount());
+                        if (toTransfer > 0) {
+                            stack.setAmount(stack.getAmount() + toTransfer);
+                            otherStack.setAmount(otherStack.getAmount() - toTransfer);
+                            if (otherStack.getAmount() <= 0) {
+                                other.remove();
+                            } else {
+                                other.setItemStack(otherStack);
+                            }
+                            item.setItemStack(stack);
+                            if (stack.getAmount() >= stack.getMaxStackSize()) {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (Exception ignored) {
+        }
+    }
+
+    /** Pure transfer amount calculator for stack consolidation. */
+    public static int calculateTransfer(int targetAmount, int targetMax, int sourceAmount) {
+        if (targetAmount < 0 || targetMax <= 0 || sourceAmount <= 0) {
+            return 0;
+        }
+        int canAdd = targetMax - targetAmount;
+        if (canAdd <= 0) {
+            return 0;
+        }
+        return Math.min(canAdd, sourceAmount);
+    }
+}

src/main/resources/config.yml

@@ -344,3 +344,43 @@ mortes:
       - "BONE | Osso da Sorte | Um ossinho pra você, campeão."
       - "COOKIE | Cookie de Consolação | Cookie de consolação. Vai que melhora."
       - "ROTTEN_FLESH | Carne Podre | É o que tinha sobrado na despensa."
+
+# --- Âncoras de Chunk (Chunk Loaders) ----------------------------------------
+chunkloader:
+  # Limite máximo de âncoras ativas por jogador por padrão.
+  # Pode ser alterado por jogador com /chunkloader limite <jogador> <qtd>.
+  limite-padrao: 1
+
+  # Exibe os marcadores de âncoras ativas no BlueMap.
+  bluemap: true
+
+  # Configurações de simulação de entidades na chunk carregada:
+  simulacao:
+    # Se true, mantém ativas gaiolas de monstros (spawners de blaze, esqueletos, etc.)
+    # mesmo sem jogadores por perto.
+    gaiolas-ativas: true
+
+    # Se true, simula o surgimento natural de monstros em plataformas escuras,
+    # slime chunks e fortalezas do nether. Se false, apenas entidades existentes funcionam.
+    spawn-monstros: true
+
+    # Teto máximo de monstros na chunk antes de pausar o spawn natural (evita acúmulo de lag).
+    limite-monstros-chunk: 20
+
+    # Se true, mantém animais, aldeões, ferro-golems e colheitas sendo processados na chunk.
+    tick-entidades-passivas: true
+
+  # Sistema de combustível e tempo de expiração:
+  combustivel:
+    # Se true, âncoras requerem abastecimento com itens e têm tempo de expiração.
+    # Se false, todas as âncoras colocadas são permanentes por padrão.
+    requer-tempo: true
+
+    # Tempo inicial padrão dado ao criar e colocar uma nova âncora (em horas).
+    tempo-inicial-horas: 24
+
+# --- Salva-Void (Resgate de Morte no Vazio) -----------------------------------
+salvavoid:
+  # Raio máximo de busca em blocos a partir de onde o jogador caiu para achar
+  # terreno seguro e colocar o baú com os itens resgatados.
+  raio-busca: 32

src/main/resources/plugin.yml

@@ -98,10 +98,20 @@ commands:
     description: Escolhe qual conquista você exibe como título no chat.
     usage: /titulo [nome|limpar]
     aliases: [titulos, title]
+  chunkloader:
+    description: Gerenciamento de Âncoras de Chunk (chunk loaders).
+    usage: /chunkloader [listar|info|remover|receita]
+    aliases: [ancora, ancoras, chunkloaders]
 
 permissions:
   # Declared explicitly: an undeclared Bukkit permission falls back to op-only,
   # which would silently stop normal players reacting, voting or guessing.
+  canalhandia.chunkloader:
+    description: Permite usar e criar Âncoras de Chunk.
+    default: true
+  canalhandia.chunkloader.admin:
+    description: Permite gerenciar e remover qualquer Âncora de Chunk no servidor.
+    default: op
   canalhandia.reagir:
     description: Permite reagir e prestar luto.
     default: true

src/test/java/dev/marcospaulo/canalhandia/ChunkLoaderTest.java

@@ -0,0 +1,231 @@
+package dev.marcospaulo.canalhandia;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.util.List;
+
+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 ChunkLoaderTest {
+
+    @TempDir
+    Path tempDir;
+
+    private File file;
+    private ChunkLoaders loaders;
+
+    @BeforeEach
+    void setUp() {
+        file = tempDir.resolve("chunks.yml").toFile();
+        loaders = new ChunkLoaders(null, file);
+    }
+
+    @AfterEach
+    void tearDown() {
+        if (loaders != null) {
+            loaders.flush();
+        }
+    }
+
+    @Test
+    void startsEmpty() {
+        assertEquals(0, loaders.size());
+        assertTrue(loaders.all().isEmpty());
+    }
+
+    @Test
+    void addsAndCalculatesChunkCoordinates() {
+        ChunkLoader loader = loaders.add("uuid-marcos", "Marcos", "world", 100, 64, 200);
+        assertEquals(1, loader.id());
+        assertEquals("uuid-marcos", loader.ownerUuid());
+        assertEquals("Marcos", loader.ownerName());
+        assertEquals(6, loader.chunkX()); // 100 >> 4 = 6
+        assertEquals(12, loader.chunkZ()); // 200 >> 4 = 12
+        assertEquals("100, 64, 200 (world)", loader.place());
+        assertEquals("[6, 12]", loader.chunkCoords());
+        assertEquals(1, loaders.size());
+    }
+
+    @Test
+    void queriesByChunkLocationAndOwner() {
+        ChunkLoader l1 = loaders.add("uuid-marcos", "Marcos", "world", 16, 64, 32);
+        ChunkLoader l2 = loaders.add("uuid-ana", "Ana", "world_nether", 0, 70, 0);
+
+        assertEquals(l1, loaders.byLocation("world", 16, 64, 32));
+        assertNull(loaders.byLocation("world", 17, 64, 32));
+
+        assertEquals(l1, loaders.byChunk("world", 1, 2));
+        assertEquals(l2, loaders.byChunk("world_nether", 0, 0));
+        assertNull(loaders.byChunk("world", 0, 0));
+
+        List<ChunkLoader> marcosLoaders = loaders.byOwner("uuid-marcos");
+        assertEquals(1, marcosLoaders.size());
+        assertEquals(l1, marcosLoaders.get(0));
+
+        List<ChunkLoader> anaLoaders = loaders.byOwner("uuid-ana");
+        assertEquals(1, anaLoaders.size());
+        assertEquals(l2, anaLoaders.get(0));
+    }
+
+    @Test
+    void removesLoaderById() {
+        ChunkLoader l1 = loaders.add("uuid-marcos", "Marcos", "world", 16, 64, 32);
+        assertTrue(loaders.remove(l1.id()));
+        assertEquals(0, loaders.size());
+        assertNull(loaders.byId(l1.id()));
+        assertFalse(loaders.remove(l1.id()));
+    }
+
+    @Test
+    void persistsToDiskAndReloads() {
+        loaders.add("uuid-marcos", "Marcos", "world", 100, 64, 200);
+        loaders.add("uuid-ana", "Ana", "world_nether", 50, 70, -50);
+        loaders.flush();
+
+        ChunkLoaders reloaded = new ChunkLoaders(null, file);
+        assertEquals(2, reloaded.size());
+
+        ChunkLoader l1 = reloaded.byId(1);
+        assertNotNull(l1);
+        assertEquals("uuid-marcos", l1.ownerUuid());
+        assertEquals(6, l1.chunkX());
+        assertEquals(12, l1.chunkZ());
+
+        ChunkLoader l2 = reloaded.byId(2);
+        assertNotNull(l2);
+        assertEquals("uuid-ana", l2.ownerUuid());
+    }
+
+    @Test
+    void renamesAndTogglesEnabledState() {
+        ChunkLoader loader = loaders.add("uuid-marcos", "Marcos", "world", 100, 64, 200);
+        assertEquals("#1", loader.simpleName());
+        assertTrue(loader.enabled());
+
+        assertTrue(loaders.rename(loader.id(), "Farm de Ferro"));
+        ChunkLoader renamed = loaders.byId(loader.id());
+        assertNotNull(renamed);
+        assertEquals("Farm de Ferro", renamed.name());
+        assertEquals("Farm de Ferro (#1)", renamed.displayName());
+        assertEquals("Farm de Ferro", renamed.simpleName());
+
+        assertEquals(renamed, loaders.find("Farm de Ferro"));
+        assertEquals(renamed, loaders.find("#1"));
+        assertEquals(renamed, loaders.find("1"));
+
+        // Loader 2 named "1" should be prioritized over ID 1 when querying by plain "1"
+        ChunkLoader loader2 = loaders.add("uuid-marcos", "Marcos", "world", 200, 64, 300, "1", 0L);
+        assertEquals(loader2, loaders.find("1"));
+        assertEquals(renamed, loaders.find("#1"));
+        assertEquals(loader2, loaders.find("#2"));
+
+        assertTrue(loaders.setEnabled(loader.id(), false));
+        ChunkLoader disabled = loaders.byId(loader.id());
+        assertNotNull(disabled);
+        assertFalse(disabled.enabled());
+
+        loaders.flush();
+        ChunkLoaders reloaded = new ChunkLoaders(null, file);
+        ChunkLoader reloadedLoader = reloaded.byId(loader.id());
+        assertNotNull(reloadedLoader);
+        assertEquals("Farm de Ferro", reloadedLoader.name());
+        assertFalse(reloadedLoader.enabled());
+    }
+
+    @Test
+    void managesExpirationAndFuelTime() {
+        ChunkLoader loader = loaders.add("uuid-marcos", "Marcos", "world", 100, 64, 200, "Base", 0L);
+        assertEquals("Permanente", loader.timeLeft());
+        assertFalse(loader.isExpired());
+
+        assertTrue(loaders.addTime(loader.id(), 2 * 3600_000L)); // +2h
+        ChunkLoader timed = loaders.byId(loader.id());
+        assertNotNull(timed);
+        assertTrue(timed.expiresAt() > System.currentTimeMillis());
+        assertFalse(timed.isExpired());
+        assertTrue(timed.timeLeft().contains("h"));
+
+        ChunkLoader expired = timed.withExpiresAt(System.currentTimeMillis() - 1000L);
+        assertTrue(expired.isExpired());
+        assertEquals("Expirado", expired.timeLeft());
+
+        assertTrue(loaders.setExpiresAt(loader.id(), 0L));
+        ChunkLoader permanent = loaders.byId(loader.id());
+        assertNotNull(permanent);
+        assertEquals(0L, permanent.expiresAt());
+        assertEquals("Permanente", permanent.timeLeft());
+        assertFalse(permanent.isExpired());
+    }
+
+    @Test
+    void pickEntityTypeReturnsExpectedEntitiesByEnvironment() {
+        // Nether
+        assertEquals(org.bukkit.entity.EntityType.ZOMBIFIED_PIGLIN,
+                ChunkLoaders.pickEntityType(org.bukkit.World.Environment.NETHER, false, 64, 0, 10));
+        assertEquals(org.bukkit.entity.EntityType.WITHER_SKELETON,
+                ChunkLoaders.pickEntityType(org.bukkit.World.Environment.NETHER, false, 64, 0, 50));
+        assertEquals(org.bukkit.entity.EntityType.BLAZE,
+                ChunkLoaders.pickEntityType(org.bukkit.World.Environment.NETHER, false, 64, 0, 75));
+        assertEquals(org.bukkit.entity.EntityType.MAGMA_CUBE,
+                ChunkLoaders.pickEntityType(org.bukkit.World.Environment.NETHER, false, 64, 0, 90));
+        assertNull(ChunkLoaders.pickEntityType(org.bukkit.World.Environment.NETHER, false, 64, 12, 10));
+
+        // End
+        assertEquals(org.bukkit.entity.EntityType.ENDERMAN,
+                ChunkLoaders.pickEntityType(org.bukkit.World.Environment.THE_END, false, 64, 15, 50));
+
+        // Overworld Slime Chunk
+        assertEquals(org.bukkit.entity.EntityType.SLIME,
+                ChunkLoaders.pickEntityType(org.bukkit.World.Environment.NORMAL, true, 30, 5, 0));
+
+        // Overworld Normal Darkness
+        assertEquals(org.bukkit.entity.EntityType.ZOMBIE,
+                ChunkLoaders.pickEntityType(org.bukkit.World.Environment.NORMAL, false, 64, 0, 10));
+        assertEquals(org.bukkit.entity.EntityType.SKELETON,
+                ChunkLoaders.pickEntityType(org.bukkit.World.Environment.NORMAL, false, 64, 0, 45));
+        assertEquals(org.bukkit.entity.EntityType.CREEPER,
+                ChunkLoaders.pickEntityType(org.bukkit.World.Environment.NORMAL, false, 64, 0, 75));
+        assertEquals(org.bukkit.entity.EntityType.SPIDER,
+                ChunkLoaders.pickEntityType(org.bukkit.World.Environment.NORMAL, false, 64, 0, 90));
+        assertEquals(org.bukkit.entity.EntityType.WITCH,
+                ChunkLoaders.pickEntityType(org.bukkit.World.Environment.NORMAL, false, 64, 0, 99));
+
+        // Overworld in Light -> Null
+        assertNull(ChunkLoaders.pickEntityType(org.bukkit.World.Environment.NORMAL, false, 64, 5, 10));
+    }
+
+    @Test
+    void createsLoaderWithInitialExpiration() {
+        long targetExpiry = System.currentTimeMillis() + 86400_000L;
+        ChunkLoader loader = loaders.add("uuid-1", "Marcos", "world", 100, 64, 200, "Base", targetExpiry);
+        assertEquals(targetExpiry, loader.expiresAt());
+        assertFalse(loader.isExpired());
+        assertTrue(loader.timeLeft().contains("h"));
+    }
+
+    @Test
+    void recognizesTrapdoorsCorrectly() {
+        assertTrue(ChunkLoaders.isTrapdoor(org.bukkit.Material.OAK_TRAPDOOR));
+        assertTrue(ChunkLoaders.isTrapdoor(org.bukkit.Material.IRON_TRAPDOOR));
+        assertTrue(ChunkLoaders.isTrapdoor(org.bukkit.Material.SPRUCE_TRAPDOOR));
+        assertFalse(ChunkLoaders.isTrapdoor(org.bukkit.Material.AIR));
+        assertFalse(ChunkLoaders.isTrapdoor(org.bukkit.Material.STONE));
+        assertFalse(ChunkLoaders.isTrapdoor(null));
+    }
+
+    @Test
+    void simulationSafelyNoopsWithNullPlugin() {
+        loaders.startSimulation();
+        loaders.tickMobSimulation();
+        loaders.stopSimulation();
+    }
+}

src/test/java/dev/marcospaulo/canalhandia/PlayerMemoryTest.java

@@ -143,6 +143,10 @@ class PlayerMemoryTest {
         assertNotNull(fact);
         assertTrue(fact.contains("estou construindo uma pirâmide gigante"));
         assertNull(PlayerMemory.extractHeuristicFact("quantos blocos tem o mundo?"));
+
+        // Leading / trailing whitespace index alignment
+        assertEquals("minha base fica no topo", PlayerMemory.extractHeuristicFact("   minha base fica no topo!  "));
+        assertEquals("estou construindo uma ponte", PlayerMemory.extractHeuristicFact("  oi, estou construindo uma ponte..."));
     }
 
     @Test

src/test/java/dev/marcospaulo/canalhandia/TitlesTest.java

@@ -25,10 +25,14 @@ class TitlesTest {
     void matchesEarnedTitleByKeyAndByName() {
         Achievement pedreiro = Achievement.byKey("pedreiro");
         Achievement veterano = Achievement.byKey("veterano");
-        List<Achievement> earned = List.of(pedreiro, veterano);
+        Achievement cacador = Achievement.byKey("cacador");
+        List<Achievement> earned = List.of(pedreiro, veterano, cacador);
         assertSame(pedreiro, CanalhandiaCommand.matchEarned("pedreiro", earned));
         assertSame(veterano, CanalhandiaCommand.matchEarned("Veterano", earned)); // display name, ci
         assertSame(pedreiro, CanalhandiaCommand.matchEarned("Pedreiro", earned));
+        assertSame(cacador, CanalhandiaCommand.matchEarned("cacador", earned));
+        assertSame(cacador, CanalhandiaCommand.matchEarned("Caçador", earned));
+        assertSame(cacador, CanalhandiaCommand.matchEarned("Cacador", earned));
     }
 
     @Test

src/test/java/dev/marcospaulo/canalhandia/VoidProtectionTest.java

@@ -0,0 +1,84 @@
+package dev.marcospaulo.canalhandia;
+
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.inventory.ItemStack;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class VoidProtectionTest {
+
+    @Test
+    void identifiesVoidDeathByCause() {
+        assertTrue(VoidProtection.isVoidDeath(100.0, -64.0, EntityDamageEvent.DamageCause.VOID));
+        assertTrue(VoidProtection.isVoidDeath(-70.0, -64.0, EntityDamageEvent.DamageCause.VOID));
+    }
+
+    @Test
+    void identifiesVoidDeathByCoordinatesBelowMinHeight() {
+        assertTrue(VoidProtection.isVoidDeath(-65.0, -64.0, EntityDamageEvent.DamageCause.FALL));
+        assertTrue(VoidProtection.isVoidDeath(-100.0, 0.0, EntityDamageEvent.DamageCause.CUSTOM));
+        assertFalse(VoidProtection.isVoidDeath(50.0, -64.0, EntityDamageEvent.DamageCause.FALL));
+        assertFalse(VoidProtection.isVoidDeath(10.0, 0.0, EntityDamageEvent.DamageCause.LAVA));
+    }
+
+    @Test
+    void handlesNullWorldOrLocationsGracefully() {
+        assertNull(VoidProtection.findSafeChestLocation(null, null, 10));
+        assertNull(VoidProtection.findSafeChestLocation(null, null, 0));
+        assertFalse(VoidProtection.rescueToChest(null, null));
+        assertFalse(VoidProtection.rescueToChest(List.of(), null));
+    }
+
+    @Test
+    void validatesSafeGroundMaterials() {
+        assertTrue(VoidProtection.isSafeGroundMaterial(org.bukkit.Material.STONE));
+        assertTrue(VoidProtection.isSafeGroundMaterial(org.bukkit.Material.GRASS_BLOCK));
+        assertTrue(VoidProtection.isSafeGroundMaterial(org.bukkit.Material.DIRT));
+        assertTrue(VoidProtection.isSafeGroundMaterial(org.bukkit.Material.OBSIDIAN));
+
+        assertFalse(VoidProtection.isSafeGroundMaterial(null));
+        assertFalse(VoidProtection.isSafeGroundMaterial(org.bukkit.Material.AIR));
+        assertFalse(VoidProtection.isSafeGroundMaterial(org.bukkit.Material.LAVA));
+        assertFalse(VoidProtection.isSafeGroundMaterial(org.bukkit.Material.FIRE));
+        assertFalse(VoidProtection.isSafeGroundMaterial(org.bukkit.Material.SOUL_FIRE));
+        assertFalse(VoidProtection.isSafeGroundMaterial(org.bukkit.Material.CACTUS));
+        assertFalse(VoidProtection.isSafeGroundMaterial(org.bukkit.Material.MAGMA_BLOCK));
+        assertFalse(VoidProtection.isSafeGroundMaterial(org.bukkit.Material.SWEET_BERRY_BUSH));
+        assertFalse(VoidProtection.isSafeGroundMaterial(org.bukkit.Material.WITHER_ROSE));
+        assertFalse(VoidProtection.isSafeGroundMaterial(org.bukkit.Material.POWDER_SNOW));
+    }
+
+    @Test
+    void validatesReplaceableMaterials() {
+        assertTrue(VoidProtection.isReplaceableMaterial(org.bukkit.Material.AIR));
+        assertTrue(VoidProtection.isReplaceableMaterial(org.bukkit.Material.CAVE_AIR));
+        assertTrue(VoidProtection.isReplaceableMaterial(org.bukkit.Material.VOID_AIR));
+        assertTrue(VoidProtection.isReplaceableMaterial(org.bukkit.Material.SHORT_GRASS));
+        assertTrue(VoidProtection.isReplaceableMaterial(org.bukkit.Material.TALL_GRASS));
+        assertTrue(VoidProtection.isReplaceableMaterial(org.bukkit.Material.SNOW));
+        assertTrue(VoidProtection.isReplaceableMaterial(org.bukkit.Material.FERN));
+        assertTrue(VoidProtection.isReplaceableMaterial(org.bukkit.Material.LARGE_FERN));
+
+        assertFalse(VoidProtection.isReplaceableMaterial(null));
+        assertFalse(VoidProtection.isReplaceableMaterial(org.bukkit.Material.STONE));
+        assertFalse(VoidProtection.isReplaceableMaterial(org.bukkit.Material.CHEST));
+        assertFalse(VoidProtection.isReplaceableMaterial(org.bukkit.Material.OBSIDIAN));
+    }
+
+    @Test
+    void nullBlocksAreNeitherSafeNorReplaceable() {
+        assertFalse(VoidProtection.isSafeGround(null));
+        assertFalse(VoidProtection.isReplaceable(null));
+    }
+
+    @Test
+    void calculatesRequiredSlotsAndChestFit() {
+        assertEquals(0, VoidProtection.calculateRequiredSlots(null));
+        assertEquals(0, VoidProtection.calculateRequiredSlots(List.of()));
+        assertTrue(VoidProtection.canFitInSingleChest(List.of()));
+        assertTrue(VoidProtection.canFitInDoubleChest(List.of()));
+    }
+}

src/test/java/dev/marcospaulo/canalhandia/XpAndItemMergeTest.java

@@ -0,0 +1,55 @@
+package dev.marcospaulo.canalhandia;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class XpAndItemMergeTest {
+
+    @Test
+    void handlesZeroOrNegativeAmountsGracefully() {
+        assertEquals(0, XpAndItemMergeListener.calculateTransfer(0, 0, 0));
+        assertEquals(0, XpAndItemMergeListener.calculateTransfer(-1, 16, 5));
+        assertEquals(0, XpAndItemMergeListener.calculateTransfer(16, 16, 5));
+        assertEquals(0, XpAndItemMergeListener.calculateTransfer(10, 16, 0));
+    }
+
+    @Test
+    void calculatesTransfersUpToMaxCapacity() {
+        // Target has 10, max is 16, source has 10 -> can transfer 6
+        assertEquals(6, XpAndItemMergeListener.calculateTransfer(10, 16, 10));
+
+        // Target has 5, max is 64, source has 20 -> can transfer all 20
+        assertEquals(20, XpAndItemMergeListener.calculateTransfer(5, 64, 20));
+
+        // Target has 63, max is 64, source has 10 -> can transfer 1
+        assertEquals(1, XpAndItemMergeListener.calculateTransfer(63, 64, 10));
+    }
+
+    @Test
+    void calculatesMendingRepairCorrectly() {
+        // Zero damage or zero XP -> 0 repair
+        int[] r1 = XpAndItemMergeListener.calculateMendingRepair(0, 50);
+        assertEquals(0, r1[0]);
+        assertEquals(0, r1[1]);
+
+        int[] r2 = XpAndItemMergeListener.calculateMendingRepair(50, 0);
+        assertEquals(0, r2[0]);
+        assertEquals(0, r2[1]);
+
+        // 10 damage, 100 XP -> repairs 10 durability, uses 5 XP
+        int[] r3 = XpAndItemMergeListener.calculateMendingRepair(10, 100);
+        assertEquals(10, r3[0]);
+        assertEquals(5, r3[1]);
+
+        // 5 damage, 10 XP -> repairs 5 durability, uses 3 XP
+        int[] r4 = XpAndItemMergeListener.calculateMendingRepair(5, 10);
+        assertEquals(5, r4[0]);
+        assertEquals(3, r4[1]);
+
+        // 10 damage, 2 XP -> repairs 4 durability (2 * 2), uses 2 XP
+        int[] r5 = XpAndItemMergeListener.calculateMendingRepair(10, 2);
+        assertEquals(4, r5[0]);
+        assertEquals(2, r5[1]);
+    }
+}