Add world ref api to handle stored world references for later use

Merge pull request #3517 from Multiverse/chore/artifact-comment
Improve artifact PR comment with better message and supports forks
2026-11-04 16:50:03 -05:00 · 2026-09-27 22:54:19 +08:00 · 2026-09-27 16:23:48 +08:00 · 2026-09-27 16:20:31 +08:00 · 2026-09-21 15:52:44 +08:00 · 2026-09-21 15:41:15 +08:00
176 changed files with 10554 additions and 1939 deletions
@@ -0,0 +1,84 @@
+name: 'Generic: Artifact Comment'
+
+on:
+  workflow_call:
+    inputs:
+      plugin_name:
+        description: 'Plugin name used by Generic: Test'
+        required: true
+        type: string
+
+jobs:
+  comment-artifact:
+    if: >-
+      github.event_name == 'workflow_run' &&
+      github.event.workflow_run.event == 'pull_request' &&
+      github.event.workflow_run.conclusion == 'success'
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      pull-requests: write
+    steps:
+      # Run separately so fork builds can post comments without a write token.
+      # Do not check out or execute code from the pull request in this workflow.
+      - name: Find pull request and artifact
+        id: artifact
+        uses: actions/github-script@v7
+        env:
+          PLUGIN_NAME: ${{ inputs.plugin_name }}
+        with:
+          script: |
+            const run = context.payload.workflow_run;
+            // Fork runs can have an empty pull_requests array in the event.
+            const pulls = await github.paginate(github.rest.pulls.list, {
+              ...context.repo,
+              state: 'open',
+              head: `${run.head_repository.owner.login}:${run.head_branch}`,
+              per_page: 100,
+            });
+            const pull = pulls.find(pr =>
+              pr.head.repo?.id === run.head_repository.id &&
+              pr.head.ref === run.head_branch &&
+              pr.head.sha === run.head_sha
+            );
+            if (!pull) {
+              core.info('No open pull request matches this build; skipping comment.');
+              return;
+            }
+
+            const artifacts = await github.paginate(github.rest.actions.listWorkflowRunArtifacts, {
+              ...context.repo,
+              run_id: run.id,
+              per_page: 100,
+            });
+            const artifact = artifacts.find(item =>
+              item.name === `${process.env.PLUGIN_NAME}-pr${pull.number}` && !item.expired
+            );
+            if (!artifact) {
+              core.info('No build artifact is available; skipping comment.');
+              return;
+            }
+
+            core.setOutput('number', pull.number);
+            core.setOutput('url', `${run.html_url}/artifacts/${artifact.id}`);
+
+      - name: Comment artifact
+        if: steps.artifact.outputs.number != ''
+        uses: marocchino/sticky-pull-request-comment@v3
+        with:
+          number: ${{ steps.artifact.outputs.number }}
+          header: build-artifact-${{ inputs.plugin_name }}
+          message: |
+            ### ✅ `${{ inputs.plugin_name }}` test build ready
+
+            The build and tests passed. This PR build is ready to try.
+
+            **[⬇️ Download test build](${{ steps.artifact.outputs.url }})**
+            Extract the downloaded ZIP to get the plugin JAR.
+
+            | Build details | |
+            | --- | --- |
+            | Commit | `${{ github.event.workflow_run.head_sha }}` |
+            | Workflow | [Run #${{ github.event.workflow_run.run_number }}](${{ github.event.workflow_run.html_url }}) |
+
+            <sub>Sign in to GitHub to download. Artifacts expire after the repository's retention period. This comment updates after successful builds.</sub>
@@ -11,9 +11,9 @@ jobs:
      pull-requests: write
    continue-on-error: true
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5

-      - uses: dbelyaev/action-checkstyle@v0.8.4
+      - uses: dbelyaev/action-checkstyle@v3
        continue-on-error: true
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
@@ -107,9 +107,9 @@ jobs:
        files: '["${{ github.workspace }}/${{ inputs.plugin_name }}-${{ steps.release-info.outputs.tag_name }}.jar"]'
        name: ${{ steps.release-info.outputs.tag_name }}
        changelog: ${{ steps.release-artifact.outputs.body }}
-        game_versions: 1.21.10, 1.21.9, 1.21.8, 1.21.7, 1.21.6, 1.21.5, 1.21.4, 1.21.3, 1.21.2, 1.21.1, 1.21, 1.20.6, 1.20.5, 1.20.4, 1.20.3, 1.20.2, 1.20.1, 1.20, 1.19.4, 1.19.3, 1.19.2, 1.19.1, 1.19, 1.18.2
+        game_versions: 26.3, 26.2, 26.1.2, 26.1.1, 26.1, 1.21.11, 1.21.10, 1.21.9, 1.21.8, 1.21.7, 1.21.6, 1.21.5, 1.21.4, 1.21.3, 1.21.2, 1.21.1, 1.21, 1.20.6, 1.20.5, 1.20.4, 1.20.3, 1.20.2, 1.20.1, 1.20, 1.19.4, 1.19.3, 1.19.2, 1.19.1, 1.19, 1.18.2
        version_type: ${{ steps.parse-release-type.outputs.release_type }}
-        loaders: bukkit, spigot, paper
+        loaders: bukkit, spigot, paper, purpur
        dependencies: ${{ inputs.modrinth_dependencies }}

    - name: Upload to DBO
@@ -121,7 +121,7 @@ jobs:
        changelog: ${{ steps.release-artifact.outputs.body }}
        changelog_type: markdown
        display_name: ${{ steps.release-info.outputs.tag_name }}
-        game_versions: 1.21.10, 1.21.9, 1.21.8, 1.21.7, 1.21.6, 1.21.5, 1.21.4, 1.21.3, 1.21.2, 1.21.1, 1.21, 1.20.6, 1.20.5, 1.20.4, 1.20.3, 1.20.2, 1.20.1, 1.20, 1.19.4, 1.19.3, 1.19.2, 1.19.1, 1.19, 1.18.2
+        game_versions: 26.3, 26.2, 26.1.2, 26.1.1, 26.1, 1.21.11, 1.21.10, 1.21.9, 1.21.8, 1.21.7, 1.21.6, 1.21.5, 1.21.4, 1.21.3, 1.21.2, 1.21.1, 1.21, 1.20.6, 1.20.5, 1.20.4, 1.20.3, 1.20.2, 1.20.1, 1.20, 1.19.4, 1.19.3, 1.19.2, 1.19.1, 1.19, 1.18.2
        release_type: ${{ steps.parse-release-type.outputs.release_type }}
        project_relations: ${{ inputs.dbo_project_relations }}
        file_path: ${{ github.workspace }}/${{ inputs.plugin_name }}-${{ steps.release-info.outputs.tag_name }}.jar
@@ -136,5 +136,5 @@ jobs:
        channel: ${{ steps.parse-release-type.outputs.release_type }}
        files: '[{"path": "${{ github.workspace }}/${{ inputs.plugin_name }}-${{ steps.release-info.outputs.tag_name }}.jar", "platforms": ["PAPER"]}]'
        description: ${{ steps.release-artifact.outputs.body }}
-        platform_dependencies: '{"PAPER": ["1.18.2-1.21.10"]}'
+        platform_dependencies: '{"PAPER": ["1.18.2-26.3"]}'
        plugin_dependencies: ${{ inputs.hangar_plugin_dependencies }}
@@ -36,13 +36,3 @@ jobs:
        with:
          name: ${{ inputs.plugin_name }}-pr${{ github.event.pull_request.number }}
          path: build/libs/${{ inputs.plugin_name }}-pr${{ github.event.pull_request.number }}.jar
-
-  comment-artifact:
-    needs: test-and-artifact
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: write
-    steps:
-      - uses: benwoo1110/artifact-comment-action@v1
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
@@ -0,0 +1,15 @@
+name: 'PR: Artifact Comment'
+
+on:
+  workflow_run:
+    workflows: ['PR: Test']
+    types: [completed]
+
+jobs:
+  comment-artifact:
+    permissions:
+      actions: read
+      pull-requests: write
+    uses: ./.github/workflows/generic.artifact_comment.yml
+    with:
+      plugin_name: multiverse-core
@@ -9,13 +9,13 @@ description = 'Multiverse-Core'

 repositories {
    maven {
-        name = 'aikar repo'
-        url = uri('https://repo.aikar.co/content/groups/aikar/')
+        name = 'jitpack repo'
+        url = uri('https://jitpack.io')
    }

    maven {
-        name = 'glaremasters repo'
-        url = 'https://repo.glaremasters.me/repository/towny/'
+        name = 'aikar repo'
+        url = uri('https://repo.aikar.co/content/groups/aikar/')
    }

    maven {
@@ -25,9 +25,9 @@ repositories {
 }

 configure(apiDependencies) {
-    serverApiVersion = '1.21.8-R0.1-SNAPSHOT'
+    serverApiVersion = '1.21.11-R0.1-SNAPSHOT'
    mockBukkitServerApiVersion = '1.21'
-    mockBukkitVersion = '4.84.0'
+    mockBukkitVersion = '4.110.0'
 }

 dependencies {
@@ -37,18 +37,18 @@ dependencies {
    }

    // PlaceholderAPI
-    externalPlugin 'me.clip:placeholderapi:2.11.6'
+    externalPlugin 'me.clip:placeholderapi:2.12.3'

    // Command Framework
    shadowed 'co.aikar:acf-paper:0.5.1-SNAPSHOT'

    // Config
-    shadowed('io.github.townyadvanced.commentedconfiguration:CommentedConfiguration:1.0.1') {
+    shadowed('com.github.TownyAdvanced:CommentedConfiguration:1.0.3') {
        exclude group: 'org.spigotmc', module: 'spigot-api'
    }

    // Utils
-    shadowed 'io.vavr:vavr:0.10.7'
+    shadowed 'io.vavr:vavr:1.0.1'
    shadowed 'org.glassfish.hk2:hk2-locator:3.1.1'
    shadowed('org.glassfish.hk2:hk2-inhabitant-generator:3.1.1') {
        exclude group: 'org.apache.maven', module: 'maven-core'
@@ -57,11 +57,11 @@ dependencies {
        exclude group: 'junit', module: 'junit'
    }
    shadowed 'de.themoep.idconverter:mappings:1.2-SNAPSHOT'
-    shadowed('org.bstats:bstats-bukkit:3.1.0') {
+    shadowed('org.bstats:bstats-bukkit:3.2.1') {
        exclude group: 'org.bukkit', module: 'bukkit'
    }
-    shadowed 'net.minidev:json-smart:2.5.2'
-    shadowed 'org.jetbrains:annotations:26.0.2'
+    shadowed 'net.minidev:json-smart:2.6.0'
+    shadowed 'org.jetbrains:annotations:26.1.0'
    shadowed 'io.papermc:paperlib:1.0.8'

    // Tests
@@ -30,6 +30,7 @@ import org.mvplugins.multiverse.core.inject.PluginServiceLocatorFactory;
 import org.mvplugins.multiverse.core.module.MultiverseModule;
 import org.mvplugins.multiverse.core.utils.StringFormatter;
 import org.mvplugins.multiverse.core.world.WorldManager;
+import org.mvplugins.multiverse.core.world.entity.SpawnCategoryMapper;
 import org.mvplugins.multiverse.core.world.location.NullSpawnLocation;
 import org.mvplugins.multiverse.core.world.location.SpawnLocation;
 import org.mvplugins.multiverse.core.world.location.UnloadedWorldLocation;
@@ -97,12 +98,16 @@ public class MultiverseCore extends MultiverseModule {
        }
        Logging.setShowingConfig(shouldShowConfig());

+        // Build it here so our logger can work, and failure messages will be logged
+        SpawnCategoryMapper.buildSpawnCategoryMap();
+
        // Initialize the worlds
-        worldManagerProvider.get().initAllWorlds().andThenTry(() -> {
+        Try.run(() -> {
+            setUpLocales();
+            worldManagerProvider.get().initAllWorlds();
            loadEconomist(); // Setup economy here so vault is loaded
            loadAnchors();
            registerDynamicListeners(CoreListener.class);
-            setUpLocales();
            registerCommands(CoreCommand.class);
            registerDestinations();
            setupMetrics();
@@ -124,9 +129,9 @@ public class MultiverseCore extends MultiverseModule {
    public void onDisable() {
        super.onDisable();
        MultiverseCoreApi.shutdown();
-        saveAllConfigs();
        shutdownDependencyInjection();
        PluginServiceLocatorFactory.get().shutdown();
+        Logging.info("- Disabled");
        Logging.shutdown();
    }

@@ -215,22 +220,23 @@ public class MultiverseCore extends MultiverseModule {
     */
    private Try<Void> saveAllConfigs() {
        return configProvider.get().save()
-                .flatMap(ignore -> worldManagerProvider.get().saveWorldsConfig())
-                .flatMap(ignore ->anchorManagerProvider.get().saveAllAnchors())
-                .onFailure(e -> {
-                    Logging.severe("Failed to save configs, things may not work as expected.");
-                });
+                .andThenTry(() -> worldManagerProvider.get().saveWorldsConfig())
+                .andThenTry(() -> anchorManagerProvider.get().saveAllAnchors())
+                .onFailure(e ->
+                        Logging.severe("Failed to save all configs, things may not work as expected. %s",
+                                e.getLocalizedMessage()));
    }

    /**
     * Logs the enable message.
     */
    private void logEnableMessage() {
-        Logging.config("\u001B[32mVersion %s (API v%s) Enabled - By %s\u001B[39m",
+        Logging.config("\u001B[32mVersion %s (API v%s) Enabled - By %s\u001B[0m",
                this.getDescription().getVersion(), getVersionAsNumber(), StringFormatter.joinAnd(getDescription().getAuthors()));

        if (configProvider.get().isShowingDonateMessage()) {
-            Logging.config("\u001B[32mLoving Multiverse-Core? Please consider supporting the project with a small donation: https://github.com/sponsors/Multiverse\u001B[39m");
+            Logging.config("\u001B[32mLoving Multiverse-Core? Please consider supporting the project with a " +
+                    "small donation: https://github.com/sponsors/Multiverse\u001B[0m");
        }
    }

@@ -1,9 +1,17 @@
 package org.mvplugins.multiverse.core;

+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Consumer;
+
+import com.dumptruckman.minecraft.util.Logging;
+import io.vavr.control.Try;
 import org.bukkit.Bukkit;
 import org.bukkit.plugin.ServicePriority;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
+
 import org.mvplugins.multiverse.core.anchor.AnchorManager;
 import org.mvplugins.multiverse.core.config.CoreConfig;
 import org.mvplugins.multiverse.core.destination.DestinationsProvider;
@@ -16,18 +24,13 @@ import org.mvplugins.multiverse.core.world.WorldManager;
 import org.mvplugins.multiverse.core.world.biomeprovider.BiomeProviderFactory;
 import org.mvplugins.multiverse.core.world.generators.GeneratorProvider;

-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
-import java.util.function.Consumer;
-
 /**
 * Provides access to the MultiverseCore API.
 */
-public class MultiverseCoreApi {
+public final class MultiverseCoreApi {

    private static MultiverseCoreApi instance;
-    private static final List<Consumer<MultiverseCoreApi>> whenLoadedCallbacks = new ArrayList<>();
+    private static final List<Consumer<MultiverseCoreApi>> WHEN_LOADED_CALLBACKS = new ArrayList<>();

    static void init(@NotNull MultiverseCore multiverseCore) {
        if (instance != null) {
@@ -36,11 +39,24 @@ public class MultiverseCoreApi {
        instance = new MultiverseCoreApi(multiverseCore.getServiceLocator());
        Bukkit.getServicesManager().register(MultiverseCoreApi.class, instance, multiverseCore, ServicePriority.Normal);

-        whenLoadedCallbacks.forEach(c -> c.accept(instance));
-        whenLoadedCallbacks.clear();
+        List<Consumer<MultiverseCoreApi>> callbacks = List.copyOf(WHEN_LOADED_CALLBACKS);
+        WHEN_LOADED_CALLBACKS.clear();
+        MultiverseCoreApi loadedApi = instance;
+        callbacks.forEach(callback -> runLoadCallback(callback, loadedApi));
+    }
+
+    private static void runLoadCallback(
+            @NotNull Consumer<MultiverseCoreApi> callback,
+            @NotNull MultiverseCoreApi loadedApi) {
+        Try.run(() -> callback.accept(loadedApi))
+                .onFailure(exception -> Logging.warning(
+                        "A Multiverse-Core API load callback failed: %s", exception.getMessage()));
    }

    static void shutdown() {
+        if (instance == null) {
+            return;
+        }
        Bukkit.getServicesManager().unregister(instance);
        instance = null;
    }
@@ -62,7 +78,7 @@ public class MultiverseCoreApi {
        if (instance != null) {
            consumer.accept(instance);
        } else {
-            whenLoadedCallbacks.add(consumer);
+            WHEN_LOADED_CALLBACKS.add(consumer);
        }
    }

@@ -1,6 +1,7 @@
 package org.mvplugins.multiverse.core;

 import com.google.common.collect.Lists;
+import io.vavr.control.Option;
 import jakarta.annotation.PostConstruct;
 import jakarta.inject.Inject;
 import me.clip.placeholderapi.expansion.PlaceholderExpansion;
@@ -12,11 +13,13 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jvnet.hk2.annotations.Service;

+import org.mvplugins.multiverse.core.config.CoreConfig;
 import org.mvplugins.multiverse.core.economy.MVEconomist;
 import org.mvplugins.multiverse.core.utils.MinecraftTimeFormatter;
 import org.mvplugins.multiverse.core.utils.REPatterns;
 import org.mvplugins.multiverse.core.utils.StringFormatter;
 import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
+import org.mvplugins.multiverse.core.world.MultiverseWorld;
 import org.mvplugins.multiverse.core.world.WorldManager;

 import java.util.List;
@@ -26,12 +29,17 @@ import java.util.Locale;
 final class PlaceholderExpansionHook extends PlaceholderExpansion {

    private final MultiverseCore plugin;
+    private final CoreConfig coreConfig;
    private final WorldManager worldManager;
    private final MVEconomist economist;

    @Inject
-    public PlaceholderExpansionHook(MultiverseCore plugin, WorldManager worldManager, MVEconomist economist) {
+    public PlaceholderExpansionHook(@NotNull MultiverseCore plugin,
+                                    @NotNull CoreConfig coreConfig,
+                                    @NotNull WorldManager worldManager,
+                                    @NotNull MVEconomist economist) {
        this.plugin = plugin;
+        this.coreConfig = coreConfig;
        this.worldManager = worldManager;
        this.economist = economist;
    }
@@ -42,6 +50,13 @@ final class PlaceholderExpansionHook extends PlaceholderExpansion {
        return super.register();
    }

+    @Override
+    public void warning(String msg) {
+        if (coreConfig.getWarnInvalidPapiFormat()) {
+            super.warning(msg);
+        }
+    }
+
    @Override
    public @NotNull String getIdentifier() {
        return "multiverse-core";
@@ -72,7 +87,8 @@ final class PlaceholderExpansionHook extends PlaceholderExpansion {
    @Override
    public @Nullable String onRequest(OfflinePlayer offlinePlayer, @NotNull String params) {
        // Split string in to an Array with underscores
-        List<String> paramsArray = Lists.newArrayList(REPatterns.UNDERSCORE.split(params));
+        List<String> paramsArray = Lists.newArrayList(
+                StringFormatter.parseQuotesInArgs(REPatterns.UNDERSCORE.split(params), "_"));

        // No placeholder defined
        if (paramsArray.isEmpty()) {
@@ -80,130 +96,115 @@ final class PlaceholderExpansionHook extends PlaceholderExpansion {
            return null;
        }

-        final var placeholder = paramsArray.removeFirst();
+        final var placeholder = paramsArray.remove(0).toLowerCase(Locale.ENGLISH);

-        String worldName = parseWorldName(offlinePlayer, paramsArray);
-        if (worldName == null) return null;
-
-        return worldManager.getLoadedWorld(worldName)
-                .onEmpty(() -> warning("Multiverse World not found: " + worldName))
-                .map(world -> getWorldPlaceHolderValue(placeholder, paramsArray, world))
-                .getOrNull();
+        return parseWorldName(offlinePlayer, paramsArray)
+                .flatMap(worldName -> worldManager.getWorld(worldName)
+                    .onEmpty(() -> warning("Multiverse World not found: " + worldName)))
+                .flatMap(world -> world.asLoadedWorld()
+                        .flatMap(loadedWorld -> getLoadedWorldPlaceHolderValue(placeholder, paramsArray, loadedWorld))
+                        .orElse(() -> getWorldPlaceHolderValue(placeholder, paramsArray, world)))
+                .getOrElse(() -> coreConfig.getInvalidPapiFormatReturnsBlank() ? "" : null);
    }

-    private @Nullable String parseWorldName(OfflinePlayer offlinePlayer, List<String> paramsArray) {
+    private @NotNull Option<String> parseWorldName(OfflinePlayer offlinePlayer, List<String> paramsArray) {
        // No world defined, get from player
        if (paramsArray.isEmpty()) {
            if (offlinePlayer instanceof Player player) {
-                return player.getWorld().getName();
+                return Option.of(player.getWorld().getName());
            } else {
                warning("You must specify a world name for non-player placeholders");
-                return null;
+                return Option.none();
            }
        }

        // Try get from params
-        String paramWorldName = paramsArray.getLast();
-        if (worldManager.isLoadedWorld(paramWorldName)) {
-            paramsArray.removeLast();
-            return paramWorldName;
+        String paramWorldName = paramsArray.get(paramsArray.size() - 1);
+        if (worldManager.isWorld(paramWorldName)) {
+            paramsArray.remove(paramsArray.size() - 1);
+            return Option.of(paramWorldName);
        }

        // Param not a world, fallback to player
        if (offlinePlayer instanceof Player player) {
-            return player.getWorld().getName();
+            return Option.of(player.getWorld().getName());
        }
        warning("Multiverse World not found: " + paramWorldName);
-        return null;
+        return Option.none();
    }

-    private @Nullable String getWorldPlaceHolderValue(@NotNull String placeholder,
-                                                      @NotNull List<String> placeholderParams,
-                                                      @NotNull LoadedMultiverseWorld world) {
-        // Switch to find what specific placeholder we want
-        switch (placeholder.toLowerCase(Locale.ENGLISH)) {
-            case "alias" -> {
-                return world.getAliasOrName();
-            }
-            case "animalspawn" -> {
-                return String.valueOf(world.getEntitySpawnConfig().getSpawnCategoryConfig(SpawnCategory.ANIMAL).isSpawn());
-            }
-            case "autoheal" -> {
-                return String.valueOf(world.getAutoHeal());
-            }
-            case "blacklist" -> {
-                return String.join(", ", world.getWorldBlacklist());
-            }
-            case "currency" -> {
-                return String.valueOf(world.getCurrency());
-            }
-            case "difficulty" -> {
-                return world.getDifficulty().toString();
-            }
-            case "entryfee" -> {
-                return economist.formatPrice(world.getPrice(), world.getCurrency());
-            }
-            case "environment" -> {
-                return world.getEnvironment().toString().toLowerCase();
-            }
-            case "flight" -> {
-                return String.valueOf(world.isAllowFlight());
-            }
-            case "gamemode" -> {
-                return world.getGameMode().toString().toLowerCase();
-            }
-            case "generator" -> {
-                return world.getGenerator();
-            }
-            case "hunger" -> {
-                return String.valueOf(world.isHunger());
-            }
-            case "monstersspawn" -> {
-                return String.valueOf(world.getEntitySpawnConfig().getSpawnCategoryConfig(SpawnCategory.MONSTER).isSpawn());
-            }
-            case "name" -> {
-                return world.getName();
-            }
-            case "playerlimit" -> {
-                return String.valueOf(world.getPlayerLimit());
-            }
-            case "price" -> {
-                return String.valueOf(world.getPrice());
-            }
-            case "pvp" -> {
-                return String.valueOf(world.getPvp());
-            }
-            case "seed" -> {
-                return String.valueOf(world.getSeed());
-            }
-            case "time" -> {
-                String timeFormat = !placeholderParams.isEmpty() ? placeholderParams.getFirst() : "";
-                long time = world.getBukkitWorld().map(World::getTime).getOrElse(0L);
-                switch (timeFormat) {
-                    case "" -> {
-                        return String.valueOf(time);
-                    }
-                    case "12h" -> {
-                        return MinecraftTimeFormatter.format12h(time);
-                    }
-                    case "24h" -> {
-                        return MinecraftTimeFormatter.format24h(time);
-                    }
-                    default -> {
-                        return MinecraftTimeFormatter.formatTime(time, timeFormat);
-                    }
+    private @NotNull Option<String> getWorldPlaceHolderValue(@NotNull String placeholder,
+                                                             @NotNull List<String> placeholderParams,
+                                                             @NotNull MultiverseWorld world) {
+        return Option.of(switch (placeholder) {
+            case "alias" -> world.getAliasOrName();
+            case "animalspawn" -> String.valueOf(world.getEntitySpawnConfig()
+                    .getSpawnCategoryConfig(SpawnCategory.ANIMAL)
+                    .isSpawn());
+            case "autoheal" -> String.valueOf(world.getAutoHeal());
+            case "blacklist" -> String.join(", ", world.getWorldBlacklist());
+            case "currency" -> String.valueOf(world.getCurrency());
+            case "difficulty" -> world.getDifficulty().toString();
+            case "entryfee" -> economist.formatPrice(world.getPrice(), world.getCurrency());
+            case "environment" -> world.getEnvironment().toString().toLowerCase();
+            case "flight" -> String.valueOf(world.isAllowFlight());
+            case "gamemode" -> world.getGameMode().toString().toLowerCase();
+            case "generator" -> world.getGenerator();
+            case "hunger" -> String.valueOf(world.isHunger());
+            case "isloaded" -> String.valueOf(world.isLoaded());
+            case "key" -> String.valueOf(world.getKey());
+            case "meta" -> {
+                if (placeholderParams.isEmpty()) {
+                    warning("No meta key specified.");
+                    yield null;
                }
+                String metaKey = String.join("_", placeholderParams);
+                yield world.getMeta(metaKey)
+                        .getOrElse(() -> {
+                            warning("Meta key '" + metaKey + "' not found for world '" + world.getName() + "'.");
+                            return null;
+                        });
            }
-            case "type" -> {
-                return world.getBukkitWorld().map(World::getWorldType).map(Enum::name).getOrElse("null");
-            }
-            case "weather" -> {
-                return String.valueOf(world.isAllowWeather());
+            case "monstersspawn" -> String.valueOf(world.getEntitySpawnConfig()
+                    .getSpawnCategoryConfig(SpawnCategory.MONSTER)
+                    .isSpawn());
+            case "name" -> world.getName();
+            case "playerlimit" -> String.valueOf(world.getPlayerLimit());
+            case "price" -> String.valueOf(world.getPrice());
+            case "pvp" -> String.valueOf(world.getPvp());
+            case "seed" -> String.valueOf(world.getSeed());
+            case "weather" -> String.valueOf(world.isAllowWeather());
+            case "playercount", "time", "type" -> {
+                warning("Placeholder '" + placeholder + "' is only available for loaded worlds.");
+                yield null;
            }
            default -> {
-                warning("Unknown placeholder: " + placeholder);
-                return null;
+                warning("Unknown Placeholder: " + placeholder);
+                yield null;
            }
-        }
+        });
+    }
+
+    private @NotNull Option<String> getLoadedWorldPlaceHolderValue(@NotNull String placeholder,
+                                                                   @NotNull List<String> placeholderParams,
+                                                                   @NotNull LoadedMultiverseWorld world) {
+        return Option.of(switch (placeholder) {
+            case "playercount" -> String.valueOf(world.getBukkitWorld()
+                    .map(World::getPlayers)
+                    .map(List::size)
+                    .getOrElse(-1));
+            case "time" -> {
+                String timeFormat = !placeholderParams.isEmpty() ? placeholderParams.get(0) : "";
+                long time = world.getBukkitWorld().map(World::getTime).getOrElse(0L);
+                yield switch (timeFormat) {
+                    case "" -> String.valueOf(time);
+                    case "12h" -> MinecraftTimeFormatter.format12h(time);
+                    case "24h" -> MinecraftTimeFormatter.format24h(time);
+                    default -> MinecraftTimeFormatter.formatTime(time, timeFormat);
+                };
+            }
+            case "type" -> world.getBukkitWorld().map(World::getWorldType).map(Enum::name).getOrElse("null");
+            default -> null;
+        });
    }
 }
@@ -0,0 +1,60 @@
+package org.mvplugins.multiverse.core.command;
+
+import co.aikar.commands.CommandCompletionContext;
+import co.aikar.commands.CommandCompletionFilter;
+import co.aikar.commands.apachecommonslang.ApacheCommonsLangUtil;
+import org.jetbrains.annotations.ApiStatus;
+
+import java.util.Locale;
+
+/**
+ * Utility filters for command completion matching.
+ *
+ * @since 5.7
+ */
+@ApiStatus.AvailableSince("5.7")
+public final class MVCommandCompletionFilters {
+
+    /**
+     * Matches namespaced keys (for example, {@code minecraft:stone}) using namespace-aware checks.
+     * <p>
+     * This filter accepts completions that:
+     * <ul>
+     *     <li>start with the current input,</li>
+     *     <li>have a namespace starting with the input, or</li>
+     *     <li>have a key value containing the input.</li>
+     * </ul>
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public static final CommandCompletionFilter NAMESPACED_KEY = (context, completion) -> {
+        String[] split = completion.split(":", 2);
+        if (split.length < 2) {
+            return ApacheCommonsLangUtil.startsWithIgnoreCase(completion, context.getInput());
+        }
+        String lowerCase = context.getInput().toLowerCase(Locale.ROOT);
+        return ApacheCommonsLangUtil.startsWithIgnoreCase(completion, context.getInput())
+                || split[0].toLowerCase(Locale.ROOT).startsWith(lowerCase)
+                || split[1].toLowerCase(Locale.ROOT).contains(lowerCase);
+    };
+
+    /**
+     * Gets the namespaced-key completion filter with a generic type-safe signature.
+     * Use this method instead of {@link MVCommandCompletionFilters#NAMESPACED_KEY}
+     * to avoid raw type unchecked warnings.
+     *
+     * @param <C> completion context type
+     * @return the namespaced key filter
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public static <C extends CommandCompletionContext> CommandCompletionFilter<C> namespacedKey() {
+        return NAMESPACED_KEY;
+    }
+
+    private MVCommandCompletionFilters() {
+        throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
+    }
+}
@@ -11,6 +11,7 @@ import java.util.Map;
 import java.util.stream.Collectors;

 import co.aikar.commands.BukkitCommandCompletionContext;
+import co.aikar.commands.CommandCompletionFilter;
 import co.aikar.commands.CommandIssuer;
 import co.aikar.commands.PaperCommandCompletions;
 import co.aikar.commands.RegisteredCommand;
@@ -27,6 +28,7 @@ import org.bukkit.GameRule;
 import org.bukkit.Material;
 import org.bukkit.World;
 import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.SpawnCategory;
 import org.jetbrains.annotations.NotNull;
@@ -43,16 +45,17 @@ import org.mvplugins.multiverse.core.config.handle.PropertyModifyAction;
 import org.mvplugins.multiverse.core.destination.DestinationInstance;
 import org.mvplugins.multiverse.core.destination.DestinationSuggestionPacket;
 import org.mvplugins.multiverse.core.destination.DestinationsProvider;
+import org.mvplugins.multiverse.core.destination.core.WorldDestination;
 import org.mvplugins.multiverse.core.permissions.CorePermissionsChecker;
 import org.mvplugins.multiverse.core.utils.REPatterns;
-import org.mvplugins.multiverse.core.utils.StringFormatter;
 import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
 import org.mvplugins.multiverse.core.world.MultiverseWorld;
 import org.mvplugins.multiverse.core.world.WorldManager;
 import org.mvplugins.multiverse.core.world.generators.GeneratorPlugin;
 import org.mvplugins.multiverse.core.world.generators.GeneratorProvider;
+import org.mvplugins.multiverse.core.world.helpers.PotentialWorldFinder;

-import static org.mvplugins.multiverse.core.utils.StringFormatter.addonToCommaSeperated;
+import static org.mvplugins.multiverse.core.utils.StringFormatter.addOnToCommaSeparated;

@Service
 public class MVCommandCompletions extends PaperCommandCompletions {
@@ -64,6 +67,7 @@ public class MVCommandCompletions extends PaperCommandCompletions {
    private final CorePermissionsChecker corePermissionsChecker;
    private final AnchorManager anchorManager;
    private final GeneratorProvider generatorProvider;
+    private final PotentialWorldFinder potentialWorldFinder;

    @Inject
    MVCommandCompletions(
@@ -73,7 +77,8 @@ public class MVCommandCompletions extends PaperCommandCompletions {
            @NotNull CoreConfig config,
            @NotNull CorePermissionsChecker corePermissionsChecker,
            @NotNull AnchorManager anchorManager,
-            @NotNull GeneratorProvider generatorProvider
+            @NotNull GeneratorProvider generatorProvider,
+            @NotNull PotentialWorldFinder potentialWorldFinder
    ) {
        super(mvCommandManager);
        this.commandManager = mvCommandManager;
@@ -83,27 +88,29 @@ public class MVCommandCompletions extends PaperCommandCompletions {
        this.corePermissionsChecker = corePermissionsChecker;
        this.anchorManager = anchorManager;
        this.generatorProvider = generatorProvider;
+        this.potentialWorldFinder = potentialWorldFinder;

-        registerAsyncCompletion("anchornames", this::suggestAnchorNames);
+        registerAsyncCompletion("anchornames", this::suggestAnchorNames, CommandCompletionFilter.contains());
        registerAsyncCompletion("commands", this::suggestCommands);
        registerAsyncCompletion("destinations", this::suggestDestinations);
        registerStaticCompletion("difficulties", suggestEnums(Difficulty.class));
        registerStaticCompletion("environments", List.of("normal", "nether", "the_end")); // Don't tab complete the "custom" environment
        registerAsyncCompletion("flags", this::suggestFlags);
        registerStaticCompletion("gamemodes", suggestEnums(GameMode.class));
-        registerStaticCompletion("gamerules", this::suggestGamerules);
+        registerStaticCompletion("gamerules", this::suggestGamerules, MVCommandCompletionFilters.namespacedKey());
        registerAsyncCompletion("gamerulesvalues", this::suggestGamerulesValues);
-        registerAsyncCompletion("generatorplugins", this::suggestGeneratorPlugins);
-        registerStaticCompletion("materials", suggestEnums(Material.class));
-        registerStaticCompletion("mvconfigs", config.getStringPropertyHandle().getAllPropertyNames());
+        registerAsyncCompletion("generatorplugins", this::suggestGeneratorPlugins, CommandCompletionFilter.contains());
+        registerStaticCompletion("materials", suggestEnums(Material.class), CommandCompletionFilter.contains());
+        registerStaticCompletion("mvconfigs", config.getStringPropertyHandle().getAllPropertyNames(), CommandCompletionFilter.contains());
        registerAsyncCompletion("mvconfigvalues", this::suggestMVConfigValues);
-        registerAsyncCompletion("mvworlds", this::suggestMVWorlds);
-        registerAsyncCompletion("mvworldpropsname", this::suggestMVWorldPropsName);
+        registerAsyncCompletion("mvworlds", this::suggestMVWorlds, MVCommandCompletionFilters.namespacedKey());
+        registerAsyncCompletion("mvworldmetakey", this::suggestMVWorldMetaKey, CommandCompletionFilter.contains());
+        registerAsyncCompletion("mvworldpropsname", this::suggestMVWorldPropsName, CommandCompletionFilter.contains());
        registerAsyncCompletion("mvworldpropsvalue", this::suggestMVWorldPropsValue);
-        registerAsyncCompletion("playersarray", this::suggestPlayersArray);
+        registerCompletion("playersarray", this::suggestPlayersArray, CommandCompletionFilter.contains()); // getting online players cannot be async
        registerStaticCompletion("propsmodifyaction", suggestEnums(PropertyModifyAction.class));
        registerStaticCompletion("spawncategories", suggestEnums(SpawnCategory.class));
-        registerAsyncCompletion("spawncategorypropsname", this::suggestSpawnCategoryPropsName);
+        registerAsyncCompletion("spawncategorypropsname", this::suggestSpawnCategoryPropsName, CommandCompletionFilter.contains());
        registerAsyncCompletion("spawncategorypropsvalue", this::suggestSpawnCategoryPropsValue);

        setDefaultCompletion("destinations", DestinationInstance.class);
@@ -162,7 +169,7 @@ public class MVCommandCompletions extends PaperCommandCompletions {
            }
        }
        if (context.hasConfig("multiple")) {
-            return addonToCommaSeperated(context.getInput(), handler.getCompletions(context));
+            return addOnToCommaSeparated(context.getInput(), handler.getCompletions(context));
        }
        return handler.getCompletions(context);
    }
@@ -224,18 +231,22 @@ public class MVCommandCompletions extends PaperCommandCompletions {
                        // Most likely console did not specify a player
                        return Collections.<String>emptyList();
                    }
-                    if (context.hasConfig("othersOnly") && (players.length == 1 && players[0].equals(context.getIssuer().getIssuer()))) {
+                    CommandSender sender = context.getIssuer().getIssuer();
+                    if (context.hasConfig("othersOnly") && (players.length == 1 && players[0].equals(sender))) {
                        return Collections.<String>emptyList();
                    }
-                    return suggestDestinationsWithPerms(context.getIssuer().getIssuer(), players, context.getInput());
+                    return suggestDestinationsWithPerms(sender, Arrays.asList(players), context.getInput());
                })
                .getOrElse(Collections.emptyList());
    }

-    private Collection<String> suggestDestinationsWithPerms(CommandSender teleporter, Player[] players, String deststring) {
+    private Collection<String> suggestDestinationsWithPerms(CommandSender teleporter, List<Entity> teleportees, String deststring) {
        return destinationsProvider.suggestDestinations(teleporter, deststring).stream()
+                .filter(packet -> !config.getSimplifiedDestinationTabCompletion()
+                        || packet.destination() instanceof WorldDestination
+                        || deststring.startsWith(packet.destination().getIdentifier() + ":"))
                .filter(packet -> corePermissionsChecker
-                        .checkDestinationPacketPermission(teleporter, Arrays.asList(players), packet))
+                        .checkDestinationPacketPermission(teleporter, teleportees, packet))
                .map(DestinationSuggestionPacket::parsableString)
                .toList();
    }
@@ -279,29 +290,33 @@ public class MVCommandCompletions extends PaperCommandCompletions {
            case "both" -> {
                return worldManager.getWorlds().stream()
                        .map(MultiverseWorld::getTabCompleteName)
-                        .map(StringFormatter::quoteMultiWordString)
                        .toList();
            }
            case "loaded" -> {
                return worldManager.getLoadedWorlds().stream()
                        .map(MultiverseWorld::getTabCompleteName)
-                        .map(StringFormatter::quoteMultiWordString)
                        .toList();
            }
            case "unloaded" -> {
                return worldManager.getUnloadedWorlds().stream()
                        .map(MultiverseWorld::getTabCompleteName)
-                        .map(StringFormatter::quoteMultiWordString)
                        .toList();
            }
            case "potential" -> {
-                return worldManager.getPotentialWorlds();
+                return potentialWorldFinder.findPotentialWorlds();
            }
        }
        Logging.severe("Invalid MVWorld scope: " + scope);
        return Collections.emptyList();
    }

+    private Collection<String> suggestMVWorldMetaKey(BukkitCommandCompletionContext context) {
+        return Try.of(() -> context.getContextValue(MultiverseWorld.class))
+                .map(MultiverseWorld::getAllMeta)
+                .map(Map::keySet)
+                .getOrElse(Collections.emptySet());
+    }
+
    private Collection<String> suggestMVWorldPropsName(BukkitCommandCompletionContext context) {
        return Try.of(() -> {
            MultiverseWorld world = context.getContextValue(MultiverseWorldValue.class).value();
@@ -332,7 +347,7 @@ public class MVCommandCompletions extends PaperCommandCompletions {
                matchedPlayers.add(name);
            }
        }
-        return addonToCommaSeperated(context.getInput(), matchedPlayers);
+        return addOnToCommaSeparated(context.getInput(), matchedPlayers);
    }

    private Collection<String> suggestSpawnCategoryPropsName(BukkitCommandCompletionContext context) {
@@ -11,6 +11,7 @@ import co.aikar.commands.MinecraftMessageKeys;
 import co.aikar.commands.PaperCommandContexts;
 import co.aikar.commands.contexts.ContextResolver;
 import com.google.common.base.Strings;
+import io.vavr.control.Option;
 import io.vavr.control.Try;
 import jakarta.inject.Inject;
 import org.bukkit.Bukkit;
@@ -38,9 +39,12 @@ import org.mvplugins.multiverse.core.display.filters.ContentFilter;
 import org.mvplugins.multiverse.core.display.filters.DefaultContentFilter;
 import org.mvplugins.multiverse.core.display.filters.RegexContentFilter;
 import org.mvplugins.multiverse.core.exceptions.command.MVInvalidCommandArgument;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.locale.message.Message;
+import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
 import org.mvplugins.multiverse.core.utils.PlayerFinder;
 import org.mvplugins.multiverse.core.utils.REPatterns;
+import org.mvplugins.multiverse.core.utils.tick.TickDuration;
 import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
 import org.mvplugins.multiverse.core.world.MultiverseWorld;
 import org.mvplugins.multiverse.core.world.WorldManager;
@@ -92,6 +96,7 @@ public class MVCommandContexts extends PaperCommandContexts {
        registerIssuerAwareContext(PlayerArrayValue.class, playerArrayContextBuilder().generateContext(PlayerArrayValue::new));
        registerIssuerAwareContext(PlayerLocation.class, this::parsePlayerLocation);
        registerContext(SpawnCategory[].class, this::parseSpawnCategories);
+        registerContext(TickDuration.class, this::parseTickDuration);
    }

    private MVCommandIssuer parseMVCommandIssuer(BukkitCommandExecutionContext context) {
@@ -165,15 +170,67 @@ public class MVCommandContexts extends PaperCommandContexts {
        return generatorPlugin;
    }

+    private Message loadedMultiverseWorldPlayerOnlyMessage() {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_LOADEDMULTIVERSEWORLD_PLAYERSONLY);
+    }
+
+    private Message loadedMultiverseWorldIssuerMessage() {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_LOADEDMULTIVERSEWORLD_ISSUER);
+    }
+
+    private Message loadedMultiverseWorldInputConsoleMessage(String worldName) {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_LOADEDMULTIVERSEWORLD_INPUTCONSOLE,
+                Replace.WORLD.with(worldName));
+    }
+
+    private Message loadedMultiverseWorldInputMessage(String worldName) {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_LOADEDMULTIVERSEWORLD_INPUT, Replace.WORLD.with(worldName));
+    }
+
+    private Message multiverseWorldPlayerOnlyMessage() {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_MULTIVERSEWORLD_PLAYERSONLY);
+    }
+
+    private Message multiverseWorldIssuerMessage() {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_MULTIVERSEWORLD_ISSUER);
+    }
+
+    private Message multiverseWorldInputConsoleMessage(String worldName) {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_MULTIVERSEWORLD_INPUTCONSOLE, Replace.WORLD.with(worldName));
+    }
+
+    private Message multiverseWorldInputMessage(String worldName) {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_MULTIVERSEWORLD_INPUT, Replace.WORLD.with(worldName));
+    }
+
+    private Message playerOnlyMessage() {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_PLAYERSONLY);
+    }
+
+    private Message playerInputIssuerMessage(String playerName) {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_PLAYER_ISSUERINPUT, Replace.PLAYER.with(playerName));
+    }
+
+    private Message playerInputMessage(String playerName) {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_PLAYER_INPUT, Replace.PLAYER.with(playerName));
+    }
+
+    private Message playerSelectorMessage(String selector) {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_PLAYER_SELECTOR, Replace.PLAYER.with(selector));
+    }
+
+    private Message playersInputMessage(String playerName) {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_PLAYERS_INPUT, Replace.PLAYER.with(playerName));
+    }

    private IssuerAwareContextBuilder<LoadedMultiverseWorld> loadedMultiverseWorldContextBuilder() {
        return new IssuerAwareContextBuilder<LoadedMultiverseWorld>()
                .fromPlayer((context, player) -> worldManager.getLoadedWorld(player.getWorld()).getOrNull())
                .fromInput((context, input) -> getLoadedMultiverseWorld(input))
-                .issuerOnlyFailMessage((context) -> Message.of("This command can only be used by a player in a loaded Multiverse World."))
-                .issuerAwarePlayerFailMessage((context, player) -> Message.of("You are not in a loaded multiverse world. Either specify a multiverse world name or use this command in a loaded multiverse world."))
-                .issuerAwareInputFailMessage((context, input) -> Message.of("World '" + input + "' is not a loaded multiverse world. Remember to specify the world name when using this command in console."))
-                .inputOnlyFailMessage((context, input) -> Message.of("World " + input + " is not a loaded multiverse world."));
+                .issuerOnlyFailMessage((context) -> loadedMultiverseWorldPlayerOnlyMessage())
+                .issuerAwarePlayerFailMessage((context, player) -> loadedMultiverseWorldIssuerMessage())
+                .issuerAwareInputFailMessage((context, input) -> loadedMultiverseWorldInputConsoleMessage(input))
+                .inputOnlyFailMessage((context, input) -> loadedMultiverseWorldInputMessage(input));
    }

    private IssuerAwareContextBuilder<LoadedMultiverseWorld[]> loadedMultiverseWorldArrayContextBuilder() {
@@ -191,16 +248,17 @@ public class MVCommandContexts extends PaperCommandContexts {
                        }
                        LoadedMultiverseWorld world = getLoadedMultiverseWorld(worldName);
                        if (world == null) {
-                            throw new InvalidCommandArgument("World " + worldName + " is not a loaded multiverse world.");
+                            throw new InvalidCommandArgument(
+                                    loadedMultiverseWorldInputMessage(worldName).formatted(context.getIssuer()));
                        }
                        worlds.add(world);
                    }
                    return worlds.isEmpty() ? null : worlds.toArray(new LoadedMultiverseWorld[0]);
                })
-                .issuerOnlyFailMessage((context) -> Message.of("This command can only be used by a player in a loaded Multiverse World."))
-                .issuerAwarePlayerFailMessage((context, player) -> Message.of("You are not in a loaded multiverse world. Either specify a multiverse world name or use this command in a loaded multiverse world."))
-                .issuerAwareInputFailMessage((context, input) -> Message.of("World '" + input + "' is not a loaded multiverse world. Remember to specify the world name when using this command in console."))
-                .inputOnlyFailMessage((context, input) -> Message.of("World " + input + " is not a loaded multiverse world."));
+                .issuerOnlyFailMessage((context) -> loadedMultiverseWorldPlayerOnlyMessage())
+                .issuerAwarePlayerFailMessage((context, player) -> loadedMultiverseWorldIssuerMessage())
+                .issuerAwareInputFailMessage((context, input) -> loadedMultiverseWorldInputConsoleMessage(input))
+                .inputOnlyFailMessage((context, input) -> loadedMultiverseWorldInputMessage(input));
    }

    @Nullable
@@ -214,10 +272,10 @@ public class MVCommandContexts extends PaperCommandContexts {
        return new IssuerAwareContextBuilder<MultiverseWorld>()
                .fromPlayer((context, player) -> worldManager.getWorld(player.getWorld()).getOrNull())
                .fromInput((context, input) -> getMultiverseWorld(input))
-                .issuerOnlyFailMessage((context) -> Message.of("This command can only be used by a player in a Multiverse World."))
-                .issuerAwarePlayerFailMessage((context, player) -> Message.of("You are not in a multiverse world. Either specify a multiverse world name or use this command in a multiverse world."))
-                .issuerAwareInputFailMessage((context, input) -> Message.of("World '" + input + "' is not a multiverse world. Remember to specify the world name when using this command in console."))
-                .inputOnlyFailMessage((context, input) -> Message.of("World " + input + " is not a multiverse world."));
+                .issuerOnlyFailMessage((context) -> multiverseWorldPlayerOnlyMessage())
+                .issuerAwarePlayerFailMessage((context, player) -> multiverseWorldIssuerMessage())
+                .issuerAwareInputFailMessage((context, input) -> multiverseWorldInputConsoleMessage(input))
+                .inputOnlyFailMessage((context, input) -> multiverseWorldInputMessage(input));
    }

    private IssuerAwareContextBuilder<MultiverseWorld[]> multiverseWorldArrayContextBuilder() {
@@ -235,16 +293,17 @@ public class MVCommandContexts extends PaperCommandContexts {
                        }
                        MultiverseWorld world = getMultiverseWorld(worldName);
                        if (world == null) {
-                            throw new InvalidCommandArgument("World " + worldName + " is not a multiverse world.");
+                            throw new InvalidCommandArgument(
+                                    multiverseWorldInputMessage(worldName).formatted(context.getIssuer()));
                        }
                        worlds.add(world);
                    }
                    return worlds.isEmpty() ? null : worlds.toArray(new MultiverseWorld[0]);
                })
-                .issuerOnlyFailMessage((context) -> Message.of("This command can only be used by a player in a Multiverse World."))
-                .issuerAwarePlayerFailMessage((context, player) -> Message.of("You are not in a multiverse world. Either specify a multiverse world name or use this command in a multiverse world."))
-                .issuerAwareInputFailMessage((context, input) -> Message.of("World '" + input + "' is not a multiverse world. Remember to specify the world name when using this command in console."))
-                .inputOnlyFailMessage((context, input) -> Message.of("World " + input + " is not a multiverse world."));
+                .issuerOnlyFailMessage((context) -> multiverseWorldPlayerOnlyMessage())
+                .issuerAwarePlayerFailMessage((context, player) -> multiverseWorldIssuerMessage())
+                .issuerAwareInputFailMessage((context, input) -> multiverseWorldInputConsoleMessage(input))
+                .inputOnlyFailMessage((context, input) -> multiverseWorldInputMessage(input));
    }

    @Nullable
@@ -264,21 +323,33 @@ public class MVCommandContexts extends PaperCommandContexts {
        return new IssuerAwareContextBuilder<Player>()
                .fromPlayer((context, player) -> player)
                .fromInput((context, input) -> PlayerFinder.get(input, context.getSender()))
-                .issuerOnlyFailMessage((context) -> Message.of("This command can only be used by a player."))
-                .issuerAwareInputFailMessage((context, input) -> Message.of("Invalid player: " + input + ". Either specify an online player or use this command as a player."))
-                .inputOnlyFailMessage((context, input) -> Message.of("Player " + input + " not found."));
+                .issuerOnlyFailMessage((context) -> playerOnlyMessage())
+                .issuerAwareInputFailMessage((context, input) -> playerInputIssuerMessage(input))
+                .inputOnlyFailMessage((context, input) -> playerInputMessage(input));
    }

    private IssuerAwareContextBuilder<Player[]> playerArrayContextBuilder() {
        return new IssuerAwareContextBuilder<Player[]>()
                .fromPlayer((context, player) -> new Player[]{player})
-                .fromInput((context, input) -> {
-                    Player[] players = PlayerFinder.getMulti(input, context.getSender()).toArray(new Player[0]);
-                    return (players.length == 0) ? null : players;
-                })
-                .issuerOnlyFailMessage((context) -> Message.of("This command can only be used by a player."))
-                .issuerAwareInputFailMessage((context, input) -> Message.of("Invalid player: " + input + ". Either specify an online player or use this command as a player."))
-                .inputOnlyFailMessage((context, input) -> Message.of("Player " + input + " not found."));
+                .fromInput((context, input) -> PlayerFinder
+                        .tryGetMulti(input, context.getSender())
+                        .map(list -> list.toArray(new Player[0]))
+                        .map(arr -> (arr.length == 0) ? null : arr)
+                        .getOrElseThrow(failure -> {
+                            if (failure instanceof MVInvalidCommandArgument mvFailure) {
+                                throw mvFailure;
+                            }
+                            throw new InvalidCommandArgument(failure.getLocalizedMessage() + " "
+                                    + Option.of(failure.getCause()).map(Throwable::getLocalizedMessage).getOrElse(""));
+                        }))
+                .issuerOnlyFailMessage((context) -> playerOnlyMessage())
+                .issuerAwareInputFailMessage((context, input) -> playerInputIssuerMessage(input))
+                .inputOnlyFailMessage((context, input) -> {
+                    if (PlayerFinder.isSelector(input)) {
+                        return playerSelectorMessage(input);
+                    }
+                    return playersInputMessage(input);
+                });
    }

    private PlayerLocation parsePlayerLocation(BukkitCommandExecutionContext context) {
@@ -380,4 +451,13 @@ public class MVCommandContexts extends PaperCommandContexts {
        }
        return categories.toArray(new SpawnCategory[0]);
    }
+
+    private TickDuration parseTickDuration(BukkitCommandExecutionContext context) {
+        String arg = context.popFirstArg();
+        return TickDuration.parseString(arg)
+                .getOrElseThrow(failure ->
+                        new InvalidCommandArgument("Invalid time duration format: \"" +arg + "\". Use a number " +
+                                "followed by an optional suffix (s for seconds, d for game days) or just a number " +
+                                "for ticks. Examples: 100, 5s, 2d"));
+    }
 }
@@ -112,9 +112,9 @@ public class MVCommandIssuer extends BukkitCommandIssuer {
        } else {
            var formatter = getManager().getFormat(messageType);
            if (formatter != null) {
-                sendMessage(formatter.format(message.formatted()));
+                sendMessage(formatter.format(message.formatted(getManager().getLocales(), this)));
            } else {
-                sendMessage(message.formatted());
+                sendMessage(message.formatted(getManager().getLocales(), this));
            }
        }
    }
@@ -12,6 +12,8 @@ import co.aikar.commands.LogLevel;
 import co.aikar.commands.PaperCommandManager;
 import co.aikar.commands.RootCommand;
 import com.dumptruckman.minecraft.util.Logging;
+import jakarta.annotation.PostConstruct;
+import jakarta.annotation.PreDestroy;
 import jakarta.inject.Inject;
 import jakarta.inject.Provider;
 import org.bukkit.Bukkit;
@@ -24,6 +26,7 @@ import org.mvplugins.multiverse.core.command.flag.CommandFlagsManager;
 import org.mvplugins.multiverse.core.command.queue.CommandQueueManager;
 import org.mvplugins.multiverse.core.config.CoreConfig;
 import org.mvplugins.multiverse.core.locale.PluginLocales;
+import org.mvplugins.multiverse.core.locale.message.LocalizedMessage;
 import org.mvplugins.multiverse.core.world.WorldManager;
 import org.mvplugins.multiverse.core.world.helpers.WorldNameChecker;

@@ -62,13 +65,22 @@ public class MVCommandManager extends PaperCommandManager {
        this.config = config;
        this.pluginLocales = new PluginLocales(this);
        this.locales = this.pluginLocales;
-        this.pluginLocales.loadLanguages();

        MVCommandConditions.load(this, worldManager, worldNameChecker);
        this.enableUnstableAPI("help");
        this.setDefaultExceptionHandler(new MVDefaultExceptionHandler());
    }

+    @PostConstruct
+    private void postConstruct() {
+        LocalizedMessage.setDefaultLocalesManager(getLocales());
+    }
+
+    @PreDestroy
+    private void preDestroy() {
+        LocalizedMessage.setDefaultLocalesManager(null);
+    }
+
    /**
     * Registers a list of commands and handles {@link LegacyAliasCommand} based on config option.
     * @param commands  The commands to register
@@ -22,6 +22,9 @@ public class MVRootCommand extends BukkitRootCommand {
    @Override
    public List<String> getTabCompletions(CommandIssuer sender, String alias, String[] args, boolean commandsOnly, boolean isAsync) {
        String[] quoteFormatedArgs = StringFormatter.parseQuotesInArgs(args).toArray(String[]::new);
-        return super.getTabCompletions(sender, alias, quoteFormatedArgs, commandsOnly, isAsync);
+        return super.getTabCompletions(sender, alias, quoteFormatedArgs, commandsOnly, isAsync)
+                .stream()
+                .map(StringFormatter::quoteMultiWordString)
+                .toList();
    }
 }
@@ -6,12 +6,16 @@ import co.aikar.commands.InvalidCommandArgument;
 import co.aikar.commands.contexts.IssuerAwareContextResolver;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.ApiStatus;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.locale.message.Message;
+import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;

 import java.util.Objects;
 import java.util.function.BiFunction;
 import java.util.function.Function;

+import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.replace;
+
 /**
 * Reusable logic of issuer only and issuer aware context resolvers
 *
@@ -22,10 +26,17 @@ public final class IssuerAwareContextBuilder<T> {

    private BiFunction<BukkitCommandExecutionContext, Player, T> fromPlayer;
    private BiFunction<BukkitCommandExecutionContext, String, T> fromInput;
-    private Function<BukkitCommandExecutionContext, Message> issuerOnlyFailMessage = context -> Message.of("This command can only be used by a player.");
-    private BiFunction<BukkitCommandExecutionContext, Player, Message> issuerAwarePlayerFailMessage = (context, player) -> Message.of("Unable to resolve context for player '" + player.getName() + "'.");
-    private BiFunction<BukkitCommandExecutionContext, String, Message> issuerAwareInputFailMessage = (context, input) -> Message.of("Unable to resolve context for input '" + input + "'.");
-    private BiFunction<BukkitCommandExecutionContext, String, Message> inputOnlyFailMessage = (context, input) -> Message.of("Unable to resolve context for input '" + input + "'.");
+    private Function<BukkitCommandExecutionContext, Message> issuerOnlyFailMessage =
+            context -> Message.of(MVCorei18n.COMMANDS_ERROR_PLAYERSONLY);
+    private BiFunction<BukkitCommandExecutionContext, Player, Message> issuerAwarePlayerFailMessage =
+            (context, player) -> Message.of(MVCorei18n.COMMANDS_ERROR_RESOLVE_PLAYER,
+                    Replace.PLAYER.with(player.getName()));
+    private BiFunction<BukkitCommandExecutionContext, String, Message> issuerAwareInputFailMessage =
+            (context, input) -> Message.of(MVCorei18n.COMMANDS_ERROR_RESOLVE_INPUT,
+                    replace("{input}").with(input));
+    private BiFunction<BukkitCommandExecutionContext, String, Message> inputOnlyFailMessage =
+            (context, input) -> Message.of(MVCorei18n.COMMANDS_ERROR_RESOLVE_INPUT,
+                    replace("{input}").with(input));

    public IssuerAwareContextBuilder() {
    }
@@ -123,48 +134,8 @@ public final class IssuerAwareContextBuilder<T> {
     */
    @ApiStatus.AvailableSince("5.1")
    public IssuerAwareContextResolver<T, BukkitCommandExecutionContext> generateContext() {
-        Objects.requireNonNull(fromPlayer);
-        Objects.requireNonNull(fromInput);
-        Objects.requireNonNull(issuerOnlyFailMessage);
-        Objects.requireNonNull(issuerAwarePlayerFailMessage);
-        Objects.requireNonNull(issuerAwareInputFailMessage);
-        Objects.requireNonNull(inputOnlyFailMessage);
-
-        return context -> {
-            BukkitCommandIssuer issuer = context.getIssuer();
-            String resolve = context.getFlagValue("resolve", "");
-
-            if (resolve.equals("issuerOnly")) {
-                if (issuer.isPlayer()) {
-                    T result = fromPlayer.apply(context, issuer.getPlayer());
-                    if (result != null) {
-                        return result;
-                    }
-                }
-                throw new InvalidCommandArgument(issuerOnlyFailMessage.apply(context).formatted(issuer));
-            }
-
-            String input = context.getFirstArg();
-            T result = fromInput.apply(context, input);
-            if (result != null) {
-                context.popFirstArg();
-                return result;
-            }
-
-            if (resolve.equals("issuerAware")) {
-                if (issuer.isPlayer()) {
-                    Player player = issuer.getPlayer();
-                    result = fromPlayer.apply(context, player);
-                    if (result != null) {
-                        return result;
-                    }
-                    throw new InvalidCommandArgument(issuerAwarePlayerFailMessage.apply(context, player).formatted(issuer));
-                }
-                throw new InvalidCommandArgument(issuerAwareInputFailMessage.apply(context, input).formatted(issuer));
-            }
-
-            throw new InvalidCommandArgument(inputOnlyFailMessage.apply(context, input).formatted(issuer));
-        };
+        validateRequiredVariables();
+        return context -> resolveValue(context, GenericIssuerAwareValue::new).value;
    }

    /**
@@ -178,49 +149,66 @@ public final class IssuerAwareContextBuilder<T> {
     */
    @ApiStatus.AvailableSince("5.1")
    public <I extends IssuerAwareValue> IssuerAwareContextResolver<I, BukkitCommandExecutionContext> generateContext(BiFunction<Boolean, T, I> createValue) {
-        // todo: This is a copy and paste from above
+        validateRequiredVariables();
+        return context -> resolveValue(context, createValue);
+    }

+    private void validateRequiredVariables() {
        Objects.requireNonNull(fromPlayer);
        Objects.requireNonNull(fromInput);
        Objects.requireNonNull(issuerOnlyFailMessage);
        Objects.requireNonNull(issuerAwarePlayerFailMessage);
        Objects.requireNonNull(issuerAwareInputFailMessage);
        Objects.requireNonNull(inputOnlyFailMessage);
+    }

-        return context -> {
-            BukkitCommandIssuer issuer = context.getIssuer();
-            String resolve = context.getFlagValue("resolve", "");
+    private <I extends IssuerAwareValue> I resolveValue(BukkitCommandExecutionContext context, BiFunction<Boolean, T, I> createValue) {
+        BukkitCommandIssuer issuer = context.getIssuer();
+        String resolve = context.getFlagValue("resolve", "");

-            if (resolve.equals("issuerOnly")) {
-                if (issuer.isPlayer()) {
-                    T result = fromPlayer.apply(context, issuer.getPlayer());
-                    if (result != null) {
-                        return createValue.apply(true, result);
-                    }
+        if (resolve.equals("issuerOnly")) {
+            if (issuer.isPlayer()) {
+                T result = fromPlayer.apply(context, issuer.getPlayer());
+                if (result != null) {
+                    return createValue.apply(true, result);
                }
-                throw new InvalidCommandArgument(issuerOnlyFailMessage.apply(context).formatted(issuer));
            }
+            throw new InvalidCommandArgument(issuerOnlyFailMessage.apply(context).formatted(issuer));
+        }

-            String input = context.getFirstArg();
-            T result = fromInput.apply(context, input);
-            if (result != null) {
-                context.popFirstArg();
-                return createValue.apply(false, result);
-            }
+        String input = context.getFirstArg();
+        T result = fromInput.apply(context, input);
+        if (result != null) {
+            context.popFirstArg();
+            return createValue.apply(false, result);
+        }

-            if (resolve.equals("issuerAware")) {
-                if (issuer.isPlayer()) {
-                    Player player = issuer.getPlayer();
-                    result = fromPlayer.apply(context, player);
-                    if (result != null) {
-                        return createValue.apply(true, result);
-                    }
-                    throw new InvalidCommandArgument(issuerAwarePlayerFailMessage.apply(context, player).formatted(issuer));
+        int maxArgForAware = context.getFlagValue("maxArgForAware", Integer.MAX_VALUE);
+        long argLengthWithoutFlags = context.getArgs().stream()
+                .takeWhile(value -> !value.startsWith("-") && !value.isEmpty()) // ignore the flags
+                .count();
+
+        if (resolve.equals("issuerAware") && argLengthWithoutFlags <= maxArgForAware) {
+            if (issuer.isPlayer()) {
+                Player player = issuer.getPlayer();
+                result = fromPlayer.apply(context, player);
+                if (result != null) {
+                    return createValue.apply(true, result);
                }
-                throw new InvalidCommandArgument(issuerAwareInputFailMessage.apply(context, input).formatted(issuer));
+                throw new InvalidCommandArgument(issuerAwarePlayerFailMessage.apply(context, player).formatted(issuer));
            }
+            throw new InvalidCommandArgument(issuerAwareInputFailMessage.apply(context, input).formatted(issuer));
+        }

-            throw new InvalidCommandArgument(inputOnlyFailMessage.apply(context, input).formatted(issuer));
-        };
+        throw new InvalidCommandArgument(inputOnlyFailMessage.apply(context, input).formatted(issuer));
+    }
+
+    private static class GenericIssuerAwareValue<T> extends IssuerAwareValue {
+        private final T value;
+
+        public GenericIssuerAwareValue(boolean byIssuer, T value) {
+            super(byIssuer);
+            this.value = value;
+        }
    }
 }
@@ -5,8 +5,10 @@ import java.util.Collection;
 import java.util.List;
 import java.util.Locale;
 import java.util.function.Function;
+import java.util.function.Supplier;

 import co.aikar.commands.InvalidCommandArgument;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

@@ -40,34 +42,34 @@ public class CommandValueFlag<T> extends CommandFlag {

    private final Class<T> type;
    private final boolean optional;
-    private final T defaultValue;
+    private final Supplier<? extends T> defaultValueSupplier;
    private final Function<String, T> context;
    private final Function<String, Collection<String>>  completion;

    /**
     * Creates a new flag.
     *
-     * @param key               The key for the new flag.
-     * @param aliases           The aliases that also refer to this flag.
-     * @param type              The type of the value.
-     * @param optional          Allow for flag without value.
-     * @param defaultValue      The default value if optional is true and user does not specify a value.
-     * @param context           Function to parse string into value type.
-     * @param completion        Function to get completion for this flag.
+     * @param key                   The key for the new flag.
+     * @param aliases               The aliases that also refer to this flag.
+     * @param type                  The type of the value.
+     * @param optional              Allow for flag without value.
+     * @param defaultValueSupplier  The default value if optional is true and user does not specify a value.
+     * @param context               Function to parse string into value type.
+     * @param completion            Function to get completion for this flag.
     */
    protected CommandValueFlag(
            @NotNull String key,
            @NotNull List<String> aliases,
            @NotNull Class<T> type,
            boolean optional,
-            @Nullable T defaultValue,
+            @Nullable Supplier<? extends T> defaultValueSupplier,
            @Nullable Function<String, T> context,
            @Nullable Function<String, Collection<String>>  completion
    ) {
        super(key, aliases);
        this.type = type;
        this.optional = optional;
-        this.defaultValue = defaultValue;
+        this.defaultValueSupplier = defaultValueSupplier;
        this.context = context;
        this.completion = completion;
    }
@@ -96,7 +98,7 @@ public class CommandValueFlag<T> extends CommandFlag {
     * @return The default value.
     */
    public @Nullable T getDefaultValue() {
-        return defaultValue;
+        return defaultValueSupplier == null ? null : defaultValueSupplier.get();
    }

    /**
@@ -126,7 +128,7 @@ public class CommandValueFlag<T> extends CommandFlag {
    public static class Builder<T, S extends Builder<T, S>> extends CommandFlag.Builder<S> {
        protected final Class<T> type;
        protected boolean optional = false;
-        protected T defaultValue = null;
+        protected Supplier<? extends T> defaultValueSupplier = null;
        protected Function<String, T> context = null;
        protected Function<String, Collection<String>> completion = null;

@@ -158,7 +160,21 @@ public class CommandValueFlag<T> extends CommandFlag {
         * @return The builder.
         */
        public @NotNull S defaultValue(@NotNull T defaultValue) {
-            this.defaultValue = defaultValue;
+            return defaultValue(() -> defaultValue);
+        }
+
+        /**
+         * Set the default value supplier. Used if optional is true and user does not specify a value.
+         * Supplier is only called when command is executed with the flag is present in input.
+         *
+         * @param defaultValueSupplier The default value supplier
+         * @return The builder
+         *
+         * @since 5.7
+         */
+        @ApiStatus.AvailableSince("5.7")
+        public @NotNull S defaultValue(@NotNull Supplier<? extends T> defaultValueSupplier) {
+            this.defaultValueSupplier = defaultValueSupplier;
            return (S) this;
        }

@@ -194,7 +210,7 @@ public class CommandValueFlag<T> extends CommandFlag {
            if (context == null && !String.class.equals(type)) {
                throw new IllegalStateException("Context is required for non-string value flags");
            }
-            return new CommandValueFlag<>(key, aliases, type, optional, defaultValue, context, completion);
+            return new CommandValueFlag<>(key, aliases, type, optional, defaultValueSupplier, context, completion);
        }
    }

@@ -207,7 +223,7 @@ public class CommandValueFlag<T> extends CommandFlag {
    public static class EnumBuilder<T extends Enum<T>, S extends EnumBuilder<T, S>> extends CommandFlag.Builder<S> {
        protected final Class<T> type;
        protected boolean optional = false;
-        protected T defaultValue = null;
+        protected Supplier<? extends T> defaultValueSupplier = null;
        protected Function<String, T> context = null;
        protected Function<String, Collection<String>>  completion = null;

@@ -253,7 +269,21 @@ public class CommandValueFlag<T> extends CommandFlag {
         * @return The builder.
         */
        public @NotNull S defaultValue(@NotNull T defaultValue) {
-            this.defaultValue = defaultValue;
+            return defaultValue(() -> defaultValue);
+        }
+
+        /**
+         * Set the default value to supply. Used if optional is true and user does not specify a value.
+         * Supplier is only called when command is executed with the flag is present in input.
+         *
+         * @param defaultValueSupplier The default value supplier.
+         * @return The builder.
+         *
+         * @since 5.7
+         */
+        @ApiStatus.AvailableSince("5.7")
+        public @NotNull S defaultValue(@NotNull Supplier<? extends T> defaultValueSupplier) {
+            this.defaultValueSupplier = defaultValueSupplier;
            return (S) this;
        }

@@ -264,7 +294,7 @@ public class CommandValueFlag<T> extends CommandFlag {
         */
        @Override
        public @NotNull CommandValueFlag<T> build() {
-            return new CommandValueFlag<>(key, aliases, type, optional, defaultValue, context, completion);
+            return new CommandValueFlag<>(key, aliases, type, optional, defaultValueSupplier, context, completion);
        }
    }
 }
@@ -0,0 +1,67 @@
+package org.mvplugins.multiverse.core.command.flags;
+
+import jakarta.inject.Inject;
+import org.bukkit.Bukkit;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jvnet.hk2.annotations.Service;
+import org.mvplugins.multiverse.core.command.flag.CommandFlagsManager;
+import org.mvplugins.multiverse.core.command.flag.CommandValueFlag;
+import org.mvplugins.multiverse.core.command.flag.FlagBuilder;
+import org.mvplugins.multiverse.core.destination.DestinationInstance;
+import org.mvplugins.multiverse.core.destination.DestinationsProvider;
+import org.mvplugins.multiverse.core.destination.core.WorldDestination;
+import org.mvplugins.multiverse.core.exceptions.command.MVInvalidCommandArgument;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
+import org.mvplugins.multiverse.core.locale.message.Message;
+import org.mvplugins.multiverse.core.world.WorldManager;
+
+@ApiStatus.AvailableSince("5.7")
+@Service
+public class RemovePlayerDestinationFlags extends FlagBuilder {
+
+    public static final String NAME = "removeplayer";
+
+    private WorldManager worldManager;
+    private DestinationsProvider destinationsProvider;
+    private WorldDestination worldDestination;
+
+    protected RemovePlayerDestinationFlags(
+            @NotNull String name,
+            @NotNull CommandFlagsManager flagsManager,
+            @NotNull WorldManager worldManager,
+            @NotNull DestinationsProvider destinationsProvider,
+            @NotNull WorldDestination worldDestination
+    ) {
+        super(name, flagsManager);
+        this.worldManager = worldManager;
+        this.destinationsProvider = destinationsProvider;
+        this.worldDestination = worldDestination;
+    }
+
+    @Inject
+    private RemovePlayerDestinationFlags(
+            @NotNull CommandFlagsManager flagsManager,
+            @NotNull WorldManager worldManager,
+            @NotNull DestinationsProvider destinationsProvider,
+            @NotNull WorldDestination worldDestination
+    ) {
+        super(NAME, flagsManager);
+        this.destinationsProvider = destinationsProvider;
+        this.worldManager = worldManager;
+        this.worldDestination = worldDestination;
+    }
+
+    public final CommandValueFlag<DestinationInstance> removePlayers = flag(CommandValueFlag.builder("--remove-players", DestinationInstance.class)
+            .addAlias("-r")
+            .defaultValue(() -> worldManager.getDefaultWorld()
+                    .map(defaultWorld -> worldDestination.fromWorld(defaultWorld))
+                    .getOrElseThrow(() -> MVInvalidCommandArgument.of(
+                            Message.of(MVCorei18n.COMMANDS_ERROR_REMOVEPLAYERS_NODEFAULT))))
+            .completion(input -> destinationsProvider.suggestDestinationStrings(Bukkit.getConsoleSender(), input))
+            .context(input -> destinationsProvider.parseDestination(input)
+                    .getOrThrow(failure ->
+                            MVInvalidCommandArgument.of(failure.getFailureMessage())))
+            .optional()
+            .build());
+}
@@ -1,12 +1,19 @@
 package org.mvplugins.multiverse.core.command.flags;

 import jakarta.inject.Inject;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jvnet.hk2.annotations.Service;
 import org.mvplugins.multiverse.core.command.flag.CommandFlag;
 import org.mvplugins.multiverse.core.command.flag.CommandFlagsManager;
 import org.mvplugins.multiverse.core.command.flag.FlagBuilder;

+/**
+ * @deprecated The --remove-players flag is being removed in favor of a more flexible system that allows for specifying
+ * a destination for players to be teleported to when a world is unloaded. See {@link RemovePlayerDestinationFlags}.
+ */
+@Deprecated(forRemoval = true, since = "5.7")
+@ApiStatus.ScheduledForRemoval(inVersion = "6.0")
@Service
 public class RemovePlayerFlags extends FlagBuilder {

@@ -15,7 +15,6 @@ import com.dumptruckman.minecraft.util.Logging;
 import io.vavr.control.Option;
 import jakarta.inject.Inject;
 import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
 import org.bukkit.block.data.type.CommandBlock;
 import org.bukkit.command.BlockCommandSender;
 import org.bukkit.command.CommandSender;
@@ -28,6 +27,7 @@ import org.jvnet.hk2.annotations.Service;
 import org.mvplugins.multiverse.core.MultiverseCore;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
 import org.mvplugins.multiverse.core.config.CoreConfig;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.utils.result.Attempt;

 import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.*;
@@ -79,8 +79,9 @@ public class CommandQueueManager {
        if (config.getUseConfirmOtp()) {
            confirmCommand += " " + payload.otp();
        }
-        payload.issuer().sendMessage(String.format("Run %s%s %sto continue. This will expire in %s seconds.",
-                ChatColor.GREEN, confirmCommand, ChatColor.WHITE, config.getConfirmTimeout()));
+        payload.issuer().sendMessage(MVCorei18n.QUEUECOMMAND_PROMPT,
+                replace("{command}").with(confirmCommand),
+                replace("{timeout}").with(config.getConfirmTimeout()));
    }

    /**
@@ -127,7 +128,7 @@ public class CommandQueueManager {
                // Payload already removed
                return;
            }
-            payload.issuer().sendMessage("Your queued command has expired.");
+            payload.issuer().sendMessage(MVCorei18n.QUEUECOMMAND_EXPIRED);
        };
    }

@@ -5,6 +5,7 @@ import org.bukkit.scheduler.BukkitTask;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.locale.message.Message;

 /**
@@ -23,12 +24,10 @@ public class CommandQueuePayload {
        return new CommandQueuePayload(issuer);
    }

-    private static final String DEFAULT_PROMPT_MESSAGE = "The command you are trying to run is deemed dangerous."; // todo: localize
-
    private final MVCommandIssuer issuer;
    private String otp;
    private Runnable action = () -> {};
-    private Message prompt = Message.of(DEFAULT_PROMPT_MESSAGE);
+    private Message prompt = Message.of(MVCorei18n.QUEUECOMMAND_DEFAULTPROMPT);
    private BukkitTask expireTask;

    protected CommandQueuePayload(@NotNull MVCommandIssuer issuer) {
@@ -12,6 +12,9 @@ import org.jvnet.hk2.annotations.Service;
 import org.mvplugins.multiverse.core.anchor.AnchorManager;
 import org.mvplugins.multiverse.core.anchor.MultiverseAnchor;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
+
+import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.replace;

@Service
 final class AnchorDeleteCommand extends CoreCommand {
@@ -35,9 +38,9 @@ final class AnchorDeleteCommand extends CoreCommand {
            @Description("")
            MultiverseAnchor anchor) {
        if (anchorManager.deleteAnchor(anchor).isSuccess()) {
-            issuer.sendMessage("&aAnchor &f" + anchor.getName() + "&a deleted.");
+            issuer.sendMessage(MVCorei18n.ANCHOR_DELETE_SUCCESS, replace("{anchor}").with(anchor.getName()));
        } else {
-            issuer.sendMessage("&cFailed to delete anchor.");
+            issuer.sendError(MVCorei18n.ANCHOR_DELETE_FAILURE);
        }
    }
 }
@@ -15,15 +15,18 @@ import org.jvnet.hk2.annotations.Service;

 import org.mvplugins.multiverse.core.anchor.AnchorManager;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
-import org.mvplugins.multiverse.core.command.MVCommandManager;
 import org.mvplugins.multiverse.core.command.flag.ParsedCommandFlags;
 import org.mvplugins.multiverse.core.command.flags.PageFilterFlags;
 import org.mvplugins.multiverse.core.display.ContentDisplay;
 import org.mvplugins.multiverse.core.display.filters.DefaultContentFilter;
 import org.mvplugins.multiverse.core.display.handlers.PagedSendHandler;
 import org.mvplugins.multiverse.core.display.parsers.ListContentProvider;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
+import org.mvplugins.multiverse.core.locale.message.Message;
 import org.mvplugins.multiverse.core.teleportation.LocationManipulation;

+import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.replace;
+
@Service
 final class AnchorListCommand extends CoreCommand {

@@ -58,18 +61,19 @@ final class AnchorListCommand extends CoreCommand {
        ContentDisplay.create()
                .addContent(ListContentProvider.forContent(getAnchors(issuer.getPlayer())))
                .withSendHandler(PagedSendHandler.create()
-                        .withHeader("&3==== [ Multiverse Anchors ] ====")
+                        .withHeader(Message.of(MVCorei18n.ANCHOR_LIST_HEADER))
                        .doPagination(true)
                        .withTargetPage(parsedFlags.flagValue(flags.page, 1))
                        .withFilter(parsedFlags.flagValue(flags.filter, DefaultContentFilter.get())))
                .send(issuer);
    }

-    private List<String> getAnchors(Player player) {
+    private List<? extends Message> getAnchors(Player player) {
        return anchorManager.getAnchors(player).stream()
                .map(anchor ->
-                        "&a%s&7 - &f%s".formatted(
-                                anchor.getName(), locationManipulation.locationToString(anchor.getLocation())))
+                        Message.of(MVCorei18n.ANCHOR_LIST_ENTRY,
+                                replace("{anchor}").with(anchor.getName()),
+                                replace("{location}").with(locationManipulation.locationToString(anchor.getLocation()))))
                .toList();
    }
 }
@@ -15,8 +15,11 @@ import org.jvnet.hk2.annotations.Service;

 import org.mvplugins.multiverse.core.anchor.AnchorManager;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.teleportation.LocationManipulation;

+import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.replace;
+
@Service
 final class AnchorSetCommand extends CoreCommand {

@@ -80,10 +83,12 @@ final class AnchorSetCommand extends CoreCommand {
    }

    private void sendAnchorSetSuccessMessage(MVCommandIssuer issuer, String anchorName, String locationString) {
-        issuer.sendMessage("&aAnchor &f" + anchorName + "&a set to &f" + locationString);
+        issuer.sendMessage(MVCorei18n.ANCHOR_SET_SUCCESS,
+                replace("{anchor}").with(anchorName),
+                replace("{location}").with(locationString));
    }

    private void sendAnchorSetFailedMessage(MVCommandIssuer issuer, String anchorName) {
-        issuer.sendMessage("&cFailed to set anchor &f" + anchorName + ".");
+        issuer.sendMessage(MVCorei18n.ANCHOR_SET_FAILURE, replace("{anchor}").with(anchorName));
    }
 }
@@ -61,7 +61,7 @@ class CheckCommand extends CoreCommand {
                replace("{location}").with(destination.getLocation(player)
                        .map(locationManipulation::locationToString)
                        .map(Message::of)
-                        .getOrElse(() -> Message.of(MVCorei18n.GENERIC_NULL, "Null!"))));
+                        .getOrElse(() -> Message.of(MVCorei18n.GENERIC_NULL))));

        // TODO: Show permission required for this particular destination
    }
@@ -20,7 +20,7 @@ import org.mvplugins.multiverse.core.command.flag.FlagBuilder;
 import org.mvplugins.multiverse.core.command.flag.ParsedCommandFlags;
 import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
-import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
+import org.mvplugins.multiverse.core.world.MultiverseWorld;
 import org.mvplugins.multiverse.core.world.WorldManager;
 import org.mvplugins.multiverse.core.world.options.CloneWorldOptions;

@@ -41,21 +41,21 @@ class CloneCommand extends CoreCommand {
    @Subcommand("clone")
    @CommandPermission("multiverse.core.clone")
    @CommandCompletion("@mvworlds:scope=loaded @empty @flags:groupName=" + Flags.NAME)
-    @Syntax("<world> <new-world-name> [--reset-world-config --reset-gamerules --reset-world-border]")
+    @Syntax("<world> <new-world-name> [--reset-world-config --reset-gamerules --reset-world-border --no-save]")
    @Description("{@@mv-core.clone.description}")
    void onCloneCommand(
            MVCommandIssuer issuer,

            @Syntax("<world>")
            @Description("{@@mv-core.clone.world.description}")
-            LoadedMultiverseWorld world,
+            MultiverseWorld world,

            @Syntax("<new-world-name>")
-            @Description("{@@mv-core.clone.newWorld.description}")
+            @Description("{@@mv-core.clone.newworld.description}")
            String newWorldName,

            @Optional
-            @Syntax("[--reset-world-config --reset-gamerules --reset-world-border]")
+            @Syntax("[--reset-world-config --reset-gamerules --reset-world-border --no-save]")
            @Description("{@@mv-core.regen.other.description}")
            String[] flagArray) {
        ParsedCommandFlags parsedFlags = flags.parse(flagArray);
@@ -114,7 +114,7 @@ class CloneCommand extends CoreCommand {

        @Override
        @CommandAlias("mvcl|mvclone")
-        void onCloneCommand(MVCommandIssuer issuer, LoadedMultiverseWorld world, String newWorldName, String[] flags) {
+        void onCloneCommand(MVCommandIssuer issuer, MultiverseWorld world, String newWorldName, String[] flags) {
            super.onCloneCommand(issuer, world, newWorldName, flags);
        }
    }
@@ -67,12 +67,10 @@ class ConfigCommand extends CoreCommand {
    private void updateConfigValue(MVCommandIssuer issuer, String name, String value) {
        var stringPropertyHandle = config.getStringPropertyHandle();
        stringPropertyHandle.setPropertyString(issuer.getIssuer(), name, value)
-                .onSuccess(ignore -> {
-                    config.save();
-                    issuer.sendMessage(MVCorei18n.CONFIG_SET_SUCCESS,
-                            Replace.NAME.with(name),
-                            Replace.VALUE.with(stringPropertyHandle.getProperty(name).getOrNull()));
-                })
+                .andThenTry(config::save)
+                .onSuccess(ignore -> issuer.sendMessage(MVCorei18n.CONFIG_SET_SUCCESS,
+                        Replace.NAME.with(name),
+                        Replace.VALUE.with(stringPropertyHandle.getProperty(name).getOrNull())))
                .onFailure(e -> issuer.sendMessage(MVCorei18n.CONFIG_SET_ERROR,
                        Replace.NAME.with(name),
                        Replace.VALUE.with(value),
@@ -11,6 +11,7 @@ import co.aikar.commands.annotation.Optional;
 import co.aikar.commands.annotation.Subcommand;
 import co.aikar.commands.annotation.Syntax;
 import com.dumptruckman.minecraft.util.Logging;
+import io.vavr.control.Try;
 import jakarta.inject.Inject;
 import org.bukkit.World;
 import org.bukkit.WorldType;
@@ -19,14 +20,16 @@ import org.jvnet.hk2.annotations.Service;

 import org.mvplugins.multiverse.core.command.LegacyAliasCommand;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
-import org.mvplugins.multiverse.core.command.MVCommandManager;
 import org.mvplugins.multiverse.core.command.flag.CommandFlag;
 import org.mvplugins.multiverse.core.command.flag.CommandFlagsManager;
 import org.mvplugins.multiverse.core.command.flag.CommandValueFlag;
 import org.mvplugins.multiverse.core.command.flag.FlagBuilder;
 import org.mvplugins.multiverse.core.command.flag.ParsedCommandFlags;
+import org.mvplugins.multiverse.core.exceptions.command.MVInvalidCommandArgument;
 import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
+import org.mvplugins.multiverse.core.utils.StringFormatter;
+import org.mvplugins.multiverse.core.utils.position.EntityPosition;
 import org.mvplugins.multiverse.core.utils.result.Attempt.Failure;
 import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
 import org.mvplugins.multiverse.core.world.WorldManager;
@@ -52,8 +55,9 @@ class CreateCommand extends CoreCommand {
    @Subcommand("create")
    @CommandPermission("multiverse.core.create")
    @CommandCompletion("@empty @environments @flags:groupName=" + Flags.NAME)
-    @Syntax("<name> <environment> [--seed <seed> --generator <generator[:id]> --world-type <worldtype> --adjust-spawn "
-            + "--no-structures --biome <biome>]")
+    @Syntax("<name> <environment> [--seed <seed> --generator <generator[:id]> --world-type <worldtype> " +
+            "--no-adjust-spawn --no-structures --generate-bonus-chest --force-spawn-position <x,y,z:pitch:yaw> " +
+            "--biome <biome> --generator-settings <json-settings> --properties <prop1=value1,prop2=value2,...>]")
    @Description("{@@mv-core.create.description}")
    void onCreateCommand(
            MVCommandIssuer issuer,
@@ -67,8 +71,9 @@ class CreateCommand extends CoreCommand {
            World.Environment environment,

            @Optional
-            @Syntax("[--seed <seed> --generator <generator[:id]> --world-type <worldtype> --adjust-spawn "
-                    + "--no-structures --biome <biome>]")
+            @Syntax("[--seed <seed> --generator <generator[:id]> --world-type <worldtype> --no-adjust-spawn " +
+                    "--no-structures --generate-bonus-chest --force-spawn-position <x,y,z:pitch:yaw> --biome <biome> " +
+                    "--generator-settings <json-settings> --properties <prop1=value1,prop2=value2,...>]")
            @Description("{@@mv-core.create.flags.description}")
            String[] flagArray) {
        ParsedCommandFlags parsedFlags = flags.parse(flagArray);
@@ -78,14 +83,17 @@ class CreateCommand extends CoreCommand {
        issuer.sendInfo(MVCorei18n.CREATE_LOADING);

        worldManager.createWorld(CreateWorldOptions.worldName(worldName)
-                .biome(parsedFlags.flagValue(flags.biome, ""))
-                .environment(environment)
-                .seed(parsedFlags.flagValue(flags.seed))
-                .worldType(parsedFlags.flagValue(flags.worldType, WorldType.NORMAL))
-                .useSpawnAdjust(!parsedFlags.hasFlag(flags.noAdjustSpawn))
-                .generator(parsedFlags.flagValue(flags.generator, ""))
-                .generatorSettings(parsedFlags.flagValue(flags.generatorSettings, ""))
-                .generateStructures(!parsedFlags.hasFlag(flags.noStructures)))
+                        .biome(parsedFlags.flagValue(flags.biome, ""))
+                        .bonusChest(parsedFlags.hasFlag(flags.bonusChest))
+                        .environment(environment)
+                        .forcedSpawnPosition(parsedFlags.flagValue(flags.forceSpawnPosition))
+                        .generator(parsedFlags.flagValue(flags.generator, ""))
+                        .generatorSettings(parsedFlags.flagValue(flags.generatorSettings, ""))
+                        .generateStructures(!parsedFlags.hasFlag(flags.noStructures))
+                        .seed(parsedFlags.flagValue(flags.seed))
+                        .useSpawnAdjust(!parsedFlags.hasFlag(flags.noAdjustSpawn))
+                        .worldPropertyStrings(StringFormatter.parseCSVMap(parsedFlags.flagValue(flags.properties)))
+                        .worldType(parsedFlags.flagValue(flags.worldType, WorldType.NORMAL)))
                .onSuccess(newWorld -> messageSuccess(issuer, newWorld))
                .onFailure(failure -> messageFailure(issuer, failure));
    }
@@ -180,6 +188,19 @@ class CreateCommand extends CoreCommand {
                .addAlias("-b")
                .completion(input -> biomeProviderFactory.suggestBiomeString(input))
                .build());
+
+        private final CommandValueFlag<String> properties = flag(CommandValueFlag.builder("--properties", String.class)
+                .addAlias("-p")
+                .build());
+
+        private final CommandFlag bonusChest = flag(CommandFlag.builder("--generate-bonus-chest")
+                .addAlias("-c")
+                .build());
+
+        private final CommandValueFlag<EntityPosition> forceSpawnPosition = flag(CommandValueFlag.builder("--force-spawn-position", EntityPosition.class)
+                .addAlias("-f")
+                .context(input -> Try.of(() -> EntityPosition.fromString(input)).getOrElseThrow(MVInvalidCommandArgument::causeBy))
+                .build());
    }

    @Service
@@ -15,11 +15,11 @@ import org.jvnet.hk2.annotations.Service;

 import org.mvplugins.multiverse.core.command.LegacyAliasCommand;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
-import org.mvplugins.multiverse.core.command.MVCommandManager;
 import org.mvplugins.multiverse.core.command.flag.ParsedCommandFlags;
-import org.mvplugins.multiverse.core.command.flags.RemovePlayerFlags;
+import org.mvplugins.multiverse.core.command.flags.RemovePlayerDestinationFlags;
 import org.mvplugins.multiverse.core.command.queue.CommandQueueManager;
 import org.mvplugins.multiverse.core.command.queue.CommandQueuePayload;
+import org.mvplugins.multiverse.core.destination.DestinationInstance;
 import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.locale.message.Message;
 import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
@@ -31,6 +31,8 @@ import org.mvplugins.multiverse.core.world.WorldManager;
 import org.mvplugins.multiverse.core.world.helpers.PlayerWorldTeleporter;
 import org.mvplugins.multiverse.core.world.options.DeleteWorldOptions;

+import java.util.Objects;
+
@Service
 class DeleteCommand extends CoreCommand {

@@ -38,7 +40,7 @@ class DeleteCommand extends CoreCommand {
    private final WorldManager worldManager;
    private final PlayerWorldTeleporter playerWorldTeleporter;
    private final WorldTickDeferrer worldTickDeferrer;
-    private final RemovePlayerFlags flags;
+    private final RemovePlayerDestinationFlags flags;

    @Inject
    DeleteCommand(
@@ -46,7 +48,7 @@ class DeleteCommand extends CoreCommand {
            @NotNull WorldManager worldManager,
            @NotNull PlayerWorldTeleporter playerWorldTeleporter,
            @NotNull WorldTickDeferrer worldTickDeferrer,
-            @NotNull RemovePlayerFlags flags
+            @NotNull RemovePlayerDestinationFlags flags
    ) {
        this.commandQueueManager = commandQueueManager;
        this.worldManager = worldManager;
@@ -57,8 +59,8 @@ class DeleteCommand extends CoreCommand {

    @Subcommand("delete")
    @CommandPermission("multiverse.core.delete")
-    @CommandCompletion("@mvworlds:scope=both @flags:groupName=" + RemovePlayerFlags.NAME)
-    @Syntax("<world>")
+    @CommandCompletion("@mvworlds:scope=both @flags:groupName=" + RemovePlayerDestinationFlags.NAME)
+    @Syntax("<world> [--remove-players [destination]]")
    @Description("{@@mv-core.delete.description}")
    void onDeleteCommand(
            MVCommandIssuer issuer,
@@ -69,7 +71,7 @@ class DeleteCommand extends CoreCommand {
            MultiverseWorld world,

            @Optional
-            @Syntax("[--remove-players]")
+            @Syntax("[--remove-players [destination]]")
            @Description("")
            String[] flagArray) {
        ParsedCommandFlags parsedFlags = flags.parse(flagArray);
@@ -77,21 +79,22 @@ class DeleteCommand extends CoreCommand {
        commandQueueManager.addToQueue(CommandQueuePayload
                .issuer(issuer)
                .action(() -> runDeleteCommand(issuer, world, parsedFlags))
-                .prompt(Message.of(MVCorei18n.DELETE_PROMPT, "",
+                .prompt(Message.of(MVCorei18n.DELETE_PROMPT,
                        Replace.WORLD.with(world.getName()))));
    }

    private void runDeleteCommand(MVCommandIssuer issuer, MultiverseWorld world, ParsedCommandFlags parsedFlags) {
        issuer.sendInfo(MVCorei18n.DELETE_DELETING, Replace.WORLD.with(world.getName()));

-        var future = parsedFlags.hasFlag(flags.removePlayers)
+        DestinationInstance<?, ?> removeToDestination = parsedFlags.flagValue(flags.removePlayers);
+        var future = Objects.nonNull(removeToDestination)
                        && world.isLoaded()
                        && world instanceof LoadedMultiverseWorld loadedWorld
-                ? playerWorldTeleporter.removeFromWorld(loadedWorld)
+                ? playerWorldTeleporter.transferAllFromWorldToDestination(loadedWorld, removeToDestination)
                : AsyncAttemptsAggregate.emptySuccess();

        future.onSuccess(() -> worldTickDeferrer.deferWorldTick(() -> doWorldDeleting(issuer, world)))
-                .onFailure(() -> issuer.sendError("Failed to teleport one or more players out of the world!"));
+                .onFailure(() -> issuer.sendError(MVCorei18n.GENERIC_TELEPORTPLAYERS_FAILED));
    }

    private void doWorldDeleting(MVCommandIssuer issuer, MultiverseWorld world) {
@@ -113,7 +116,7 @@ class DeleteCommand extends CoreCommand {
                @NotNull WorldManager worldManager,
                @NotNull PlayerWorldTeleporter playerWorldTeleporter,
                @NotNull WorldTickDeferrer worldTickDeferrer,
-                @NotNull RemovePlayerFlags flags) {
+                @NotNull RemovePlayerDestinationFlags flags) {
            super(commandQueueManager, worldManager, playerWorldTeleporter, worldTickDeferrer, flags);
        }

@@ -12,13 +12,10 @@ import org.jvnet.hk2.annotations.Service;

 import org.mvplugins.multiverse.core.command.flag.CommandFlagsManager;
 import org.mvplugins.multiverse.core.command.flag.FlagBuilder;
-import org.mvplugins.multiverse.core.commands.DumpsLogPoster.LogsType;
+import org.mvplugins.multiverse.core.command.flag.ParsedCommandFlags;
 import org.mvplugins.multiverse.core.commands.DumpsLogPoster.UploadType;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
-import org.mvplugins.multiverse.core.command.MVCommandManager;
-import org.mvplugins.multiverse.core.command.flag.CommandFlag;
 import org.mvplugins.multiverse.core.command.flag.CommandValueFlag;
-import org.mvplugins.multiverse.core.command.flag.ParsedCommandFlags;

@Service
 final class DumpsCommand extends CoreCommand {
@@ -35,22 +32,17 @@ final class DumpsCommand extends CoreCommand {
    @Subcommand("dumps")
    @CommandPermission("multiverse.core.dumps")
    @CommandCompletion("@flags:groupName=" + Flags.NAME)
-    @Syntax("[--logs <mclogs | append>] [--upload <pastesdev | pastegg>] [--paranoid]")
+    @Syntax("[--upload <pastesdev|mclogs>]")
    @Description("{@@mv-core.dumps.description}")
    void onDumpsCommand(
            MVCommandIssuer issuer,

            @Optional
-            @Syntax("[--logs <mclogs | append>] [--upload <pastesdev | pastegg>] [--paranoid]")
+            @Syntax("[--upload <pastesdev|mclogs>]")
            String[] flagArray) {
        ParsedCommandFlags parsedFlags = flags.parse(flagArray);
-
-        // Grab all our flags
-        boolean paranoid = parsedFlags.hasFlag(flags.paranoid);
-        LogsType logsType = parsedFlags.flagValue(flags.logs, LogsType.MCLOGS);
        UploadType servicesType = parsedFlags.flagValue(flags.upload, UploadType.PASTESDEV);
-
-        dumpsService.postLogs(issuer, logsType, servicesType, paranoid);
+        dumpsService.postLogs(issuer, servicesType);
    }

    @Service
@@ -63,19 +55,9 @@ final class DumpsCommand extends CoreCommand {
            super(NAME, flagsManager);
        }

-        private final CommandValueFlag<LogsType> logs = flag(CommandValueFlag
-                .enumBuilder("--logs", LogsType.class)
-                .addAlias("-l")
-                .build());
-
        private final CommandValueFlag<UploadType> upload = flag(CommandValueFlag
                .enumBuilder("--upload", UploadType.class)
                .addAlias("-u")
                .build());
-
-        // Does not upload logs or plugin list (except if --logs mclogs is there)
-        private final CommandFlag paranoid = flag(CommandFlag.builder("--paranoid")
-                .addAlias("-p")
-                .build());
    }
 }
@@ -1,11 +1,19 @@
 package org.mvplugins.multiverse.core.commands;

+import java.lang.management.ManagementFactory;
+import java.time.Instant;
+import java.util.Date;
 import java.util.Map;

 import com.dumptruckman.minecraft.util.Logging;
+import io.vavr.control.Option;
+import net.minidev.json.JSONArray;
+import net.minidev.json.JSONObject;
+import org.bukkit.plugin.Plugin;
 import org.bukkit.scheduler.BukkitRunnable;
 import org.jetbrains.annotations.NotNull;

+import org.mvplugins.multiverse.core.MultiverseCore;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
 import org.mvplugins.multiverse.core.event.MVDumpsDebugInfoEvent;
 import org.mvplugins.multiverse.core.locale.MVCorei18n;
@@ -18,8 +26,10 @@ final class DumpsLogPoster extends BukkitRunnable {

    enum UploadType {
        // BEGIN CHECKSTYLE-SUPPRESSION: JavadocVariable
-        PASTEGG(PasteServiceType.PASTEGG, "paste.gg"),
-        PASTESDEV(PasteServiceType.PASTESDEV, "pastes.dev");
+        // PASTEBIN(PasteServiceType.PASTEBIN, "pastebin.com"),
+        PASTESDEV(PasteServiceType.PASTESDEV, "pastes.dev"),
+        MCLOGS(PasteServiceType.MCLOGS, "mclo.gs"),
+        ;
        // END CHECKSTYLE-SUPPRESSION: JavadocVariable

        private final PasteServiceType pasteServiceType;
@@ -31,34 +41,21 @@ final class DumpsLogPoster extends BukkitRunnable {
        }
    }

-    enum LogsType {
-        /**
-         * Appends the log file to the debug info.
-         */
-        APPEND,
-        /**
-         * Uploads the log file to a paste service.
-         */
-        MCLOGS
-    }
-
+    @NotNull
+    private final MultiverseCore plugin;
    private final MVCommandIssuer issuer;
-    private final LogsType logsType;
    private final UploadType uploadType;
-    private final boolean paranoid;
    private final String logs;
    private final MVDumpsDebugInfoEvent versionEvent;

-    DumpsLogPoster(@NotNull MVCommandIssuer issuer,
-                   @NotNull DumpsLogPoster.LogsType logsType,
+    DumpsLogPoster(@NotNull MultiverseCore core,
+                   @NotNull MVCommandIssuer issuer,
                   @NotNull DumpsLogPoster.UploadType uploadType,
-                   boolean paranoid,
                   @NotNull String logs,
                   @NotNull MVDumpsDebugInfoEvent versionEvent) {
+        this.plugin = core;
        this.issuer = issuer;
-        this.logsType = logsType;
        this.uploadType = uploadType;
-        this.paranoid = paranoid;
        this.logs = logs;
        this.versionEvent = versionEvent;
    }
@@ -69,24 +66,12 @@ final class DumpsLogPoster extends BukkitRunnable {
        handleVersionEvent();
    }

-    @SuppressWarnings("checkstyle:MissingSwitchDefault")
    private void handleLogs() {
-        Logging.finer("Logs type is: " + logsType);
-
-        if (!paranoid) {
-            switch (logsType) {
-                case MCLOGS -> sendDumpsUrl("Logs", postRawDataToMcLogs(logs));
-                case APPEND -> versionEvent.putDetailedDebugInfo("latest.log", logs);
-                default -> Logging.finer("Not uploading logs.");
-            }
-        } else {
-            Logging.finer("Paranoid mode is on, not uploading logs.");
-        }
+        versionEvent.putDetailedDebugInfo("latest.log", logs);
    }

    private void handleVersionEvent() {
        Logging.finer("Upload service is: " + uploadType);
-
        final Map<String, String> files = versionEvent.getDetailedDebugInfo();
        sendDumpsUrl(uploadType.serviceName, postFilesToService(files));
    }
@@ -95,37 +80,77 @@ final class DumpsLogPoster extends BukkitRunnable {
        issuer.sendInfo(MVCorei18n.DUMPS_URL_LIST, "{service}", service, "{link}", url);
    }

-    private String postRawDataToMcLogs(@NotNull String rawPasteData) {
-        PasteService pasteService = PasteServiceFactory.getService(PasteServiceType.MCLOGS, true);
-
-        return pasteToService(() -> pasteService.postData(rawPasteData));
-    }
-
    private String postFilesToService(@NotNull Map<String, String> pasteFiles) {
-        PasteService pasteService = PasteServiceFactory.getService(uploadType.pasteServiceType, true);
-
-        return pasteToService(() -> {
-            if (pasteService.supportsMultiFile()) {
-                return pasteService.postData(pasteFiles);
-            } else {
-                return pasteService.postData(this.encodeAsString(pasteFiles));
-            }
-        });
+        PasteService pasteService = PasteServiceFactory.getService(uploadType.pasteServiceType, false);
+        return pasteToService(() -> pasteService.postData(encodePasteAsJson(pasteFiles)));
    }

-    private String encodeAsString(Map<String, String> files) {
-        StringBuilder uploadData = new StringBuilder();
-        for (Map.Entry<String, String> entry : files.entrySet()) {
-            String file = entry.getKey();
-            String data = entry.getValue();
-            uploadData.append("# ---------- ")
-                    .append(file)
-                    .append(" ----------\n\n")
-                    .append(data)
-                    .append("\n\n");
+    private String encodePasteAsJson(Map<String, String> files) {
+        JSONObject rootObject = new JSONObject();
+        JSONArray plugins = new JSONArray();
+        JSONArray filesObject = new JSONArray();
+
+        for (Plugin plugin : plugin.getServer().getPluginManager().getPlugins()) {
+            plugins.add(new JSONObject(Map.of(
+                    "name", plugin.getName(),
+                    "version", plugin.getDescription().getVersion(),
+                    "description", Option.of(plugin.getDescription().getDescription()).getOrElse(""),
+                    "authors", plugin.getDescription().getAuthors(),
+                    "website", Option.of(plugin.getDescription().getWebsite()).getOrElse(""),
+                    "enabled", plugin.isEnabled()
+            )));
        }

-        return uploadData.toString();
+        for (Map.Entry<String, String> entry : files.entrySet()) {
+            String fileType = "text";
+            if (entry.getKey().endsWith(".yml") || entry.getKey().endsWith(".yaml")) {
+                fileType = "yaml";
+            } else if (entry.getKey().endsWith(".json")) {
+                fileType = "json";
+            } else if (entry.getKey().endsWith(".md")) {
+                fileType = "markdown";
+            } else if (entry.getKey().endsWith(".log")) {
+                fileType = "accesslog";
+            }
+
+            filesObject.add(new JSONObject(Map.of(
+                    "name", entry.getKey(),
+                    "data", entry.getValue(),
+                    "type", fileType
+            )));
+        }
+        rootObject.put("server", new JSONObject(Map.of(
+                "name", plugin.getServer().getName(),
+                "version", plugin.getServer().getVersion(),
+                "bukkitVersion", plugin.getServer().getBukkitVersion(),
+                "onlineMode", plugin.getServer().getOnlineMode(),
+                "javaVersion", Runtime.version().toString(),
+                "operatingSystem", System.getProperty("os.name") + " " + System.getProperty("os.version") + " " + System.getProperty("os.arch"),
+                "uptime", calculateUptimeString(),
+                "memory", "%d free / %d total / %d max".formatted(
+                        toMb(Runtime.getRuntime().freeMemory()),
+                        toMb(Runtime.getRuntime().totalMemory()),
+                        toMb(Runtime.getRuntime().maxMemory()))
+        )));
+
+        rootObject.put("plugins", plugins);
+        rootObject.put("files", filesObject);
+        rootObject.put("createdAt", Instant.now().toString());
+
+        return rootObject.toJSONString();
+    }
+
+    private long toMb(long value) {
+        return value / 1024 / 1024;
+    }
+
+    private String calculateUptimeString() {
+        long uptimeMs = System.currentTimeMillis() - ManagementFactory.getRuntimeMXBean().getStartTime();
+        long totalSeconds = uptimeMs / 1000;
+        long hours = totalSeconds / 3600;
+        long minutes = (totalSeconds % 3600) / 60;
+        long seconds = totalSeconds % 60;
+        return String.format("%d hrs, %d mins, %d sec", hours, minutes, seconds);
    }

    private String pasteToService(LogPaster paster) {
@@ -8,13 +8,12 @@ import java.nio.file.Path;

 import com.dumptruckman.minecraft.util.Logging;
 import jakarta.inject.Inject;
-import org.apache.commons.lang3.StringUtils;
 import org.jetbrains.annotations.NotNull;
 import org.jvnet.hk2.annotations.Service;

 import org.mvplugins.multiverse.core.MultiverseCore;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.module.MultiverseModulesRegistry;
-import org.mvplugins.multiverse.core.commands.DumpsLogPoster.LogsType;
 import org.mvplugins.multiverse.core.commands.DumpsLogPoster.UploadType;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
 import org.mvplugins.multiverse.core.event.MVDumpsDebugInfoEvent;
@@ -38,16 +37,12 @@ final class DumpsService {
        this.fileUtils = fileUtils;
    }

-    void postLogs(MVCommandIssuer issuer, LogsType logsType, UploadType servicesType, boolean paranoid) {
+    void postLogs(MVCommandIssuer issuer, UploadType servicesType) {
+        issuer.sendInfo(MVCorei18n.DUMPS_STARTING);
+
        // Initialise and add info to the debug event
        MVDumpsDebugInfoEvent versionEvent = createAndCallDebugInfoEvent();
-
-        // Add plugin list if user isn't paranoid
-        if (!paranoid) {
-            versionEvent.putDetailedDebugInfo("plugins.md", "# Plugins\n\n" + getPluginList());
-        }
-
-        new DumpsLogPoster(issuer, logsType, servicesType, paranoid, getLogs(), versionEvent)
+        new DumpsLogPoster(plugin, issuer, servicesType, getLogs(), versionEvent)
                .runTaskAsynchronously(plugin);
    }

@@ -72,18 +67,18 @@ final class DumpsService {
    private @NotNull String readLogsFromFile(Path logsPath) {
        String logs = "Could not read log";

-        // Try reading as ANSI encoded
+        // Try reading as UTF-8 first
        try {
            logs = Files.readString(logsPath, StandardCharsets.UTF_8);
        } catch (IOException e) {
-            Logging.severe("Could not read logs/latest.log. See below for stack trace");
+            Logging.severe("Could not read logs/latest.log as UTF-8. Trying ISO-8859-1. See below for stack trace");
            e.printStackTrace();

            try {
-                logs = Files.readString(logsPath, StandardCharsets.UTF_8);
+                logs = Files.readString(logsPath, StandardCharsets.ISO_8859_1);
            } catch (IOException ex) {
                // It is some other strange encoding
-                Logging.severe("Could not read ./logs/latest.log. See below for stack trace");
+                Logging.severe("Could not read ./logs/latest.log as ISO-8859-1. See below for stack trace");
                ex.printStackTrace();
            }
        }
@@ -91,15 +86,6 @@ final class DumpsService {
        return logs;
    }

-    private String getDebugInfoString() {
-        return "# Multiverse-Core Version info" + "\n\n"
-                + " - Multiverse-Core Version: " + this.plugin.getDescription().getVersion() + '\n'
-                + " - Bukkit Version: " + this.plugin.getServer().getVersion() + '\n'
-                + " - Loaded Worlds: " + worldManager.getLoadedWorlds() + '\n'
-                + " - Multiverse Plugins Loaded: " + StringFormatter.joinAnd(MultiverseModulesRegistry.get().getRegisteredPlugins()) + '\n'
-                + " - Multiverse Plugins Count: " + MultiverseModulesRegistry.get().getPluginCount() + '\n';
-    }
-
    private MVDumpsDebugInfoEvent createAndCallDebugInfoEvent() {
        MVDumpsDebugInfoEvent event = new MVDumpsDebugInfoEvent();
        addDebugInfoToEvent(event);
@@ -111,31 +97,63 @@ final class DumpsService {
        // Add the legacy file, but as markdown, so it's readable
        event.putDetailedDebugInfo("version.md", this.getDebugInfoString());

-        // add config.yml
-        File configFile = new File(plugin.getDataFolder(), "config.yml");
-        event.putDetailedDebugInfo("Multiverse-Core/config.yml", configFile);
-
-        // add worlds.yml
-        File worldsFile = new File(plugin.getDataFolder(), "worlds.yml");
-        event.putDetailedDebugInfo("Multiverse-Core/worlds.yml", worldsFile);
-
-        // Add bukkit.yml if we found it
-        if (fileUtils.getBukkitConfig() != null) {
-            event.putDetailedDebugInfo(fileUtils.getBukkitConfig().getPath(), fileUtils.getBukkitConfig());
-        } else {
-            Logging.warning("/mv dumps could not find bukkit.yml. Not including file");
-        }
-
        // Add server.properties if we found it
        if (fileUtils.getServerProperties() != null) {
-            event.putDetailedDebugInfo(fileUtils.getServerProperties().getPath(), fileUtils.getServerProperties());
+            event.putDetailedDebugInfo(fileUtils.getServerProperties().getName(), fileUtils.getServerProperties());
        } else {
            Logging.warning("/mv dumps could not find server.properties. Not including file");
        }

+        // Add bukkit.yml if we found it
+        if (fileUtils.getBukkitConfig() != null) {
+            event.putDetailedDebugInfo(fileUtils.getBukkitConfig().getName(), fileUtils.getBukkitConfig());
+        } else {
+            Logging.warning("/mv dumps could not find bukkit.yml. Not including file");
+        }
+
+        // Add spigot.yml
+        File spigotYml = fileUtils.getServerFolder().toPath().resolve("spigot.yml").toFile();
+        if (spigotYml.isFile()) {
+            event.putDetailedDebugInfo(spigotYml.getName(), spigotYml);
+        } else {
+            Logging.warning("/mv dumps could not find spigot.yml. Not including file");
+        }
+
+        // Add paper-global.yml
+        File paperGlobalYml = fileUtils.getServerFolder().toPath().resolve("config/paper-global.yml").toFile();
+        if (paperGlobalYml.isFile()) {
+            event.putDetailedDebugInfo(paperGlobalYml.getName(), paperGlobalYml);
+        } else {
+            Logging.warning("/mv dumps could not find paper-global.yml. Not including file");
+        }
+
+        // add paper-world-defaults.yml
+        File paperWorldDefaultsYml = fileUtils.getServerFolder().toPath().resolve("config/paper-world-defaults.yml").toFile();
+        if (paperWorldDefaultsYml.isFile()) {
+            event.putDetailedDebugInfo(paperWorldDefaultsYml.getName(), paperWorldDefaultsYml);
+        } else {
+            Logging.warning("/mv dumps could not find paper-global.yml. Not including file");
+        }
+
+        // add multiverse-core config.yml
+        File configFile = new File(plugin.getDataFolder(), "config.yml");
+        event.putDetailedDebugInfo("multiverse-core/config.yml", configFile);
+
+        // add multiverse-core worlds.yml
+        File worldsFile = new File(plugin.getDataFolder(), "worlds.yml");
+        event.putDetailedDebugInfo("multiverse-core/worlds.yml", worldsFile);
+
+        // add multiverse-core anchors.yml
+        File anchorsFile = new File(plugin.getDataFolder(), "anchors.yml");
+        event.putDetailedDebugInfo("multiverse-core/anchors.yml", anchorsFile);
    }

-    private String getPluginList() {
-        return " - " + StringUtils.join(plugin.getServer().getPluginManager().getPlugins(), "\n - ");
+    private String getDebugInfoString() {
+        return "# Multiverse-Core Version info" + "\n\n"
+                + " - Multiverse-Core Version: " + this.plugin.getDescription().getVersion() + '\n'
+                + " - Bukkit Version: " + this.plugin.getServer().getVersion() + '\n'
+                + " - Loaded Worlds: " + worldManager.getLoadedWorlds() + '\n'
+                + " - Multiverse Plugins Loaded: " + StringFormatter.joinAnd(MultiverseModulesRegistry.get().getRegisteredPlugins()) + '\n'
+                + " - Multiverse Plugins Count: " + MultiverseModulesRegistry.get().getPluginCount() + '\n';
    }
 }
@@ -21,7 +21,9 @@ import org.mvplugins.multiverse.core.display.ContentDisplay;
 import org.mvplugins.multiverse.core.display.filters.DefaultContentFilter;
 import org.mvplugins.multiverse.core.display.handlers.PagedSendHandler;
 import org.mvplugins.multiverse.core.display.parsers.ListContentProvider;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.locale.message.Message;
+import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
 import org.mvplugins.multiverse.core.utils.StringFormatter;
 import org.mvplugins.multiverse.core.world.MultiverseWorld;
 import org.mvplugins.multiverse.core.world.WorldManager;
@@ -31,6 +33,8 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;

+import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.replace;
+
@Service
@Subcommand("entity-spawn-config")
 final class EntitySpawnConfigCommand extends CoreCommand {
@@ -52,7 +56,7 @@ final class EntitySpawnConfigCommand extends CoreCommand {
    void onInfoCommand(
            MVCommandIssuer issuer,

-            @Flags("resolve=issuerAware")
+            @Flags("resolve=issuerAware,maxArgForAware=0")
            @Syntax("[world]")
            MultiverseWorld world,

@@ -64,21 +68,26 @@ final class EntitySpawnConfigCommand extends CoreCommand {
        ContentDisplay.create()
                .addContent(ListContentProvider.forContent(getEntitySpawnConfigList(world)))
                .withSendHandler(PagedSendHandler.create()
-                        .withHeader(Message.of("==== [ Entity Spawn Config '" + world.getName() + "' ] ===="))
+                        .withHeader(Message.of(MVCorei18n.ENTITYSPAWNCONFIG_INFO_HEADER,
+                                Replace.WORLD.with(world.getName())))
                        .withLinesPerPage(8)
                        .withTargetPage(parsedFlags.flagValue(flags.page, 1))
                        .withFilter(parsedFlags.flagValue(flags.filter, DefaultContentFilter.get())))
                .send(issuer);
    }

-    private List<String> getEntitySpawnConfigList(MultiverseWorld world) {
-        List<String> list = new ArrayList<>();
+    private List<Message> getEntitySpawnConfigList(MultiverseWorld world) {
+        List<Message> list = new ArrayList<>();
        Arrays.stream(SpawnCategory.values()).forEach(spawnCategory -> {
-            list.add(spawnCategory.name() + ": ");
+            list.add(Message.of(MVCorei18n.ENTITYSPAWNCONFIG_INFO_CATEGORY,
+                    replace("{category}").with(spawnCategory.name())));
            SpawnCategoryConfig spawnCategoryConfig = world.getEntitySpawnConfig().getSpawnCategoryConfig(spawnCategory);
-            list.add("  spawn: " + spawnCategoryConfig.isSpawn());
-            list.add("  tick-rate: " + spawnCategoryConfig.getTickRate());
-            list.add("  exceptions: " + StringFormatter.join(spawnCategoryConfig.getExceptions(), ", "));
+            list.add(Message.of(MVCorei18n.ENTITYSPAWNCONFIG_INFO_SPAWN,
+                    replace("{spawn}").with(spawnCategoryConfig.isSpawn())));
+            list.add(Message.of(MVCorei18n.ENTITYSPAWNCONFIG_INFO_TICKRATE,
+                    replace("{tickRate}").with(spawnCategoryConfig.getTickRate())));
+            list.add(Message.of(MVCorei18n.ENTITYSPAWNCONFIG_INFO_EXCEPTIONS,
+                    replace("{exceptions}").with(StringFormatter.join(spawnCategoryConfig.getExceptions(), ", "))));
        });
        return list;
    }
@@ -91,7 +100,7 @@ final class EntitySpawnConfigCommand extends CoreCommand {
    void onModifyCommand(
            MVCommandIssuer issuer,

-            @Flags("resolve=issuerAware")
+            @Flags("resolve=issuerAware,maxArgForAware=4")
            @Syntax("[world]")
            MultiverseWorld world,

@@ -113,11 +122,17 @@ final class EntitySpawnConfigCommand extends CoreCommand {
                .getSpawnCategoryConfig(spawnCategory)
                .getStringPropertyHandle()
                .modifyPropertyString(property, value, action)
-                .onSuccess(ignore -> issuer.sendInfo("Successfully set " + property + " to " + value
-                        + " for " + spawnCategory.name() + " in " + world.getName()))
-                .onFailure(e -> issuer.sendError("Unable to set " + property + " to " + value
-                        + " for " + spawnCategory.name() + " in " + world.getName() + ": " + e.getMessage()));
-
-        worldManager.saveWorldsConfig();
+                .andThenTry(worldManager::saveWorldsConfig)
+                .onSuccess(ignore -> issuer.sendInfo(MVCorei18n.ENTITYSPAWNCONFIG_MODIFY_SUCCESS,
+                        replace("{property}").with(property),
+                        Replace.VALUE.with(value),
+                        replace("{category}").with(spawnCategory.name()),
+                        Replace.WORLD.with(world.getName())))
+                .onFailure(e -> issuer.sendError(MVCorei18n.ENTITYSPAWNCONFIG_MODIFY_FAILURE,
+                        replace("{property}").with(property),
+                        Replace.VALUE.with(value),
+                        replace("{category}").with(spawnCategory.name()),
+                        Replace.WORLD.with(world.getName()),
+                        Replace.ERROR.with(e)));
    }
 }
@@ -54,21 +54,21 @@ class GameruleCommand extends CoreCommand {
    @Subcommand("gamerule|rule set")
    @CommandPermission("multiverse.core.gamerule.set")
    @CommandCompletion("@gamerules @gamerulesvalues @mvworlds:multiple|*")
-    @Syntax("<Gamerule> <Gamerule value> [World or *]")
+    @Syntax("<gamerule> <value> [worlds|*]")
    @Description("{@@mv-core.gamerule.set.description}")
    void onGameruleSetCommand(
            MVCommandIssuer issuer,

-            @Syntax("<Gamerule>")
+            @Syntax("<gamerule>")
            @Description("{@@mv-core.gamerule.set.gamerule.description}")
            GameRule gamerule,

-            @Syntax("<Value>")
+            @Syntax("<value>")
            @Description("{@@mv-core.gamerule.set.value.description}")
            GameRuleValue gameRuleValue,

-            @Flags("resolve=issuerAware")
-            @Syntax("[World or *]")
+            @Flags("resolve=issuerAware,maxArgForAware=2")
+            @Syntax("[worlds|*]")
            @Description("{@@mv-core.gamerule.set.world.description}")
            LoadedMultiverseWorld[] worlds) {
        Object value = gameRuleValue.value();
@@ -105,17 +105,17 @@ class GameruleCommand extends CoreCommand {
    @Subcommand("gamerule|rule reset")
    @CommandPermission("multiverse.core.gamerule.set")
    @CommandCompletion("@gamerules @mvworlds:multiple|*")
-    @Syntax("<Gamerule> [World or *]")
+    @Syntax("<gamerule> [worlds|*]")
    @Description("{@@mv-core.gamerule.reset.description}")
    void onGameruleResetCommand(
            MVCommandIssuer issuer,

-            @Syntax("<Gamerule>")
+            @Syntax("<gamerule>")
            @Description("{@@mv-core.gamerule.reset.gamerule.description}")
            GameRule gamerule,

-            @Flags("resolve=issuerAware")
-            @Syntax("[World or *]")
+            @Flags("resolve=issuerAware,maxArgForAware=1")
+            @Syntax("[worlds|*]")
            @Description("{@@mv-core.gamerule.reset.world.description}")
            LoadedMultiverseWorld[] worlds) {
        AtomicBoolean success = new AtomicBoolean(true);
@@ -152,8 +152,8 @@ class GameruleCommand extends CoreCommand {
    void onGameruleListCommand(
            MVCommandIssuer issuer,

-            @Flags("resolve=issuerAware")
-            @Syntax("<world>")
+            @Flags("resolve=issuerAware,maxArgForAware=0")
+            @Syntax("[world]")
            @Description("{@@mv-core.gamerule.list.description.world}")
            LoadedMultiverseWorld world,

@@ -10,7 +10,6 @@ import co.aikar.commands.annotation.Optional;
 import co.aikar.commands.annotation.Subcommand;
 import co.aikar.commands.annotation.Syntax;
 import jakarta.inject.Inject;
-import org.bukkit.ChatColor;
 import org.jetbrains.annotations.NotNull;
 import org.jvnet.hk2.annotations.Service;

@@ -23,10 +22,13 @@ import org.mvplugins.multiverse.core.display.filters.DefaultContentFilter;
 import org.mvplugins.multiverse.core.display.handlers.PagedSendHandler;
 import org.mvplugins.multiverse.core.display.parsers.ListContentProvider;
 import org.mvplugins.multiverse.core.locale.MVCorei18n;
+import org.mvplugins.multiverse.core.locale.message.Message;
 import org.mvplugins.multiverse.core.utils.StringFormatter;
 import org.mvplugins.multiverse.core.world.generators.GeneratorPlugin;
 import org.mvplugins.multiverse.core.world.generators.GeneratorProvider;

+import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.replace;
+
 /**
 * List all gamerules in your current or specified world.
 */
@@ -68,7 +70,7 @@ class GeneratorsCommand extends CoreCommand {
        ContentDisplay.create()
                .addContent(ListContentProvider.forContent(generators))
                .withSendHandler(PagedSendHandler.create()
-                        .withHeader("%s====[ Multiverse Generator List ]====", ChatColor.AQUA)
+                        .withHeader(Message.of(MVCorei18n.GENERATORS_HEADER))
                        .doPagination(true)
                        .withTargetPage(parsedFlags.flagValue(flags.page, 1))
                        .withFilter(parsedFlags.flagValue(flags.filter, DefaultContentFilter.get())))
@@ -85,10 +87,13 @@ class GeneratorsCommand extends CoreCommand {
            @Syntax("<generator>")
            GeneratorPlugin generatorPlugin
    ) {
-        issuer.sendMessage(ChatColor.RESET + "Generator Plugin: " + generatorPlugin.getPluginName());
-        issuer.sendMessage(ChatColor.RESET + "Example usages: ");
-        issuer.sendMessage(ChatColor.RESET + StringFormatter.join(generatorPlugin.getExampleUsages(), "\n"));
-        issuer.sendMessage(ChatColor.RESET + "Link to more info: " + generatorPlugin.getInfoLink());
+        issuer.sendMessage(MVCorei18n.GENERATORS_INFO_PLUGIN,
+                replace("{plugin}").with(generatorPlugin.getPluginName()));
+        issuer.sendMessage(MVCorei18n.GENERATORS_INFO_EXAMPLEUSAGES);
+        issuer.sendMessage(MVCorei18n.GENERATORS_INFO_USAGES,
+                replace("{usages}").with(StringFormatter.join(generatorPlugin.getExampleUsages(), "\n")));
+        issuer.sendMessage(MVCorei18n.GENERATORS_INFO_INFOLINK,
+                replace("{link}").with(generatorPlugin.getInfoLink()));
    }

    @Service
@@ -43,22 +43,24 @@ class ImportCommand extends CoreCommand {
    @Subcommand("import")
    @CommandPermission("multiverse.core.import")
    @CommandCompletion("@mvworlds:scope=potential @environments @flags:groupName=" + Flags.NAME)
-    @Syntax("<name> <environment> [--generator <generator[:id]> --adjust-spawn --biome <biome>]")
+    @Syntax("<name> <environment> [--generator <generator[:id]> --no-adjust-spawn --biome <biome> " +
+            "--skip-folder-check --generator-settings <json-settings>]")
    @Description("{@@mv-core.import.description}")
    void onImportCommand(
            MVCommandIssuer issuer,

-            @Conditions("worldname:scope=new")
+            // @Conditions("worldname:scope=new")
            @Syntax("<name>")
            @Description("{@@mv-core.import.name.description}")
            String worldName,

-            @Syntax("<env>")
+            @Syntax("<environment>")
            @Description("{@@mv-core.import.env.description}")
            World.Environment environment,

            @Optional
-            @Syntax("[--generator <generator[:id]> --adjust-spawn --biome <biome>]")
+            @Syntax("[--generator <generator[:id]> --no-adjust-spawn --biome <biome> " +
+                    "--skip-folder-check --generator-settings <json-settings>]")
            @Description("{@@mv-core.import.other.description}")
            String[] flagArray) {
        ParsedCommandFlags parsedFlags = flags.parse(flagArray);
@@ -67,7 +69,8 @@ class ImportCommand extends CoreCommand {
        worldManager.importWorld(ImportWorldOptions.worldName(worldName)
                        .biome(parsedFlags.flagValue(flags.biome, ""))
                        .environment(environment)
-                        .generator(parsedFlags.flagValue(flags.generator, String.class))
+                        .generator(parsedFlags.flagValue(flags.generator))
+                        .generatorSettings(parsedFlags.flagValue(flags.generatorSettings, ""))
                        .useSpawnAdjust(!parsedFlags.hasFlag(flags.noAdjustSpawn))
                        .doFolderCheck(!parsedFlags.hasFlag(flags.skipFolderCheck)))
                .onSuccess(newWorld -> {
@@ -110,6 +113,11 @@ class ImportCommand extends CoreCommand {
        private final CommandFlag skipFolderCheck = flag(CommandFlag.builder("--skip-folder-check")
                .addAlias("-f")
                .build());
+
+        private final CommandValueFlag<String> generatorSettings = flag(CommandValueFlag
+                .builder("--generator-settings", String.class)
+                .addAlias("-gs")
+                .build());
    }

    @Service
@@ -61,8 +61,8 @@ class InfoCommand extends CoreCommand {
    public void onInfoCommand(
            MVCommandIssuer issuer,

-            @Flags("resolve=issuerAware")
-            @Syntax("<world>")
+            @Flags("resolve=issuerAware,maxArgForAware=0")
+            @Syntax("[world]")
            @Description("{@@mv-core.info.description.world}")
            LoadedMultiverseWorld world,

@@ -87,6 +87,7 @@ class InfoCommand extends CoreCommand {
    private Map<String, String> getInfo(LoadedMultiverseWorld world) {
        Map<String, String> outMap = new LinkedHashMap<>();

+        outMap.put("World Key", world.getKey().toString());
        outMap.put("World Name", world.getName());
        outMap.put("World Alias", world.getAlias());
        outMap.put("World UID", world.getUID().toString());
@@ -103,6 +104,7 @@ class InfoCommand extends CoreCommand {
        outMap.put("World Type", world.getWorldType().map(WorldType::getName).getOrNull());
        outMap.put("Biome", world.getBiome());
        outMap.put("Generator", world.getGenerator());
+        outMap.put("Generator Settings",  world.getGeneratorSettings());
        outMap.put("Generate Structures", world.canGenerateStructures().map(String::valueOf).getOrNull());

        outMap.put("Auto Load", String.valueOf(world.isAutoLoad()));
@@ -112,13 +114,12 @@ class InfoCommand extends CoreCommand {
        outMap.put("World Scale", String.valueOf(world.getScale()));
        outMap.put("Weather Enabled", String.valueOf(world.isAllowWeather()));
        outMap.put("Allow Flight", String.valueOf(world.isAllowFlight()));
+        outMap.put("Grant Advancements", String.valueOf(world.isAllowAdvancementGrant()));
+        outMap.put("Auto Heal", String.valueOf(world.getAutoHeal()));
        outMap.put("Hunger Depletes", String.valueOf(world.isHunger()));
-        outMap.put("Keep Spawn In Memory", String.valueOf(world.isKeepSpawnInMemory()));
        outMap.put("PVP Enabled", String.valueOf(world.getPvp()));
        outMap.put("Portal Form", String.valueOf(world.getPortalForm()));
        outMap.put("Player Limit", String.valueOf(world.getPlayerLimit()));
-//        getAnimalSpawningInfo(outMap, world);
-//        getMonsterSpawningInfo(outMap, world);
        outMap.put("World Blacklist", String.join(", ", world.getWorldBlacklist()));

        return outMap;
@@ -135,30 +136,6 @@ class InfoCommand extends CoreCommand {
        }
    }

-//    private void getAnimalSpawningInfo(Map<String, String> outMap, MultiverseWorld world) {
-//        if (world.isSpawningAnimals()) {
-//            outMap.put("Spawning Animals", "ALL");
-//        } else {
-//            if (!world.getSpawningAnimalsExceptions().isEmpty()) {
-//                outMap.put("Spawning Animals", world.getSpawningAnimalsExceptions().toString());
-//            } else {
-//                outMap.put("Spawning Animals", "NONE");
-//            }
-//        }
-//    }
-//
-//    private void getMonsterSpawningInfo(Map<String, String> outMap, MultiverseWorld world) {
-//        if (world.isSpawningMonsters()) {
-//            outMap.put("Spawning Monsters", "ALL");
-//        } else {
-//            if (!world.getSpawningMonstersExceptions().isEmpty()) {
-//                outMap.put("Spawning Monsters", world.getSpawningMonstersExceptions().toString());
-//            } else {
-//                outMap.put("Spawning Monsters", "NONE");
-//            }
-//        }
-//    }
-
    @Service
    private static final class LegacyAlias extends InfoCommand implements LegacyAliasCommand {
        @Inject
@@ -54,12 +54,12 @@ class ListCommand extends CoreCommand {
    @Subcommand("list")
    @CommandPermission("multiverse.core.list.worlds")
    @CommandCompletion("@flags:groupName=" + Flags.NAME)
-    @Syntax("--filter [filter] --page [page] --raw")
+    @Syntax("[--filter <filter>] [--page <page>] [--raw]")
    @Description("{{@mv-core.list.description}}")
    public void onListCommand(
            MVCommandIssuer issuer,

-            @Syntax("[--filter <filter>] [--page <page>]")
+            @Syntax("[--filter <filter>] [--page <page>] [--raw]")
            @Description("Filters the list of worlds by the given regex and displays the given page.")
            String[] flagArray) {
        ParsedCommandFlags parsedFlags = flags.parse(flagArray);
@@ -16,8 +16,8 @@ import org.mvplugins.multiverse.core.command.LegacyAliasCommand;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
 import org.mvplugins.multiverse.core.command.flag.CommandFlag;
 import org.mvplugins.multiverse.core.command.flag.CommandFlagsManager;
+import org.mvplugins.multiverse.core.command.flag.FlagBuilder;
 import org.mvplugins.multiverse.core.command.flag.ParsedCommandFlags;
-import org.mvplugins.multiverse.core.command.flags.RemovePlayerFlags;
 import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
 import org.mvplugins.multiverse.core.world.MultiverseWorld;
@@ -38,8 +38,8 @@ class LoadCommand extends CoreCommand {

    @Subcommand("load")
    @CommandPermission("multiverse.core.load")
-    @CommandCompletion("@mvworlds:scope=unloaded")
-    @Syntax("<world>")
+    @CommandCompletion("@mvworlds:scope=unloaded @flags:groupName=" + Flags.NAME)
+    @Syntax("<world> [--skip-folder-check]")
    @Description("{@@mv-core.load.description}")
    void onLoadCommand(
            MVCommandIssuer issuer,
@@ -49,7 +49,7 @@ class LoadCommand extends CoreCommand {
            MultiverseWorld world,

            @Optional
-            @Syntax("[--remove-players]")
+            @Syntax("[--skip-folder-check]")
            @Description("")
            String[] flagArray) {
        ParsedCommandFlags parsedFlags = flags.parse(flagArray);
@@ -67,9 +67,9 @@ class LoadCommand extends CoreCommand {
    }

    @Service
-    private static final class Flags extends RemovePlayerFlags {
+    private static final class Flags extends FlagBuilder {

-        private static final String NAME = "mvunload";
+        private static final String NAME = "mvload";

        @Inject
        private Flags(@NotNull CommandFlagsManager flagsManager) {
@@ -0,0 +1,121 @@
+package org.mvplugins.multiverse.core.commands;
+
+import co.aikar.commands.annotation.CommandCompletion;
+import co.aikar.commands.annotation.CommandPermission;
+import co.aikar.commands.annotation.Description;
+import co.aikar.commands.annotation.Flags;
+import co.aikar.commands.annotation.Optional;
+import co.aikar.commands.annotation.Single;
+import co.aikar.commands.annotation.Subcommand;
+import co.aikar.commands.annotation.Syntax;
+import jakarta.inject.Inject;
+import org.bukkit.ChatColor;
+import org.jetbrains.annotations.NotNull;
+import org.jvnet.hk2.annotations.Service;
+import org.mvplugins.multiverse.core.command.MVCommandIssuer;
+import org.mvplugins.multiverse.core.command.flag.ParsedCommandFlags;
+import org.mvplugins.multiverse.core.command.flags.PageFilterFlags;
+import org.mvplugins.multiverse.core.display.ContentDisplay;
+import org.mvplugins.multiverse.core.display.filters.DefaultContentFilter;
+import org.mvplugins.multiverse.core.display.handlers.PagedSendHandler;
+import org.mvplugins.multiverse.core.display.parsers.MapContentProvider;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
+import org.mvplugins.multiverse.core.locale.message.Message;
+import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
+import org.mvplugins.multiverse.core.world.MultiverseWorld;
+import org.mvplugins.multiverse.core.world.WorldManager;
+
+import java.util.Locale;
+
+import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.replace;
+
+@Service
+@Subcommand("meta")
+final class MetaCommand extends CoreCommand {
+
+    private final WorldManager worldManager;
+    private final PageFilterFlags flags;
+
+    @Inject
+    MetaCommand(@NotNull WorldManager worldManager, @NotNull PageFilterFlags flags) {
+        this.worldManager = worldManager;
+        this.flags = flags;
+    }
+
+    @Subcommand("info")
+    @CommandPermission("multiverse.core.meta.info")
+    @CommandCompletion("@mvworlds:scope=both|@flags:resolveUntil=arg1,groupName=" + PageFilterFlags.NAME + " " +
+            "@flags:groupName=" + PageFilterFlags.NAME)
+    @Syntax("[world] [--page <page>] [--filter <filter>]")
+    @Description("{@@mv-core.meta.info.description}")
+    void infoCommand(
+            MVCommandIssuer issuer,
+
+            @Flags("resolve=issuerAware,maxArgForAware=0")
+            @Syntax("[world]")
+            @Description("{@@mv-core.meta.info.world.description}")
+            MultiverseWorld world,
+
+            @Optional
+            @Syntax("[--page <page>] [--filter <filter>]")
+            String[] flagArray
+    ) {
+        ParsedCommandFlags parsedFlags = flags.parse(flagArray);
+        ContentDisplay.create()
+                .addContent(MapContentProvider.forContent(world.getAllMeta())
+                        .withKeyColor(ChatColor.AQUA)
+                        .withValueColor(ChatColor.WHITE))
+                .withSendHandler(PagedSendHandler.create()
+                        .withHeader(Message.of(MVCorei18n.META_INFO_HEADER, replace("{world}").with(world.getName())))
+                        .noContentMessage(Message.of(MVCorei18n.META_INFO_NOCONTENT, replace("{world}").with(world.getName())))
+                        .withTargetPage(parsedFlags.flagValue(flags.page, 1))
+                        .withFilter(parsedFlags.flagValue(flags.filter, DefaultContentFilter.get())))
+                .send(issuer);
+    }
+
+    @Subcommand("modify")
+    @CommandPermission("multiverse.core.meta.modify")
+    @CommandCompletion("@mvworlds:scope=both set|remove @mvworldmetakey @empty")
+    @Syntax("[world] <set|remove> <key> [value]")
+    void modifyCommand(
+            MVCommandIssuer issuer,
+
+            @Flags("resolve=issuerAware,maxArgForAware=4")
+            @Syntax("[world]")
+            MultiverseWorld world,
+
+            @Syntax("<set|remove>")
+            String action,
+
+            @Syntax("<key>")
+            String key,
+
+            @Optional
+            @Single
+            @Syntax("[value]")
+            String value
+    ) {
+        switch (action.toLowerCase(Locale.ROOT)) {
+            case "set" -> world.setMeta(key, value)
+                    .onSuccess(ignore -> issuer.sendInfo(MVCorei18n.META_MODIFY_SET_SUCCESS,
+                                    replace("{key}").with(key),
+                                    replace("{value}").with(value),
+                                    Replace.WORLD.with(world.getName())))
+                    .onFailure(throwable -> issuer.sendError(MVCorei18n.META_MODIFY_SET_FAILURE,
+                            replace("{key}").with(key),
+                            replace("{value}").with(value),
+                            Replace.WORLD.with(world.getName()),
+                            Replace.ERROR.with(throwable)));
+            case "remove" -> world.removeMeta(key)
+                    .onSuccess(ignore -> issuer.sendInfo(MVCorei18n.META_MODIFY_REMOVE_SUCCESS,
+                            replace("{key}").with(key),
+                            Replace.WORLD.with(world.getName())))
+                    .onFailure(throwable -> issuer.sendError(MVCorei18n.META_MODIFY_REMOVE_FAILURE,
+                            replace("{key}").with(key),
+                            Replace.WORLD.with(world.getName()),
+                            Replace.ERROR.with(throwable)));
+            default -> issuer.sendError(MVCorei18n.META_MODIFY_INVALIDACTION, replace("{action}").with(action));
+        }
+        worldManager.saveWorldsConfig();
+    }
+}
@@ -49,12 +49,12 @@ class ModifyCommand extends CoreCommand {
            "@propsmodifyaction:notByIssuerForArg=arg1|@mvworldpropsname:byIssuerForArg=arg1 " +
            "@mvworldpropsname:notByIssuerForArg=arg1|@mvworldpropsvalue:byIssuerForArg=arg1 " +
            "@mvworldpropsvalue:notByIssuerForArg=arg1")
-    @Syntax("[world] <set|add|remove|reset> <property> <value>")
+    @Syntax("[world] <set|add|remove|reset> <property> [value]")
    @Description("{@@mv-core.modify.description}")
    void onModifyCommand(// SUPPRESS CHECKSTYLE: ParameterNumber
            MVCommandIssuer issuer,

-            @Flags("resolve=issuerAware")
+            @Flags("resolve=issuerAware,maxArgForAware=3")
            @Syntax("[world]")
            @Description("{@@mv-core.modify.world.description}")
            @NotNull MultiverseWorldValue worldValue,
@@ -94,28 +94,28 @@ class ModifyCommand extends CoreCommand {
        }

        StringPropertyHandle worldPropertyHandle = world.getStringPropertyHandle();
-        worldPropertyHandle.modifyPropertyString(issuer.getIssuer(), propertyName, propertyValue, action).onSuccess(ignore -> {
-            issuer.sendMessage(MVCorei18n.MODIFY_SUCCESS,
+        worldPropertyHandle.modifyPropertyString(issuer.getIssuer(), propertyName, propertyValue, action)
+                .andThenTry(worldManager::saveWorldsConfig)
+                .onSuccess(ignore -> issuer.sendMessage(MVCorei18n.MODIFY_SUCCESS,
                    replace("{action}").with(action.name().toLowerCase()),
                    replace("{property}").with(propertyName),
                    Replace.VALUE.with(worldPropertyHandle.getProperty(propertyName).getOrNull()),
-                    Replace.WORLD.with(world.getName()));
-            worldManager.saveWorldsConfig();
-        }).onFailure(exception -> {
-            if (propertyValue == null) {
-                issuer.sendMessage(MVCorei18n.MODIFY_FAILURE_NOVALUE,
-                        replace("{action}").with(action.name().toLowerCase()),
-                        replace("{property}").with(propertyName),
-                        Replace.WORLD.with(world.getName()),
-                        Replace.ERROR.with(exception.getMessage()));
-            } else {
-                issuer.sendMessage(MVCorei18n.MODIFY_FAILURE,
-                        replace("{action}").with(action.name().toLowerCase()),
-                        replace("{property}").with(propertyName),
-                        Replace.VALUE.with(propertyValue),
-                        Replace.WORLD.with(world.getName()),
-                        Replace.ERROR.with(exception.getMessage()));
-            }
+                    Replace.WORLD.with(world.getName())))
+                .onFailure(exception -> {
+                    if (propertyValue == null) {
+                        issuer.sendMessage(MVCorei18n.MODIFY_FAILURE_NOVALUE,
+                                replace("{action}").with(action.name().toLowerCase()),
+                                replace("{property}").with(propertyName),
+                                Replace.WORLD.with(world.getName()),
+                                Replace.ERROR.with(exception));
+                    } else {
+                        issuer.sendMessage(MVCorei18n.MODIFY_FAILURE,
+                                replace("{action}").with(action.name().toLowerCase()),
+                                replace("{property}").with(propertyName),
+                                Replace.VALUE.with(propertyValue),
+                                Replace.WORLD.with(world.getName()),
+                                Replace.ERROR.with(exception));
+                    }
        });
    }

@@ -10,12 +10,16 @@ import jakarta.inject.Inject;
 import org.bukkit.entity.SpawnCategory;
 import org.jvnet.hk2.annotations.Service;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
+import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
 import org.mvplugins.multiverse.core.utils.StringFormatter;
 import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
 import org.mvplugins.multiverse.core.world.entity.EntityPurger;

 import java.util.List;

+import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.replace;
+
@Service
 final class PurgeAllEntitiesCommand extends CoreCommand {

@@ -33,7 +37,7 @@ final class PurgeAllEntitiesCommand extends CoreCommand {
    void onPurgeAllEntitiesCommand(
            MVCommandIssuer issuer,

-            @Flags("resolve=issuerAware")
+            @Flags("resolve=issuerAware,maxArgForAware=1")
            @Syntax("[world]")
            LoadedMultiverseWorld world,

@@ -43,12 +47,16 @@ final class PurgeAllEntitiesCommand extends CoreCommand {
    ) {
        if (spawnCategories == null || spawnCategories.length == 0) {
            int purgeCount = entityPurger.purgeAllEntities(world);
-            issuer.sendMessage("Successfully purged " + purgeCount + " entities in world " + world.getName() + ".");
+            issuer.sendMessage(MVCorei18n.PURGEALLENTITIES_SUCCESS,
+                    Replace.COUNT.with(purgeCount),
+                    Replace.WORLD.with(world.getName()));
            return;
        }

        int purgeCount = entityPurger.purgeEntities(world, spawnCategories);
-        issuer.sendMessage("Successfully purged " + purgeCount + " entities in world " + world.getName() +
-                " for spawn categories " + StringFormatter.join(List.of(spawnCategories), ", ") + ".");
+        issuer.sendMessage(MVCorei18n.PURGEALLENTITIES_SUCCESS_CATEGORIES,
+                Replace.COUNT.with(purgeCount),
+                Replace.WORLD.with(world.getName()),
+                replace("{categories}").with(StringFormatter.join(List.of(spawnCategories), ", ")));
    }
 }
@@ -8,6 +8,8 @@ import co.aikar.commands.annotation.Syntax;
 import jakarta.inject.Inject;
 import org.jvnet.hk2.annotations.Service;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
+import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
 import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
 import org.mvplugins.multiverse.core.world.entity.EntityPurger;

@@ -28,11 +30,13 @@ final class PurgeEntitiesCommand extends CoreCommand {
    void onPurgeEntityCommand(
            MVCommandIssuer issuer,

-            @Flags("resolve=issuerAware")
+            @Flags("resolve=issuerAware,maxArgForAware=0")
            @Syntax("[world]")
            LoadedMultiverseWorld world
    ) {
        int purgeCount = entityPurger.purgeEntities(world);
-        issuer.sendMessage("Successfully purged " + purgeCount + " entities in world " + world.getName() + ".");
+        issuer.sendMessage(MVCorei18n.PURGEENTITIES_SUCCESS,
+                Replace.COUNT.with(purgeCount),
+                Replace.WORLD.with(world.getName()));
    }
 }
@@ -2,6 +2,7 @@ package org.mvplugins.multiverse.core.commands;

 import java.util.Collections;
 import java.util.List;
+import java.util.Objects;

 import co.aikar.commands.ACFUtil;
 import co.aikar.commands.annotation.CommandAlias;
@@ -23,9 +24,12 @@ import org.mvplugins.multiverse.core.command.flag.CommandFlag;
 import org.mvplugins.multiverse.core.command.flag.CommandFlagsManager;
 import org.mvplugins.multiverse.core.command.flag.CommandValueFlag;
 import org.mvplugins.multiverse.core.command.flag.ParsedCommandFlags;
-import org.mvplugins.multiverse.core.command.flags.RemovePlayerFlags;
+import org.mvplugins.multiverse.core.command.flags.RemovePlayerDestinationFlags;
 import org.mvplugins.multiverse.core.command.queue.CommandQueueManager;
 import org.mvplugins.multiverse.core.command.queue.CommandQueuePayload;
+import org.mvplugins.multiverse.core.destination.DestinationInstance;
+import org.mvplugins.multiverse.core.destination.DestinationsProvider;
+import org.mvplugins.multiverse.core.destination.core.WorldDestination;
 import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.locale.message.Message;
 import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
@@ -65,7 +69,8 @@ class RegenCommand extends CoreCommand {
    @Subcommand("regen")
    @CommandPermission("multiverse.core.regen")
    @CommandCompletion("@mvworlds:scope=loaded @flags:groupName=" + Flags.NAME)
-    @Syntax("<world> [--seed [seed] --reset-world-config --reset-gamerules --reset-world-border --remove-players]")
+    @Syntax("<world> [--seed [seed]] [--reset-world-config] [--reset-gamerules] [--reset-world-border] " +
+            "[--keep-files <files>] [--remove-players [destination]]")
    @Description("{@@mv-core.regen.description}")
    void onRegenCommand(
            MVCommandIssuer issuer,
@@ -75,7 +80,8 @@ class RegenCommand extends CoreCommand {
            LoadedMultiverseWorld world,

            @Optional
-            @Syntax("[--seed [seed] --reset-world-config --reset-gamerules --reset-world-border --remove-players]")
+            @Syntax("[--seed [seed]] [--reset-world-config] [--reset-gamerules] [--reset-world-border] " +
+                    "[--keep-files <files>] [--remove-players [destination]]")
            @Description("{@@mv-core.regen.other.description}")
            String[] flagArray) {
        ParsedCommandFlags parsedFlags = flags.parse(flagArray);
@@ -83,7 +89,7 @@ class RegenCommand extends CoreCommand {
        commandQueueManager.addToQueue(CommandQueuePayload
                .issuer(issuer)
                .action(() -> runRegenCommand(issuer, world, parsedFlags))
-                .prompt(Message.of(MVCorei18n.REGEN_PROMPT, "",
+                .prompt(Message.of(MVCorei18n.REGEN_PROMPT,
                        Replace.WORLD.with(world.getName()))));
    }

@@ -91,14 +97,15 @@ class RegenCommand extends CoreCommand {
        issuer.sendInfo(MVCorei18n.REGEN_REGENERATING, Replace.WORLD.with(world.getName()));
        List<Player> worldPlayers = world.getPlayers().getOrElse(Collections.emptyList());

-        var future = parsedFlags.hasFlag(flags.removePlayers)
-                ? playerWorldTeleporter.removeFromWorld(world)
+        DestinationInstance<?, ?> removeToDestination = parsedFlags.flagValue(flags.removePlayers);
+        var future = Objects.nonNull(removeToDestination)
+                ? playerWorldTeleporter.transferAllFromWorldToDestination(world,  removeToDestination)
                : AsyncAttemptsAggregate.emptySuccess();

        // todo: using future will hide stacktrace
        future.onSuccess(() -> worldTickDeferrer
                        .deferWorldTick(() -> doWorldRegening(issuer, world, parsedFlags, worldPlayers)))
-                .onFailure(() -> issuer.sendError("Failed to teleport one or more players out of the world!"));
+                .onFailure(() -> issuer.sendError(MVCorei18n.GENERIC_TELEPORTPLAYERS_FAILED));
    }

    private void doWorldRegening(
@@ -128,13 +135,18 @@ class RegenCommand extends CoreCommand {
    }

    @Service
-    private static final class Flags extends RemovePlayerFlags {
+    private static final class Flags extends RemovePlayerDestinationFlags {

        private static final String NAME = "mvregen";

        @Inject
-        private Flags(@NotNull CommandFlagsManager flagsManager) {
-            super(NAME, flagsManager);
+        private Flags(
+                @NotNull CommandFlagsManager flagsManager,
+                @NotNull WorldManager worldManager,
+                @NotNull DestinationsProvider destinationsProvider,
+                @NotNull WorldDestination worldDestination
+        ) {
+            super(NAME, flagsManager, worldManager, destinationsProvider, worldDestination);
        }

        private final CommandValueFlag<String> seed = flag(CommandValueFlag.builder("--seed", String.class)
@@ -14,11 +14,13 @@ import org.jvnet.hk2.annotations.Service;

 import org.mvplugins.multiverse.core.command.LegacyAliasCommand;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
-import org.mvplugins.multiverse.core.command.MVCommandManager;
 import org.mvplugins.multiverse.core.command.flag.CommandFlag;
 import org.mvplugins.multiverse.core.command.flag.CommandFlagsManager;
 import org.mvplugins.multiverse.core.command.flag.ParsedCommandFlags;
-import org.mvplugins.multiverse.core.command.flags.RemovePlayerFlags;
+import org.mvplugins.multiverse.core.command.flags.RemovePlayerDestinationFlags;
+import org.mvplugins.multiverse.core.destination.DestinationInstance;
+import org.mvplugins.multiverse.core.destination.DestinationsProvider;
+import org.mvplugins.multiverse.core.destination.core.WorldDestination;
 import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
 import org.mvplugins.multiverse.core.utils.result.AsyncAttemptsAggregate;
@@ -27,6 +29,8 @@ import org.mvplugins.multiverse.core.world.WorldManager;
 import org.mvplugins.multiverse.core.world.helpers.PlayerWorldTeleporter;
 import org.mvplugins.multiverse.core.world.options.RemoveWorldOptions;

+import java.util.Objects;
+
@Service
 class RemoveCommand extends CoreCommand {

@@ -48,7 +52,7 @@ class RemoveCommand extends CoreCommand {
    @Subcommand("remove")
    @CommandPermission("multiverse.core.remove")
    @CommandCompletion("@mvworlds:scope=both @flags:groupName=" + Flags.NAME)
-    @Syntax("<world>")
+    @Syntax("<world> [--remove-players [destination]] [--no-unload-bukkit-world] [--no-save]")
    @Description("{@@mv-core.remove.description}")
    void onRemoveCommand(
            MVCommandIssuer issuer,
@@ -58,17 +62,20 @@ class RemoveCommand extends CoreCommand {
            MultiverseWorld world,

            @Optional
-            @Syntax("[--remove-players]")
+            @Syntax("[--remove-players [destination]] [--no-unload-bukkit-world] [--no-save]")
            @Description("")
            String[] flagArray) {
        ParsedCommandFlags parsedFlags = flags.parse(flagArray);

-        var future = parsedFlags.hasFlag(flags.removePlayers)
-                ? worldManager.getLoadedWorld(world).map(playerWorldTeleporter::removeFromWorld).getOrElse(AsyncAttemptsAggregate::emptySuccess)
+        DestinationInstance<?, ?> removeToDestination = parsedFlags.flagValue(flags.removePlayers);
+        var future = Objects.nonNull(removeToDestination)
+                ? world.asLoadedWorld()
+                  .map(loadedWorld -> playerWorldTeleporter.transferAllFromWorldToDestination(loadedWorld, removeToDestination))
+                  .getOrElse(AsyncAttemptsAggregate::emptySuccess)
                : AsyncAttemptsAggregate.emptySuccess();

        future.onSuccess(() -> doWorldRemoving(issuer, world, parsedFlags))
-                .onFailure(() -> issuer.sendError("Failed to teleport one or more players out of the world!"));
+                .onFailure(() -> issuer.sendError(MVCorei18n.GENERIC_TELEPORTPLAYERS_FAILED));
    }

    private void doWorldRemoving(MVCommandIssuer issuer, MultiverseWorld world, ParsedCommandFlags parsedFlags) {
@@ -85,13 +92,18 @@ class RemoveCommand extends CoreCommand {
    }

    @Service
-    private static final class Flags extends RemovePlayerFlags {
+    private static final class Flags extends RemovePlayerDestinationFlags {

        private static final String NAME = "mvremove";

        @Inject
-        private Flags(@NotNull CommandFlagsManager flagsManager) {
-            super(NAME, flagsManager);
+        private Flags(
+                @NotNull CommandFlagsManager flagsManager,
+                @NotNull WorldManager worldManager,
+                @NotNull DestinationsProvider destinationsProvider,
+                @NotNull WorldDestination worldDestination
+        ) {
+            super(NAME, flagsManager, worldManager, destinationsProvider, worldDestination);
        }

        private final CommandFlag noUnloadBukkitWorld = flag(CommandFlag.builder("--no-unload-bukkit-world")
@@ -40,12 +40,12 @@ class SetSpawnCommand extends CoreCommand {
    @Subcommand("setspawn")
    @CommandPermission("multiverse.core.spawn.set")
    @CommandCompletion("@flags:groupName=" + UnsafeFlags.NAME + " @flags:resolveUntil=arg1,groupName=" + UnsafeFlags.NAME)
-    @Syntax("[worldname:x,y,z[,pitch,yaw]] [--unsafe]")
+    @Syntax("[worldname:x,y,z[,yaw,pitch]] [--unsafe]")
    @Description("{@@mv-core.setspawn.description}")
    void onSetSpawnCommand(
            MVCommandIssuer issuer,

-            @Syntax("[worldname:x,y,z[,pitch,yaw]]")
+            @Syntax("[worldname:x,y,z[,yaw,pitch]]")
            @Description("{@@mv-core.setspawn.location.description}")
            PlayerLocation playerLocation,

@@ -63,7 +63,7 @@ class SetSpawnCommand extends CoreCommand {

        worldManager.getLoadedWorld(location.getWorld())
                .peek(mvWorld -> mvWorld.setSpawnLocation(location)
-                        .flatMap(ignore -> worldManager.saveWorldsConfig())
+                        .andThenTry(worldManager::saveWorldsConfig)
                        .onSuccess(ignore -> issuer.sendMessage(MVCorei18n.SETSPAWN_SUCCESS,
                                Replace.WORLD.with(mvWorld.getName()),
                                Replace.LOCATION.with(prettyLocation(location))))
@@ -62,7 +62,7 @@ final class SpawnCommand extends CoreCommand {
    @CommandPermission("@mvspawn")
    @CommandCompletion("@playersarray:checkPermissions=@mvspawnother|@flags:resolveUntil=arg1,groupName=" + UnsafeFlags.NAME
            + " @flags:groupName=" + UnsafeFlags.NAME)
-    @Syntax("[player]")
+    @Syntax("[player] [--unsafe]")
    @Description("{@@mv-core.spawn.description}")
    void onSpawnTpCommand(
            MVCommandIssuer issuer,
@@ -88,11 +88,11 @@ final class SpawnCommand extends CoreCommand {
                                        List<Entity> entities, boolean checkSafety) {
        LoadedMultiverseWorld mvWorld = worldManager.getLoadedWorld(world).getOrNull();
        if (mvWorld == null) {
-            issuer.sendMessage("The world '" + world.getName() + "' is not a multiverse world!");
+            issuer.sendMessage(MVCorei18n.SPAWN_NOTMVWORLD, Replace.WORLD.with(world.getName()));
            return;
        }
        if (!permissionsChecker.checkSpawnPermission(issuer.getIssuer(), entities, mvWorld)) {
-            issuer.sendMessage("You do not have permission to use this command in this world!");
+            issuer.sendMessage(MVCorei18n.SPAWN_NOPERMISSION);
            return;
        }

@@ -119,7 +119,7 @@ final class SpawnCommand extends CoreCommand {
                                ? Message.of(MVCorei18n.GENERIC_YOU)
                                : Message.of(entity.getName())),
                        Replace.WORLD.with(mvWorld.getName()),
-                        Replace.REASON.with(failure.getFirst().getFailureMessage())));
+                        Replace.REASON.with(failure.get(0).getFailureMessage())));
    }

    private void handleMultiTeleport(MVCommandIssuer issuer, LoadedMultiverseWorld mvWorld,
@@ -129,16 +129,18 @@ final class SpawnCommand extends CoreCommand {
                .checkSafety(checkSafety)
                .teleport(entities)
                .onSuccessCount(successCount ->  issuer.sendMessage(MVCorei18n.SPAWN_SUCCESS,
-                        Replace.PLAYER.with(successCount + " players"), //todo: replace this with localised "{count} players"
+                        Replace.PLAYER.with(Message.of(MVCorei18n.GENERIC_PLAYERCOUNT,
+                                Replace.COUNT.with(successCount))),
                        Replace.WORLD.with(mvWorld.getName())))
                .onFailureCount(reasonsCountMap -> {
                    for (var entry : reasonsCountMap.entrySet()) {
                        Logging.finer("Failed to teleport %s players to %s: %s",
                                entry.getValue(), mvWorld.getName(), entry.getKey());
                        issuer.sendError(MVCorei18n.SPAWN_FAILED,
-                                Replace.PLAYER.with(entry.getValue() + " players"),
+                                Replace.PLAYER.with(Message.of(MVCorei18n.GENERIC_PLAYERCOUNT,
+                                        Replace.COUNT.with(entry.getValue()))),
                                Replace.WORLD.with(mvWorld.getName()),
-                                Replace.REASON.with(entry.getKey().getMessageKey()));
+                                Replace.REASON.with(Message.of(entry.getKey())));
                    }
                });
    }
@@ -19,7 +19,10 @@ import org.jvnet.hk2.annotations.Service;

 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
 import org.mvplugins.multiverse.core.command.context.issueraware.PlayerArrayValue;
+import org.mvplugins.multiverse.core.command.flag.CommandFlag;
+import org.mvplugins.multiverse.core.command.flag.CommandFlagsManager;
 import org.mvplugins.multiverse.core.command.flag.ParsedCommandFlags;
+import org.mvplugins.multiverse.core.command.flags.PageFilterFlags;
 import org.mvplugins.multiverse.core.command.flags.UnsafeFlags;
 import org.mvplugins.multiverse.core.config.CoreConfig;
 import org.mvplugins.multiverse.core.destination.DestinationInstance;
@@ -35,14 +38,14 @@ final class TeleportCommand extends CoreCommand {
    private final CoreConfig config;
    private final CorePermissionsChecker permissionsChecker;
    private final AsyncSafetyTeleporter safetyTeleporter;
-    private final UnsafeFlags flags;
+    private final Flags flags;

    @Inject
    TeleportCommand(
            @NotNull CoreConfig config,
            @NotNull CorePermissionsChecker permissionsChecker,
            @NotNull AsyncSafetyTeleporter safetyTeleporter,
-            @NotNull UnsafeFlags flags
+            @NotNull Flags flags
    ) {
        this.config = config;
        this.permissionsChecker = permissionsChecker;
@@ -54,14 +57,14 @@ final class TeleportCommand extends CoreCommand {
    @Subcommand("teleport|tp")
    @CommandPermission("@mvteleport")
    @CommandCompletion("@playersarray:checkPermissions=@mvteleportother|@destinations:byIssuerForArg=arg1 "
-            + "@destinations:notByIssuerForArg=arg1|@flags:byIssuerForArg=arg1,groupName=" + UnsafeFlags.NAME + " "
-            + "@flags:notByIssuerForArg=arg1,groupName=" + UnsafeFlags.NAME)
-    @Syntax("[player] <destination> [--unsafe]")
+            + "@destinations:notByIssuerForArg=arg1|@flags:byIssuerForArg=arg1,groupName=" + Flags.NAME + " "
+            + "@flags:notByIssuerForArg=arg1,groupName=" + Flags.NAME)
+    @Syntax("[player] <destination> [--unsafe --silent]")
    @Description("{@@mv-core.teleport.description}")
    void onTeleportCommand(
            MVCommandIssuer issuer,

-            @Flags("resolve=issuerAware")
+            @co.aikar.commands.annotation.Flags("resolve=issuerAware,maxArgForAware=1")
            @Syntax("[player]")
            @Description("{@@mv-core.teleport.player.description}")
            PlayerArrayValue playersValue,
@@ -71,7 +74,7 @@ final class TeleportCommand extends CoreCommand {
            DestinationInstance<?, ?> destination,

            @Optional
-            @Syntax("[--unsafe]")
+            @Syntax("[--unsafe --silent]")
            @Description("")
            String[] flagArray) {
        Player[] players = playersValue.value();
@@ -91,10 +94,9 @@ final class TeleportCommand extends CoreCommand {
                                      DestinationInstance<?, ?> destination,
                                      ParsedCommandFlags parsedFlags) {
        if (!permissionsChecker.checkTeleportPermission(issuer.getIssuer(), player, destination)) {
-            // TODO localize
-            issuer.sendMessage(player == issuer.getPlayer()
-                    ? "You do not have permission to teleport yourself!"
-                    : "You do not have permission to teleport other players!");
+            issuer.sendError(player == issuer.getPlayer()
+                    ? MVCorei18n.TELEPORT_NOPERMISSION_SELF
+                    : MVCorei18n.TELEPORT_NOPERMISSION_OTHER);
            return;
        }

@@ -103,16 +105,21 @@ final class TeleportCommand extends CoreCommand {
                .checkSafety(!parsedFlags.hasFlag(flags.unsafe) && destination.checkTeleportSafety())
                .passengerMode(config.getPassengerMode())
                .teleportSingle(player)
-                .onSuccess(() -> issuer.sendInfo(MVCorei18n.TELEPORT_SUCCESS,
-                        Replace.PLAYER.with(getYouOrName(issuer, player)),
-                        Replace.DESTINATION.with(destination.toString())))
+                .onSuccess(() -> {
+                    if (parsedFlags.hasFlag(flags.silent)) {
+                        return;
+                    }
+                    issuer.sendInfo(MVCorei18n.TELEPORT_SUCCESS,
+                            Replace.PLAYER.with(getYouOrName(issuer, player)),
+                            Replace.DESTINATION.with(destination.getDisplayMessage()));
+                })
                .onFailureCount(reasonsCountMap -> {
                    for (var entry : reasonsCountMap.entrySet()) {
                        Logging.finer("Failed to teleport %s players to %s: %s",
                                entry.getValue(), destination, entry.getKey());
                        issuer.sendError(MVCorei18n.TELEPORT_FAILED,
                                Replace.PLAYER.with(player.getName()),
-                                Replace.DESTINATION.with(destination.toString()),
+                                Replace.DESTINATION.with(destination.getDisplayMessage()),
                                Replace.REASON.with(Message.of(entry.getKey())));
                    }
                });
@@ -126,8 +133,7 @@ final class TeleportCommand extends CoreCommand {
                                         DestinationInstance<?, ?> destination,
                                         ParsedCommandFlags parsedFlags) {
        if (!permissionsChecker.checkTeleportPermission(issuer.getIssuer(), Arrays.asList(players), destination)) {
-            // TODO localize
-            issuer.sendMessage("You do not have permission to teleport all these players!");
+            issuer.sendError(MVCorei18n.TELEPORT_NOPERMISSION_ALL);
            return;
        }

@@ -136,18 +142,40 @@ final class TeleportCommand extends CoreCommand {
                .checkSafety(!parsedFlags.hasFlag(flags.unsafe) && destination.checkTeleportSafety())
                .passengerMode(config.getPassengerMode())
                .teleport(List.of(players))
-                .onSuccessCount(successCount -> issuer.sendInfo(MVCorei18n.TELEPORT_SUCCESS,
-                        Replace.PLAYER.with(successCount + " players"),
-                        Replace.DESTINATION.with(destination.toString())))
+                .onSuccessCount(successCount -> {
+                    if (parsedFlags.hasFlag(flags.silent)) {
+                        return;
+                    }
+                    issuer.sendInfo(MVCorei18n.TELEPORT_SUCCESS,
+                            Replace.PLAYER.with(Message.of(MVCorei18n.GENERIC_PLAYERCOUNT,
+                                    Replace.COUNT.with(successCount))),
+                            Replace.DESTINATION.with(destination.getDisplayMessage()));
+                })
                .onFailureCount(reasonsCountMap -> {
                    for (var entry : reasonsCountMap.entrySet()) {
                        Logging.finer("Failed to teleport %s players to %s: %s",
                                entry.getValue(), destination, entry.getKey());
                        issuer.sendError(MVCorei18n.TELEPORT_FAILED,
-                                Replace.PLAYER.with(entry.getValue() + " players"),
-                                Replace.DESTINATION.with(destination.toString()),
+                                Replace.PLAYER.with(Message.of(MVCorei18n.GENERIC_PLAYERCOUNT,
+                                        Replace.COUNT.with(entry.getValue()))),
+                                Replace.DESTINATION.with(destination.getDisplayMessage()),
                                Replace.REASON.with(Message.of(entry.getKey())));
                    }
                });
    }
+
+    @Service
+    private static final class Flags extends UnsafeFlags {
+
+        private static final String NAME = "mvteleport";
+
+        @Inject
+        private Flags(@NotNull CommandFlagsManager flagsManager) {
+            super(NAME, flagsManager);
+        }
+
+        private final CommandFlag silent = flag(CommandFlag.builder("--silent")
+                .addAlias("-s")
+                .build());
+    }
 }
@@ -14,11 +14,13 @@ import org.jvnet.hk2.annotations.Service;

 import org.mvplugins.multiverse.core.command.LegacyAliasCommand;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
-import org.mvplugins.multiverse.core.command.MVCommandManager;
 import org.mvplugins.multiverse.core.command.flag.CommandFlag;
 import org.mvplugins.multiverse.core.command.flag.CommandFlagsManager;
 import org.mvplugins.multiverse.core.command.flag.ParsedCommandFlags;
-import org.mvplugins.multiverse.core.command.flags.RemovePlayerFlags;
+import org.mvplugins.multiverse.core.command.flags.RemovePlayerDestinationFlags;
+import org.mvplugins.multiverse.core.destination.DestinationInstance;
+import org.mvplugins.multiverse.core.destination.DestinationsProvider;
+import org.mvplugins.multiverse.core.destination.core.WorldDestination;
 import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
 import org.mvplugins.multiverse.core.utils.result.AsyncAttemptsAggregate;
@@ -27,6 +29,8 @@ import org.mvplugins.multiverse.core.world.WorldManager;
 import org.mvplugins.multiverse.core.world.helpers.PlayerWorldTeleporter;
 import org.mvplugins.multiverse.core.world.options.UnloadWorldOptions;

+import java.util.Objects;
+
@Service
 class UnloadCommand extends CoreCommand {

@@ -48,7 +52,7 @@ class UnloadCommand extends CoreCommand {
    @Subcommand("unload")
    @CommandPermission("multiverse.core.unload")
    @CommandCompletion("@mvworlds @flags:groupName=" + Flags.NAME)
-    @Syntax("<world>")
+    @Syntax("<world> [--remove-players [destination]] [--no-unload-bukkit-world] [--no-save]")
    @Description("{@@mv-core.unload.description}")
    void onUnloadCommand(
            MVCommandIssuer issuer,
@@ -58,19 +62,20 @@ class UnloadCommand extends CoreCommand {
            LoadedMultiverseWorld world,

            @Optional
-            @Syntax("[--remove-players] [--no-save]")
+            @Syntax("[--remove-players [destination]] [--no-unload-bukkit-world] [--no-save]")
            @Description("{@@mv-core.gamerules.description.page}")
            String[] flagArray) {
        ParsedCommandFlags parsedFlags = flags.parse(flagArray);

        issuer.sendInfo(MVCorei18n.UNLOAD_UNLOADING, Replace.WORLD.with(world.getAliasOrName()));

-        var future = parsedFlags.hasFlag(flags.removePlayers)
-                ? playerWorldTeleporter.removeFromWorld(world)
+        DestinationInstance<?, ?> removeToDestination = parsedFlags.flagValue(flags.removePlayers);
+        var future = Objects.nonNull(removeToDestination)
+                ? playerWorldTeleporter.transferAllFromWorldToDestination(world, removeToDestination)
                : AsyncAttemptsAggregate.emptySuccess();

        future.onSuccess(() -> doWorldUnloading(issuer, world, parsedFlags))
-                .onFailure(() -> issuer.sendError("Failed to teleport one or more players out of the world!"));
+                .onFailure(() -> issuer.sendError(MVCorei18n.GENERIC_TELEPORTPLAYERS_FAILED));
    }

    private void doWorldUnloading(MVCommandIssuer issuer, LoadedMultiverseWorld world, ParsedCommandFlags parsedFlags) {
@@ -88,13 +93,18 @@ class UnloadCommand extends CoreCommand {
    }

    @Service
-    private static final class Flags extends RemovePlayerFlags {
+    private static final class Flags extends RemovePlayerDestinationFlags {

        private static final String NAME = "mvunload";

        @Inject
-        private Flags(@NotNull CommandFlagsManager flagsManager) {
-            super(NAME, flagsManager);
+        private Flags(
+                @NotNull CommandFlagsManager flagsManager,
+                @NotNull WorldManager worldManager,
+                @NotNull DestinationsProvider destinationsProvider,
+                @NotNull WorldDestination worldDestination
+        ) {
+            super(NAME, flagsManager, worldManager, destinationsProvider, worldDestination);
        }

        private final CommandFlag noUnloadBukkitWorld = flag(CommandFlag.builder("--no-unload-bukkit-world")
@@ -74,12 +74,12 @@ class WhoCommand extends CoreCommand {
    @Subcommand("who")
    @CommandPermission("multiverse.core.list.who")
    @CommandCompletion("@mvworlds:scope=both @flags:groupName=" + PageFilterFlags.NAME)
-    @Syntax("<world> [--page <page>] [--filter <filter>]")
+    @Syntax("[world] [--page <page>] [--filter <filter>]")
    @Description("{@@mv-core.who.description}")
    void onWhoCommand(
            MVCommandIssuer issuer,
-            @Flags("resolve=issuerAware")
-            @Syntax("<world>")
+            @Flags("resolve=issuerAware,maxArgForAware=0")
+            @Syntax("[world]")
            @Description("{@@mv-core.who.world.description}")
            LoadedMultiverseWorld inputtedWorld,

@@ -12,8 +12,11 @@ import org.jvnet.hk2.annotations.Service;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
 import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
+import org.mvplugins.multiverse.core.utils.compatibility.WorldBorderCompatibility;
+import org.mvplugins.multiverse.core.utils.tick.TickDuration;
 import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;

+import java.time.temporal.ChronoUnit;
 import java.util.function.Consumer;

 import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.replace;
@@ -33,28 +36,27 @@ final class WorldBorderCommand extends CoreCommand {
            @Optional
            @Default("0")
            @Syntax("[time]")
-            int time,
+            TickDuration duration,

-            @Flags("resolve=issuerAware")
+            @Flags("resolve=issuerAware,maxArgForAware=0")
            @Syntax("[world]")
            LoadedMultiverseWorld world
    ) {
-        worldBorderAction(issuer, world, worldBorder -> {
-            onWorldBorderSet(issuer, worldBorder.getSize() + size, time, world);
-        });
+        worldBorderAction(issuer, world, worldBorder ->
+                onWorldBorderSet(issuer, worldBorder.getSize() + size, duration, world));
    }

    @Subcommand("center")
    void onWorldBorderCenter(
            MVCommandIssuer issuer,

-            @Syntax("[x]")
+            @Syntax("<x>")
            double x,

-            @Syntax("[z]")
+            @Syntax("<z>")
            double z,

-            @Flags("resolve=issuerAware")
+            @Flags("resolve=issuerAware,maxArgForAware=0")
            @Syntax("[world]")
            LoadedMultiverseWorld world
    ) {
@@ -79,7 +81,7 @@ final class WorldBorderCommand extends CoreCommand {
            @Syntax("<damage>")
            double damage,

-            @Flags("resolve=issuerAware")
+            @Flags("resolve=issuerAware,maxArgForAware=0")
            @Syntax("[world]")
            LoadedMultiverseWorld world
    ) {
@@ -103,7 +105,7 @@ final class WorldBorderCommand extends CoreCommand {
            @Syntax("<distance>")
            double distance,

-            @Flags("resolve=issuerAware")
+            @Flags("resolve=issuerAware,maxArgForAware=0")
            @Syntax("[world]")
            LoadedMultiverseWorld world
    ) {
@@ -124,7 +126,7 @@ final class WorldBorderCommand extends CoreCommand {
    void onWorldBorderGet(
            MVCommandIssuer issuer,

-            @Flags("resolve=issuerAware")
+            @Flags("resolve=issuerAware,maxArgForAware=0")
            @Syntax("[world]")
            LoadedMultiverseWorld world
    ) {
@@ -145,9 +147,9 @@ final class WorldBorderCommand extends CoreCommand {
            @Optional
            @Default("0")
            @Syntax("[time]")
-            int time,
+            TickDuration duration,

-            @Flags("resolve=issuerAware")
+            @Flags("resolve=issuerAware,maxArgForAware=0")
            @Syntax("[world]")
            LoadedMultiverseWorld world
    ) {
@@ -158,15 +160,18 @@ final class WorldBorderCommand extends CoreCommand {
                        Replace.WORLD.with(world.getAliasOrName()));
                return;
            }
-            worldBorder.setSize(size, time);
-            if (time <= 0) {
+            if (!WorldBorderCompatibility.supportsChangeSizeInTicks() && !duration.isExactTo(ChronoUnit.SECONDS)) {
+                setRoundOffError(issuer, duration);
+            }
+            WorldBorderCompatibility.changeSizeDuration(worldBorder, size, duration);
+            if (duration.toTicks() <= 0) {
                issuer.sendMessage(MVCorei18n.WORLDBORDER_SET_IMMEDIATE,
                        replace("{size}").with(worldBorder.getSize()),
                        Replace.WORLD.with(world.getAliasOrName()));
            } else {
                issuer.sendMessage(previousSize > size ? MVCorei18n.WORLDBORDER_SET_GROWING : MVCorei18n.WORLDBORDER_SET_SHRINKING,
                        replace("{size}").with(size),
-                        replace("{time}").with(time),
+                        replace("{time}").with(String.format("%.2f", duration.toSeconds())),
                        Replace.WORLD.with(world.getAliasOrName()));
            }
        });
@@ -179,7 +184,7 @@ final class WorldBorderCommand extends CoreCommand {
            @Syntax("<distance>")
            int distance,

-            @Flags("resolve=issuerAware")
+            @Flags("resolve=issuerAware,maxArgForAware=0")
            @Syntax("[world]")
            LoadedMultiverseWorld world
    ) {
@@ -201,27 +206,36 @@ final class WorldBorderCommand extends CoreCommand {
            MVCommandIssuer issuer,

            @Syntax("<time>")
-            int time,
+            TickDuration duration,

-            @Flags("resolve=issuerAware")
+            @Flags("resolve=issuerAware,maxArgForAware=0")
            @Syntax("[world]")
            LoadedMultiverseWorld world
    ) {
        worldBorderAction(issuer, world, worldBorder -> {
-            if (worldBorder.getWarningTime() == time) {
+            if (WorldBorderCompatibility.getWarningTimeTicks(worldBorder) == duration.toTicks()) {
                issuer.sendMessage(MVCorei18n.WORLDBORDER_WARNINGTIME_NOTHINGCHANGED,
                        Replace.WORLD.with(world.getAliasOrName()));
                return;
            }
-            worldBorder.setWarningTime(time);
+            if (!WorldBorderCompatibility.supportsSetWarningTimeInTicks() && !duration.isExactTo(ChronoUnit.SECONDS)) {
+                setRoundOffError(issuer, duration);
+            }
+            WorldBorderCompatibility.setWarningTimeDuration(worldBorder, duration);
            issuer.sendMessage(MVCorei18n.WORLDBORDER_WARNINGTIME_SUCCESS,
-                    replace("{time}").with(worldBorder.getWarningTime()),
+                    replace("{time}").with(String.format("%.2f", WorldBorderCompatibility.getWarningTime(worldBorder))),
                    Replace.WORLD.with(world.getAliasOrName()));
        });
    }

+    private void setRoundOffError(MVCommandIssuer issuer, TickDuration duration) {
+        issuer.sendError(MVCorei18n.WORLDBORDER_ROUNDOFF_WARNING,
+                replace("{fromTime}").with(String.format("%.2f", duration.toSeconds())),
+                replace("{toTime}").with(Math.round(duration.toSeconds())));
+    }
+
    private void worldBorderAction(MVCommandIssuer issuer, LoadedMultiverseWorld world, Consumer<WorldBorder> worldBorderAction) {
        Try.run(() -> world.getWorldBorder().peek(worldBorderAction))
-                .onFailure(error -> issuer.sendError(error.getLocalizedMessage()));
+                .onFailure(error -> issuer.sendError(MVCorei18n.GENERIC_ERROR_DETAILS, Replace.ERROR.with(error)));
    }
 }
@@ -8,16 +8,13 @@ import java.util.Locale;
 import com.dumptruckman.minecraft.util.Logging;
 import io.vavr.control.Try;
 import jakarta.inject.Inject;
-import jakarta.inject.Provider;
 import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.event.EventPriority;
-import org.bukkit.plugin.PluginManager;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jvnet.hk2.annotations.Service;

 import org.mvplugins.multiverse.core.MultiverseCore;
-import org.mvplugins.multiverse.core.command.MVCommandManager;
 import org.mvplugins.multiverse.core.command.queue.ConfirmMode;
 import org.mvplugins.multiverse.core.config.handle.CommentedConfigurationHandle;
 import org.mvplugins.multiverse.core.config.handle.StringPropertyHandle;
@@ -28,7 +25,6 @@ import org.mvplugins.multiverse.core.config.migration.action.InvertBoolMigratorA
 import org.mvplugins.multiverse.core.config.migration.action.MoveMigratorAction;
 import org.mvplugins.multiverse.core.config.migration.VersionMigrator;
 import org.mvplugins.multiverse.core.config.migration.action.SetMigratorAction;
-import org.mvplugins.multiverse.core.destination.DestinationsProvider;
 import org.mvplugins.multiverse.core.teleportation.PassengerMode;
 import org.mvplugins.multiverse.core.teleportation.PassengerModes;
 import org.mvplugins.multiverse.core.world.helpers.DimensionFinder.DimensionFormat;
@@ -190,6 +186,16 @@ public final class CoreConfig {
        return configHandle.get(configNodes.enforceFlight);
    }

+    @ApiStatus.AvailableSince("5.5")
+    public Try<Void> setGamemodeAndFlightEnforceDelay(int delayTicks) {
+        return configHandle.set(configNodes.gamemodeAndFlightEnforceDelay, delayTicks);
+    }
+
+    @ApiStatus.AvailableSince("5.5")
+    public int getGamemodeAndFlightEnforceDelay() {
+        return configHandle.get(configNodes.gamemodeAndFlightEnforceDelay);
+    }
+
    @ApiStatus.AvailableSince("5.3")
    public Try<Void> setApplyEntitySpawnRate(boolean applyEntitySpawnRate) {
        return configHandle.set(configNodes.applyEntitySpawnRate, applyEntitySpawnRate);
@@ -240,6 +246,16 @@ public final class CoreConfig {
        return configHandle.get(configNodes.endWorldNameFormat);
    }

+    @ApiStatus.AvailableSince("5.8")
+    public Try<Void> setWarnAliasConflicts(boolean warnAliasConflicts) {
+        return configHandle.set(configNodes.warnAliasConflicts, warnAliasConflicts);
+    }
+
+    @ApiStatus.AvailableSince("5.8")
+    public boolean getWarnAliasConflicts() {
+        return configHandle.get(configNodes.warnAliasConflicts);
+    }
+
    /**
     * {@inheritDoc}
     */
@@ -497,6 +513,26 @@ public final class CoreConfig {
        return configHandle.get(configNodes.registerPapiHook);
    }

+    @ApiStatus.AvailableSince("5.5")
+    public Try<Void> setWarnInvalidPapiFormat(boolean warnInvalidPapiFormat) {
+        return configHandle.set(configNodes.warnInvalidPapiFormat, warnInvalidPapiFormat);
+    }
+
+    @ApiStatus.AvailableSince("5.5")
+    public boolean getWarnInvalidPapiFormat() {
+        return configHandle.get(configNodes.warnInvalidPapiFormat);
+    }
+
+    @ApiStatus.AvailableSince("5.5")
+    public Try<Void> setInvalidPapiFormatReturnsBlank(boolean invalidPapiFormatReturnsBlank) {
+        return configHandle.set(configNodes.invalidPapiFormatReturnsBlank, invalidPapiFormatReturnsBlank);
+    }
+
+    @ApiStatus.AvailableSince("5.5")
+    public  boolean getInvalidPapiFormatReturnsBlank() {
+        return configHandle.get(configNodes.invalidPapiFormatReturnsBlank);
+    }
+
    /**
     * {@inheritDoc}
     */
@@ -539,6 +575,16 @@ public final class CoreConfig {
        return configHandle.get(configNodes.resolveAliasName);
    }

+    @ApiStatus.AvailableSince("5.4")
+    public Try<Void> setSimplifiedDestinationTabCompletion(boolean simplifiedDestinationTabCompletion) {
+        return configHandle.set(configNodes.simplifiedDestinationTabCompletion, simplifiedDestinationTabCompletion);
+    }
+
+    @ApiStatus.AvailableSince("5.4")
+    public boolean getSimplifiedDestinationTabCompletion() {
+        return configHandle.get(configNodes.simplifiedDestinationTabCompletion);
+    }
+
    /**
     * {@inheritDoc}
     */
@@ -615,6 +661,16 @@ public final class CoreConfig {
        return configHandle.get(configNodes.eventPriorityPlayerTeleport);
    }

+    @ApiStatus.AvailableSince("5.5")
+    public Try<Void> setEventPriorityPlayerWorldChange(EventPriority eventPriorityPlayerWorldChange) {
+        return configHandle.set(configNodes.eventPriorityPlayerWorldChange, eventPriorityPlayerWorldChange);
+    }
+
+    @ApiStatus.AvailableSince("5.5")
+    public EventPriority getEventPriorityPlayerWorldChange() {
+        return configHandle.get(configNodes.eventPriorityPlayerWorldChange);
+    }
+
    public Try<Void> setBukkitYmlPath(String bukkitYmlPath) {
        return configHandle.set(configNodes.bukkitYmlPath, bukkitYmlPath);
    }
@@ -4,6 +4,7 @@ import com.dumptruckman.minecraft.util.Logging;
 import io.vavr.control.Try;
 import jakarta.inject.Inject;
 import jakarta.inject.Provider;
+import org.bukkit.ChatColor;
 import org.bukkit.command.CommandSender;
 import org.bukkit.event.EventPriority;
 import org.bukkit.plugin.PluginManager;
@@ -24,6 +25,8 @@ import org.mvplugins.multiverse.core.destination.DestinationsProvider;
 import org.mvplugins.multiverse.core.dynamiclistener.EventPriorityMapper;
 import org.mvplugins.multiverse.core.event.MVDebugModeEvent;
 import org.mvplugins.multiverse.core.exceptions.MultiverseException;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
+import org.mvplugins.multiverse.core.locale.message.Message;
 import org.mvplugins.multiverse.core.permissions.PermissionUtils;
 import org.mvplugins.multiverse.core.teleportation.PassengerModes;
 import org.mvplugins.multiverse.core.world.helpers.DimensionFinder.DimensionFormat;
@@ -134,13 +137,27 @@ final class CoreConfigNodes {
            .name("enforce-flight")
            .build());

+    final ConfigNode<Integer> gamemodeAndFlightEnforceDelay = node(ConfigNode.builder("world.gamemode-and-flight-enforce-delay", Integer.class)
+            .comment("")
+            .comment("Sets the delay in ticks before Multiverse enforces gamemode and flight ability on world change.")
+            .comment("Increase this value if you are experiencing issues with other plugins overriding gamemode or flight ability.")
+            .comment("Or set to 0 to enforce immediately during world change event.")
+            .defaultValue(1)
+            .name("gamemode-and-flight-enforce-delay")
+            .suggester((sender -> List.of("0", "1", "2", "5", "10")))
+            .build());
+
    final ConfigNode<Boolean> applyEntitySpawnRate = node(ConfigNode.builder("world.apply-entity-spawn-rate", Boolean.class)
            .comment("")
            .comment("Sets whether Multiverse will apply the world's entity `tick-rate` config in worlds.yml.")
            .comment("If disabled, the `tick-rate` config in worlds.yml will be ignored.")
            .comment("Disable this if you want paper-world.yml or another plugin to handle entity spawn rate per world.")
+            .comment("!!!NOTE: This will only apply after a server restart!")
            .defaultValue(true)
            .name("apply-entity-spawn-rate")
+            .onChange(((sender, oldValue, newValue) ->
+                    sender.sendMessage(ChatColor.YELLOW + "'apply-entity-spawn-rate' config option will only take " +
+                            "full effect after a server restart.")))
            .build());

    final ConfigNode<Boolean> applyEntitySpawnLimit = node(ConfigNode.builder("world.apply-entity-spawn-limit", Boolean.class)
@@ -148,8 +165,12 @@ final class CoreConfigNodes {
            .comment("Sets whether Multiverse will apply the world's entity `spawn-limit` config when a world is loaded.")
            .comment("If disabled, the `spawn-limit` config in worlds.yml will be ignored.")
            .comment("Disable this if you want paper-world.yml or another plugin to handle entity limits per world.")
+            .comment("!!!NOTE: This will only apply after a server restart!")
            .defaultValue(true)
            .name("apply-entity-spawn-limit")
+            .onChange(((sender, oldValue, newValue) ->
+                    sender.sendMessage(ChatColor.YELLOW + "'apply-entity-spawn-limit' config option will only take" +
+                            " full effect after a server restart.")))
            .build());

    final ConfigNode<Boolean> autoPurgeEntities = node(ConfigNode.builder("world.auto-purge-entities", Boolean.class)
@@ -179,6 +200,15 @@ final class CoreConfigNodes {
            .stringParser(DimensionFormatNodeStringParser.INSTANCE)
            .build());

+    final ConfigNode<Boolean> warnAliasConflicts = node(ConfigNode.builder("world.warn-alias-conflicts", Boolean.class)
+            .comment("")
+            .comment("Sets whether Multiverse will warn about alias duplicates when adding worlds or modifying aliases.")
+            .comment("Although not enforced, it is highly recommended to not have multiple worlds with the same alias or")
+            .comment("alias matching another world's name as it can cause confusion during world listing and selection in commands.")
+            .defaultValue(true)
+            .name("warn-alias-conflicts")
+            .build());
+
    private final ConfigHeaderNode teleportHeader = node(ConfigHeaderNode.builder("teleport")
            .comment("")
            .comment("")
@@ -201,8 +231,12 @@ final class CoreConfigNodes {

    final ConfigNode<PassengerModes> passengerMode = node(ConfigNode.builder("teleport.passenger-mode", PassengerModes.class)
            .comment("")
-            .comment("Configures how passengers and vehicles are handled when an entity is teleported.")
-            .comment("  default: Server will handle passengers and vehicles, this usually means entities will not be teleported to a different world if they have passengers.")
+            .comment("Configures how passengers and vehicles are handled when an entity is teleported. This config is")
+            .comment("only applied to /mvtp, join-destination and first-spawn-override. It will not touch any other")
+            .comment("teleport by other plugins or commands.")
+            .comment("========= Available options: =========")
+            .comment("  default: Server will handle passengers and vehicles. On papermc 1.21.10+, all will be retained by default.")
+            .comment("                                                       On older versions, all will be dismounted if world changes.")
            .comment("  dismount_passengers: Passengers will be removed from the parent entity before the teleport.")
            .comment("  dismount_vehicle: Vehicle will be removed and from the parent entity before the teleport.")
            .comment("  dismount_all: All passengers and vehicles will be removed from the parent entity before the teleport.")
@@ -348,7 +382,8 @@ final class CoreConfigNodes {
            .defaultValue(128)
            .name("custom-portal-search-radius")
            .validator(value -> value < 0
-                    ? Try.failure(new MultiverseException("The value must be greater than or equal to 0.", null))
+                    ? Try.failure(new MultiverseException(
+                            Message.of(MVCorei18n.CORE_CONFIG_CUSTOMPORTALSEARCHRADIUS_NONNEGATIVE), null))
                    : Try.success(null))
            .build());

@@ -380,12 +415,29 @@ final class CoreConfigNodes {
            .name("register-papi-hook")
            .build());

+    final ConfigNode<Boolean> warnInvalidPapiFormat = node(ConfigNode.builder("messaging.warn-invalid-papi-format", Boolean.class)
+            .comment("")
+            .comment("This config option defines whether or not Multiverse should warn about invalid PlaceholderAPI formats.")
+            .comment("Only applies if PlaceholderAPI is installed, and only to multiverse placeholders.")
+            .defaultValue(true)
+            .name("warn-invalid-papi-format")
+            .build());
+
+    final ConfigNode<Boolean> invalidPapiFormatReturnsBlank = node(ConfigNode.builder("messaging.invalid-papi-format-returns-blank", Boolean.class)
+            .comment("")
+            .comment("By default, invalid formats will return the original placeholder string.")
+            .comment("This config option defines whether or not Multiverse should show invalid PlaceholderAPI formats as blank.")
+            .comment("Only applies if PlaceholderAPI is installed, and only to multiverse placeholders.")
+            .defaultValue(false)
+            .name("invalid-papi-format-returns-blank")
+            .build());
+
    final ConfigNode<Locale> defaultLocale = node(ConfigNode.builder("messaging.default-locale", Locale.class)
            .comment("")
            .comment("This config option defines the default language Multiverse should use.")
            .defaultValue(Locale.ENGLISH)
            .name("default-locale")
-            .onSetValue((oldValue, newValue) ->
+            .onLoadAndChange((oldValue, newValue) ->
                    commandManager.get().getLocales().setDefaultLocale(newValue))
            .build());

@@ -395,9 +447,8 @@ final class CoreConfigNodes {
            .comment("If the player's language does not have a translation, it will use the default language set above instead.")
            .defaultValue(true)
            .name("per-player-locale")
-            .onSetValue((oldValue, newValue) -> {
-                commandManager.get().usePerIssuerLocale(newValue);
-            })
+            .onLoadAndChange((oldValue, newValue) ->
+                    commandManager.get().usePerIssuerLocale(newValue))
            .build());

    private final ConfigHeaderNode commandHeader = node(ConfigHeaderNode.builder("command")
@@ -413,6 +464,15 @@ final class CoreConfigNodes {
            .name("resolve-alias-name")
            .build());

+    final ConfigNode<Boolean> simplifiedDestinationTabCompletion = node(ConfigNode.builder("command.simplified-destination-tab-completion", Boolean.class)
+            .comment("")
+            .comment("If this is set to true, Multiverse will only suggest simple destination formats in tab completion.")
+            .comment("This means only world names will be suggested without other destination type such as `e:worldname:x,y,z` or `p:playername`.")
+            .comment("Note: This DOES NOT prevent players from using the destinations, as that is controlled by permissions.")
+            .defaultValue(false)
+            .name("simplified-destination-tab-completion")
+            .build());
+
    final ConfigNode<ConfirmMode> confirmMode = node(ConfigNode.builder("command.confirm-mode", ConfirmMode.class)
            .comment("")
            .comment("This config option defines whether `/mv confirm` is needed before running a DANGEROUS action.")
@@ -439,7 +499,8 @@ final class CoreConfigNodes {
            .defaultValue(30)
            .name("confirm-timeout")
            .validator(value -> (value <= 0)
-                    ? Try.failure(new MultiverseException("Confirm timeout must be a positive number!"))
+                    ? Try.failure(new MultiverseException(
+                            Message.of(MVCorei18n.CORE_CONFIG_CONFIRMTIMEOUT_POSITIVE)))
                    : Try.success(null))
            .build());

@@ -467,8 +528,11 @@ final class CoreConfigNodes {
            .comment("")
            .comment("This config option defines the priority for the PlayerPortalEvent.")
            .name("event-priority-player-portal")
-            .onSetValue((oldValue, newValue) ->
+            .onLoadAndChange((oldValue, newValue) ->
                    eventPriorityMapper.get().setPriority("mvcore-player-portal", newValue))
+            .onChange(((sender, oldValue, newValue) ->
+                    sender.sendMessage(ChatColor.YELLOW + "'event-priority.player-portal' config option will only take " +
+                            "full effect after a server restart.")))
            .build());

    final ConfigNode<EventPriority> eventPriorityPlayerRespawn = node(ConfigNode.builder("event-priority.player-respawn", EventPriority.class)
@@ -476,16 +540,23 @@ final class CoreConfigNodes {
            .name("event-priority-player-respawn")
            .comment("")
            .comment("This config option defines the priority for the PlayerRespawnEvent.")
-            .onSetValue((oldValue, newValue) ->
+            .onLoadAndChange((oldValue, newValue) ->
                    eventPriorityMapper.get().setPriority("mvcore-player-respawn", newValue))
+            .onChange((sender, oldValue, newValue) ->
+                    sender.sendMessage(ChatColor.YELLOW + "'event-priority.player-respawn' config option will only take " +
+                            "full effect after a server restart."))
            .build());

    final ConfigNode<EventPriority> eventPriorityPlayerSpawnLocation = node(ConfigNode.builder("event-priority.player-spawn-location", EventPriority.class)
            .defaultValue(EventPriority.NORMAL)
            .comment("")
            .comment("This config option defines the priority for the PlayerSpawnLocationEvent.")
-            .name("event-priority-player-spawn-location").onSetValue((oldValue, newValue) ->
+            .name("event-priority-player-spawn-location")
+            .onLoadAndChange((oldValue, newValue) ->
                    eventPriorityMapper.get().setPriority("mvcore-player-spawn-location", newValue))
+            .onChange((sender, oldValue, newValue) ->
+                    sender.sendMessage(ChatColor.YELLOW + "'event-priority.player-spawn-location' config option will only take " +
+                            "full effect after a server restart."))
            .build());

    final ConfigNode<EventPriority> eventPriorityPlayerTeleport = node(ConfigNode.builder("event-priority.player-teleport", EventPriority.class)
@@ -493,8 +564,23 @@ final class CoreConfigNodes {
            .name("event-priority-player-teleport")
            .comment("")
            .comment("This config option defines the priority for the PlayerTeleportEvent.")
-            .onSetValue((oldValue, newValue) ->
+            .onLoadAndChange((oldValue, newValue) ->
                    eventPriorityMapper.get().setPriority("mvcore-player-teleport", newValue))
+            .onChange((sender, oldValue, newValue) ->
+                    sender.sendMessage(ChatColor.YELLOW + "'event-priority.player-teleport' config option will only take " +
+                            "full effect after a server restart."))
+            .build());
+
+    final ConfigNode<EventPriority> eventPriorityPlayerWorldChange = node(ConfigNode.builder("event-priority.player-changed-world", EventPriority.class)
+            .defaultValue(EventPriority.NORMAL)
+            .name("event-priority-player-changed-world")
+            .comment("")
+            .comment("This config option defines the priority for the PlayerChangedWorldEvent.")
+            .onLoadAndChange((oldValue, newValue) ->
+                    eventPriorityMapper.get().setPriority("mvcore-player-changed-world", newValue))
+            .onChange((sender, oldValue, newValue) ->
+                    sender.sendMessage(ChatColor.YELLOW + "'event-priority.player-changed-world' config option will only take " +
+                            "full effect after a server restart."))
            .build());

    private final ConfigHeaderNode miscHeader = node(ConfigHeaderNode.builder("misc")
@@ -507,6 +593,9 @@ final class CoreConfigNodes {
            .comment("Note: this config option needs a server restart to take effect.")
            .defaultValue("bukkit.yml")
            .name("bukkit-yml-path")
+            .onChange(((sender, oldValue, newValue) ->
+                    sender.sendMessage(ChatColor.YELLOW + "'bukkit-yml-path' config option will only take " +
+                            "full effect after a server restart.")))
            .build());

    final ConfigNode<String> serverPropertiesPath = node(ConfigNode.builder("misc.server-properties-path", String.class)
@@ -515,6 +604,9 @@ final class CoreConfigNodes {
            .comment("Note: this config option needs a server restart to take effect.")
            .defaultValue("server.properties")
            .name("server-properties-path")
+            .onChange(((sender, oldValue, newValue) ->
+                    sender.sendMessage(ChatColor.YELLOW + "'server-properties-path' config option will only take " +
+                            "full effect after a server restart.")))
            .build());

    final ConfigNode<Boolean> autoDetectGeneratorPlugins = node(ConfigNode.builder("misc.auto-detect-generator-plugins", Boolean.class)
@@ -539,9 +631,10 @@ final class CoreConfigNodes {
            .name("global-debug")
            .suggester(input -> List.of("0", "1", "2", "3"))
            .validator(value -> (value < 0 || value > 3)
-                    ? Try.failure(new MultiverseException("Debug level must be between 0 and 3."))
+                    ? Try.failure(new MultiverseException(
+                            Message.of(MVCorei18n.CORE_CONFIG_DEBUGLEVEL_RANGE)))
                    : Try.success(null))
-            .onSetValue((oldValue, newValue) -> {
+            .onLoadAndChange((oldValue, newValue) -> {
                if (newValue != Logging.getDebugLevel()) {
                    Logging.setDebugLevel(newValue);
                    pluginManager.callEvent(new MVDebugModeEvent(newValue));
@@ -555,7 +648,7 @@ final class CoreConfigNodes {
            .comment("This will only work if the above 'global-debug' is set to 1 or more.")
            .defaultValue(false)
            .name("debug-permissions")
-            .onSetValue((oldValue, newValue) -> PermissionUtils.setDebugPermissions(newValue))
+            .onLoadAndChange((oldValue, newValue) -> PermissionUtils.setDebugPermissions(newValue))
            .build());

    final ConfigNode<Boolean> silentStart = node(ConfigNode.builder("misc.silent-start", Boolean.class)
@@ -563,7 +656,7 @@ final class CoreConfigNodes {
            .comment("If true, the startup console messages will no longer show.")
            .defaultValue(false)
            .name("silent-start")
-            .onSetValue((oldValue, newValue) -> Logging.setShowingConfig(!newValue))
+            .onLoadAndChange((oldValue, newValue) -> Logging.setShowingConfig(!newValue))
            .build());

    final ConfigNode<Boolean> showDonationMessage = node(ConfigNode.builder("misc.show-donation-message", Boolean.class)
@@ -6,16 +6,18 @@ import java.util.Map;
 import java.util.logging.Logger;

 import com.dumptruckman.minecraft.util.Logging;
-import io.vavr.control.Option;
 import io.vavr.control.Try;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
 import org.bukkit.configuration.ConfigurationSection;
 import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 import org.mvplugins.multiverse.core.config.migration.ConfigMigrator;
 import org.mvplugins.multiverse.core.config.node.ListValueNode;
-import org.mvplugins.multiverse.core.config.node.Node;
+import org.mvplugins.multiverse.core.config.node.MapValueNode;
 import org.mvplugins.multiverse.core.config.node.NodeGroup;
 import org.mvplugins.multiverse.core.config.node.ValueNode;

@@ -84,22 +86,19 @@ public abstract class BaseConfigurationHandle<C extends ConfigurationSection> {
        });

        nodeValueMap.forEach((valueNode, value) -> {
-            valueNode.onSetValue(value, value);
+            valueNode.onLoad(value);
+            valueNode.onLoadAndChange(Bukkit.getConsoleSender(), null, value);
        });
    }

    protected <T> T deserializeNodeFromConfig(ValueNode<T> node) {
-        if (node.getSerializer() == null) {
-            return Option.of(config.getObject(node.getPath(), node.getType())).getOrElse(node::getDefaultValue);
-        }
        return Try.of(() -> {
                    var value = config.get(node.getPath());
-                    if (value == null) {
-                        return node.getDefaultValue();
-                    }
-                    return node.getSerializer().deserialize(value, node.getType());
-                }).flatMap(value -> node.validate(value).map(ignore -> value))
-                .onFailure(e -> Logging.warning("Failed to deserialize node %s: %s", node.getPath(), e.getMessage()))
+                    return value == null ? node.getDefaultValue() : node.deserialize(value);
+                })
+                .flatMap(value -> node.validate(value).map(ignore -> value))
+                .onFailure(e -> Logging.warning("Failed to deserialize node %s: %s",
+                        node.getPath(), e.getMessage()))
                .getOrElse(node::getDefaultValue);
    }

@@ -120,12 +119,7 @@ public abstract class BaseConfigurationHandle<C extends ConfigurationSection> {
        if (value == null) {
            value = node.getDefaultValue();
        }
-        if (node.getSerializer() != null) {
-            var serialized = node.getSerializer().serialize(value, node.getType());
-            config.set(node.getPath(), serialized);
-        } else {
-            config.set(node.getPath(), value);
-        }
+        config.set(node.getPath(), node.serialize(value));
    }

    /**
@@ -156,10 +150,36 @@ public abstract class BaseConfigurationHandle<C extends ConfigurationSection> {
     * @return Empty try if the value was set, try containing an error otherwise.
     */
    public <T> Try<Void> set(@NotNull ValueNode<T> node, T value) {
+        return set(Bukkit.getConsoleSender(), node, value);
+    }
+
+    public <K, V> Try<Void> set(@NotNull MapValueNode<K, V> node, K key, V value) {
+        return node.validateEntry(key, value).map(ignore -> {
+            Map<K,V> map = get(node);
+            map.put(key, value);
+            // node.onSetEntryValue(null, key, null, value);
+            return null;
+        });
+    }
+
+    /**
+     * Sets the value of a node, if the validator is not null, it will be tested first.
+     *
+     * @param sender The sender who triggered the change.
+     * @param node   The node to set the value of.
+     * @param value  The value to set.
+     * @param <T>    The type of the node value.
+     * @return Empty try if the value was set, try containing an error otherwise.
+     *
+     * @since 5.4
+     */
+    @ApiStatus.AvailableSince("5.4")
+    public <T> Try<Void> set(@NotNull CommandSender sender, @NotNull ValueNode<T> node, T value) {
        return node.validate(value).map(ignore -> {
            T oldValue = get(node);
            nodeValueMap.put(node, value);
-            node.onSetValue(oldValue, get(node));
+            node.onLoadAndChange(sender, oldValue, value);
+            node.onChange(sender, oldValue, value);
            return null;
        });
    }
@@ -200,6 +220,18 @@ public abstract class BaseConfigurationHandle<C extends ConfigurationSection> {
        });
    }

+    public <K, V> Try<Void> remove(@NotNull MapValueNode<K, V> node, K key) {
+        return node.validateKey(key).map(ignore -> {
+            Map<K,V> map = get(node);
+            V value = map.remove(key);
+            if (value == null) {
+                throw new IllegalArgumentException("Cannot remove entry as it is already not in the map!");
+            }
+            // node.onSetEntryValue(key, value, null);
+            return null;
+        });
+    }
+
    /**
     * Sets the default value of a node.
     *
@@ -112,10 +112,5 @@ public abstract class FileConfigurationHandle<C extends FileConfiguration> exten
         * @return The configuration handle.
         */
        public abstract @NotNull FileConfigurationHandle<C> build();
-
-        @SuppressWarnings("unchecked")
-        protected B self() {
-            return (B) this;
-        }
    }
 }
@@ -226,7 +226,7 @@ public class StringPropertyHandle {
    public Try<Void> setPropertyString(@NotNull CommandSender sender, @Nullable String name, @Nullable String value) {
        return findNode(name, ValueNode.class)
                .flatMap(node -> node.parseFromString(sender, value)
-                        .flatMap(parsedValue -> handle.set(node, parsedValue)));
+                        .flatMap(parsedValue -> handle.set(sender, node, parsedValue)));
    }

    /**
@@ -14,6 +14,9 @@ import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

+import org.mvplugins.multiverse.core.config.node.functions.NodeChangeCallback;
+import org.mvplugins.multiverse.core.config.node.functions.NodeValueCallback;
+import org.mvplugins.multiverse.core.config.node.functions.SenderNodeChangeCallback;
 import org.mvplugins.multiverse.core.config.node.functions.SenderNodeStringParser;
 import org.mvplugins.multiverse.core.config.node.functions.SenderNodeSuggester;
 import org.mvplugins.multiverse.core.config.node.serializer.DefaultSerializerProvider;
@@ -53,7 +56,9 @@ public class ConfigNode<T> extends ConfigHeaderNode implements ValueNode<T> {
    protected @Nullable NodeStringParser<T> stringParser;
    protected @Nullable NodeSerializer<T> serializer;
    protected @Nullable Function<T, Try<Void>> validator;
-    protected @Nullable BiConsumer<T, T> onSetValue;
+    protected @Nullable NodeValueCallback<T> onLoad;
+    protected @Nullable NodeChangeCallback<T> onLoadAndChange;
+    protected @Nullable NodeChangeCallback<T> onChange;

    protected ConfigNode(
            @NotNull String path,
@@ -66,7 +71,9 @@ public class ConfigNode<T> extends ConfigHeaderNode implements ValueNode<T> {
            @Nullable NodeStringParser<T> stringParser,
            @Nullable NodeSerializer<T> serializer,
            @Nullable Function<T, Try<Void>> validator,
-            @Nullable BiConsumer<T, T> onSetValue) {
+            @Nullable NodeValueCallback<T> onLoad,
+            @Nullable NodeChangeCallback<T> onLoadAndChange,
+            @Nullable NodeChangeCallback<T> onChange) {
        super(path, comments);
        this.name = name;
        this.type = type;
@@ -82,7 +89,9 @@ public class ConfigNode<T> extends ConfigHeaderNode implements ValueNode<T> {
                ? serializer
                : DefaultSerializerProvider.getDefaultSerializer(type);
        this.validator = validator;
-        this.onSetValue = onSetValue;
+        this.onLoad = onLoad;
+        this.onLoadAndChange = onLoadAndChange;
+        this.onChange = onChange;
    }

    /**
@@ -171,6 +180,24 @@ public class ConfigNode<T> extends ConfigHeaderNode implements ValueNode<T> {
        return serializer;
    }

+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public T deserialize(@Nullable Object object) {
+        return serializer == null
+                ? (type.isInstance(object)) ? type.cast(object) : getDefaultValue()
+                : serializer.deserialize(object, type);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Object serialize(T value) {
+        return serializer ==  null ? value : serializer.serialize(value, type);
+    }
+
    /**
     * {@inheritDoc}
     */
@@ -186,9 +213,29 @@ public class ConfigNode<T> extends ConfigHeaderNode implements ValueNode<T> {
     * {@inheritDoc}
     */
    @Override
-    public void onSetValue(@Nullable T oldValue, @Nullable T newValue) {
-        if (onSetValue != null) {
-            onSetValue.accept(oldValue, newValue);
+    public void onLoad(@Nullable T value) {
+        if (onLoad != null) {
+            onLoad.run(value);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void onLoadAndChange(@NotNull CommandSender sender, @Nullable T oldValue, @Nullable T newValue) {
+        if (onLoadAndChange != null) {
+            onLoadAndChange.run(sender, oldValue, newValue);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void onChange(@NotNull CommandSender sender, @Nullable T oldValue, @Nullable T newValue) {
+        if (onChange != null) {
+            onChange.run(sender, oldValue, newValue);
        }
    }

@@ -208,7 +255,9 @@ public class ConfigNode<T> extends ConfigHeaderNode implements ValueNode<T> {
        protected @Nullable NodeStringParser<T> stringParser;
        protected @Nullable NodeSerializer<T> serializer;
        protected @Nullable Function<T, Try<Void>> validator;
-        protected @Nullable BiConsumer<T, T> onSetValue;
+        protected @Nullable NodeValueCallback<T> onLoad;
+        protected @Nullable NodeChangeCallback<T> onLoadAndChange;
+        protected @Nullable NodeChangeCallback<T> onChange;

        /**
         * Creates a new builder.
@@ -368,15 +417,84 @@ public class ConfigNode<T> extends ConfigHeaderNode implements ValueNode<T> {
            return self();
        }

+        /**
+         * Sets the action to be performed when the value is loaded.
+         *
+         * @param onLoad    The action to be performed.
+         * @return This builder.
+         */
+        @ApiStatus.AvailableSince("5.4")
+        public @NotNull B onLoad(@NotNull NodeValueCallback<T> onLoad) {
+            this.onLoad = this.onLoad == null ? onLoad : this.onLoad.then(onLoad);
+            return self();
+        }
+
+        /**
+         * Sets the action to be performed when the value is loaded and changed.
+         *
+         * @param onLoadAndChange    The action to be performed.
+         * @return This builder.
+         *
+         * @since 5.4
+         */
+        @ApiStatus.AvailableSince("5.4")
+        public @NotNull B onLoadAndChange(@NotNull NodeChangeCallback<T> onLoadAndChange) {
+            this.onLoadAndChange = this.onLoadAndChange == null ? onLoadAndChange : this.onLoadAndChange.then(onLoadAndChange);
+            return self();
+        }
+
+        /**
+         * Sets the action to be performed when the value is loaded and changed.
+         *
+         * @param onLoadAndChange    The action to be performed.
+         * @return This builder.
+         *
+         * @since 5.4
+         */
+        @ApiStatus.AvailableSince("5.4")
+        public @NotNull B onLoadAndChange(@NotNull SenderNodeChangeCallback<T> onLoadAndChange) {
+            return onLoadAndChange((NodeChangeCallback<T>) onLoadAndChange);
+        }
+
+        /**
+         * Sets the action to be performed when the value is changed.
+         *
+         * @param onChange    The action to be performed.
+         * @return This builder.
+         *
+         * @since 5.4
+         */
+        @ApiStatus.AvailableSince("5.4")
+        public @NotNull B onChange(@NotNull NodeChangeCallback<T> onChange) {
+            this.onChange = this.onChange == null ? onChange : this.onChange.then(onChange);
+            return self();
+        }
+
+        /**
+         * Sets the action to be performed when the value is changed.
+         *
+         * @param onChange    The action to be performed.
+         * @return This builder.
+         *
+         * @since 5.4
+         */
+        @ApiStatus.AvailableSince("5.4")
+        public @NotNull B onChange(@NotNull SenderNodeChangeCallback<T> onChange) {
+            return onChange((NodeChangeCallback<T>) onChange);
+        }
+
        /**
         * Sets the action to be performed when the value is set.
         *
         * @param onSetValue    The action to be performed.
         * @return This builder.
+         *
+         * @deprecated Use {@link #onLoadAndChange(NodeChangeCallback)} instead.
         */
+        @Deprecated(since = "5.4", forRemoval = true)
+        @ApiStatus.ScheduledForRemoval(inVersion = "6.0")
        public @NotNull B onSetValue(@NotNull BiConsumer<T, T> onSetValue) {
-            this.onSetValue = this.onSetValue == null ? onSetValue : this.onSetValue.andThen(onSetValue);
-            return self();
+            return onLoadAndChange(onSetValue::accept);
        }

        /**
@@ -385,7 +503,8 @@ public class ConfigNode<T> extends ConfigHeaderNode implements ValueNode<T> {
        @Override
        public @NotNull ConfigNode<T> build() {
            return new ConfigNode<>(path, comments.toArray(new String[0]),
-                    name, type, aliases, defaultValue, suggester, stringParser, serializer, validator, onSetValue);
+                    name, type, aliases, defaultValue, suggester, stringParser, serializer, validator,
+                    onLoad, onLoadAndChange, onChange);
        }
    }
 }
@@ -19,6 +19,8 @@ import org.jetbrains.annotations.Nullable;

 import org.mvplugins.multiverse.core.config.node.functions.DefaultStringParserProvider;
 import org.mvplugins.multiverse.core.config.node.functions.DefaultSuggesterProvider;
+import org.mvplugins.multiverse.core.config.node.functions.NodeChangeCallback;
+import org.mvplugins.multiverse.core.config.node.functions.NodeValueCallback;
 import org.mvplugins.multiverse.core.config.node.functions.NodeStringParser;
 import org.mvplugins.multiverse.core.config.node.functions.NodeSuggester;
 import org.mvplugins.multiverse.core.config.node.functions.SenderNodeStringParser;
@@ -67,7 +69,9 @@ public class ListConfigNode<I> extends ConfigNode<List<I>> implements ListValueN
            @Nullable NodeStringParser<List<I>> stringParser,
            @Nullable NodeSerializer<List<I>> serializer,
            @Nullable Function<List<I>, Try<Void>> validator,
-            @Nullable BiConsumer<List<I>, List<I>> onSetValue,
+            @Nullable NodeValueCallback<List<I>> onLoad,
+            @Nullable NodeChangeCallback<List<I>> onLoadAndChange,
+            @Nullable NodeChangeCallback<List<I>> onChange,
            @NotNull Class<I> itemType,
            @Nullable NodeSuggester itemSuggester,
            @Nullable NodeStringParser<I> itemStringParser,
@@ -75,7 +79,7 @@ public class ListConfigNode<I> extends ConfigNode<List<I>> implements ListValueN
            @Nullable Function<I, Try<Void>> itemValidator,
            @Nullable BiConsumer<I, I> onSetItemValue) {
        super(path, comments, name, type, aliases, defaultValueSupplier, suggester, stringParser, serializer,
-                validator, onSetValue);
+                validator, onLoad, onLoadAndChange, onChange);
        this.itemType = itemType;
        this.itemSuggester = itemSuggester != null
                ? itemSuggester
@@ -105,8 +109,8 @@ public class ListConfigNode<I> extends ConfigNode<List<I>> implements ListValueN
        if (this.itemSerializer != null && this.serializer == null) {
            setDefaultSerialiser();
        }
-        if (this.onSetItemValue != null && this.onSetValue == null) {
-            setDefaultOnSetValue();
+        if (this.onSetItemValue != null && this.onLoadAndChange == null) {
+            setDefaultOnLoadAndChange();
        }
        if (this.defaultValue == null) {
            this.defaultValue = ArrayList::new;
@@ -116,9 +120,9 @@ public class ListConfigNode<I> extends ConfigNode<List<I>> implements ListValueN
    private void setDefaultSuggester() {
        if (itemSuggester instanceof SenderNodeSuggester senderItemSuggester) {
            this.suggester = (SenderNodeSuggester)(sender, input) ->
-                    StringFormatter.addonToCommaSeperated(input, senderItemSuggester.suggest(sender, input));
+                    StringFormatter.addOnToCommaSeparated(input, senderItemSuggester.suggest(sender, input));
        } else {
-            this.suggester = input -> StringFormatter.addonToCommaSeperated(input, itemSuggester.suggest(input));
+            this.suggester = input -> StringFormatter.addOnToCommaSeparated(input, itemSuggester.suggest(input));
        }
    }

@@ -168,8 +172,8 @@ public class ListConfigNode<I> extends ConfigNode<List<I>> implements ListValueN
        };
    }

-    private void setDefaultOnSetValue() {
-        this.onSetValue = (oldValue, newValue) -> {
+    private void setDefaultOnLoadAndChange() {
+        this.onLoadAndChange = (oldValue, newValue) -> {
            if (oldValue != null) {
                oldValue.stream()
                        .filter(value -> !newValue.contains(value))
@@ -279,7 +283,7 @@ public class ListConfigNode<I> extends ConfigNode<List<I>> implements ListValueN
            //noinspection unchecked
            super(path, (Class<List<I>>) (Object) List.class);
            this.itemType = itemType;
-            this.defaultValue = () -> (List<I>) new ArrayList<>();
+            this.defaultValue = ArrayList::new;
        }

        /**
@@ -381,7 +385,9 @@ public class ListConfigNode<I> extends ConfigNode<List<I>> implements ListValueN
                    stringParser,
                    serializer,
                    validator,
-                    onSetValue,
+                    onLoad,
+                    onLoadAndChange,
+                    onChange,
                    itemType,
                    itemSuggester,
                    itemStringParser,
@@ -0,0 +1,607 @@
+package org.mvplugins.multiverse.core.config.node;
+
+import com.dumptruckman.minecraft.util.Logging;
+import io.vavr.control.Try;
+import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.ConfigurationSection;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.mvplugins.multiverse.core.config.node.functions.DefaultStringParserProvider;
+import org.mvplugins.multiverse.core.config.node.functions.DefaultSuggesterProvider;
+import org.mvplugins.multiverse.core.config.node.functions.NodeChangeCallback;
+import org.mvplugins.multiverse.core.config.node.functions.NodeStringParser;
+import org.mvplugins.multiverse.core.config.node.functions.NodeSuggester;
+import org.mvplugins.multiverse.core.config.node.functions.NodeValueCallback;
+import org.mvplugins.multiverse.core.config.node.functions.SenderNodeStringParser;
+import org.mvplugins.multiverse.core.config.node.functions.SenderNodeSuggester;
+import org.mvplugins.multiverse.core.config.node.serializer.DefaultSerializerProvider;
+import org.mvplugins.multiverse.core.config.node.serializer.NodeSerializer;
+import org.mvplugins.multiverse.core.exceptions.MultiverseException;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
+import org.mvplugins.multiverse.core.locale.message.Message;
+import org.mvplugins.multiverse.core.utils.REPatterns;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.replace;
+
+/**
+ * A config node that contains key-value mappings.
+ *
+ * @param <K> The key type.
+ * @param <V> The value type.
+ *
+ * @since 5.7
+ */
+@ApiStatus.AvailableSince("5.7")
+public class MapConfigNode<K, V> extends ConfigNode<Map<K, V>> implements MapValueNode<K, V> {
+
+    /**
+     * Creates a new builder for a {@link MapConfigNode}.
+     *
+     * @param path      The path of the node.
+     * @param keyType   The map key type.
+     * @param valueType The map value type.
+     * @param <K>       The key type.
+     * @param <V>       The value type.
+     * @return The new builder.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public static @NotNull <K, V> Builder<K, V> mapBuilder(
+            @NotNull String path,
+            @NotNull Class<K> keyType,
+            @NotNull Class<V> valueType) {
+        return new Builder<>(path, keyType, valueType);
+    }
+
+    protected final @NotNull Class<K> keyType;
+    protected final @NotNull Class<V> valueType;
+    protected final @Nullable NodeSuggester keySuggester;
+    protected final @Nullable NodeSuggester valueSuggester;
+    protected final @Nullable NodeStringParser<K> keyStringParser;
+    protected final @Nullable NodeStringParser<V> valueStringParser;
+    protected final @Nullable NodeSerializer<K> keySerializer;
+    protected final @Nullable NodeSerializer<V> valueSerializer;
+    protected final @Nullable Function<K, Try<Void>> keyValidator;
+    protected final @Nullable Function<V, Try<Void>> valueValidator;
+
+    protected MapConfigNode(
+            @NotNull String path,
+            @NotNull String[] comments,
+            @Nullable String name,
+            @NotNull Class<Map<K, V>> type,
+            @NotNull String[] aliases,
+            @Nullable Supplier<Map<K, V>> defaultValueSupplier,
+            @Nullable NodeSuggester suggester,
+            @Nullable NodeStringParser<Map<K, V>> stringParser,
+            @Nullable NodeSerializer<Map<K, V>> serializer,
+            @Nullable Function<Map<K, V>, Try<Void>> validator,
+            @Nullable NodeValueCallback<Map<K, V>> onLoad,
+            @Nullable NodeChangeCallback<Map<K, V>> onLoadAndChange,
+            @Nullable NodeChangeCallback<Map<K, V>> onChange,
+            @NotNull Class<K> keyType,
+            @NotNull Class<V> valueType,
+            @Nullable NodeSuggester keySuggester,
+            @Nullable NodeSuggester valueSuggester,
+            @Nullable NodeStringParser<K> keyStringParser,
+            @Nullable NodeStringParser<V> valueStringParser,
+            @Nullable NodeSerializer<K> keySerializer,
+            @Nullable NodeSerializer<V> valueSerializer,
+            @Nullable Function<K, Try<Void>> keyValidator,
+            @Nullable Function<V, Try<Void>> valueValidator) {
+        super(path, comments, name, type, aliases, defaultValueSupplier, suggester, stringParser, serializer,
+                validator, onLoad, onLoadAndChange, onChange);
+        this.keyType = keyType;
+        this.valueType = valueType;
+        this.keySuggester = keySuggester != null
+                ? keySuggester
+                : DefaultSuggesterProvider.getDefaultSuggester(keyType);
+        this.valueSuggester = valueSuggester != null
+                ? valueSuggester
+                : DefaultSuggesterProvider.getDefaultSuggester(valueType);
+        this.keyStringParser = keyStringParser != null
+                ? keyStringParser
+                : DefaultStringParserProvider.getDefaultStringParser(keyType);
+        this.valueStringParser = valueStringParser != null
+                ? valueStringParser
+                : DefaultStringParserProvider.getDefaultStringParser(valueType);
+        this.keySerializer = keySerializer != null
+                ? keySerializer
+                : DefaultSerializerProvider.getDefaultSerializer(keyType);
+        this.valueSerializer = valueSerializer != null
+                ? valueSerializer
+                : DefaultSerializerProvider.getDefaultSerializer(valueType);
+        this.keyValidator = keyValidator != null
+                ? keyValidator
+                : defaultYamlKeyValidator();
+        this.valueValidator = valueValidator;
+
+        setDefaults();
+    }
+
+    private Function<K, Try<Void>> defaultYamlKeyValidator() {
+        return key -> Try.of(() -> {
+            if (!REPatterns.YAML_KEY.matcher(String.valueOf(serializeKey(key))).matches()) {
+                throw new MultiverseException(Message.of(MVCorei18n.CONFIG_NODE_INVALIDYAMLKEY,
+                        replace("{key}").with(key)));
+            }
+            return null;
+        });
+    }
+
+    private void setDefaults() {
+        if ((this.keySuggester != null || this.valueSuggester != null) && this.suggester == null) {
+            setDefaultSuggester();
+        }
+        if (this.keyStringParser != null && this.valueStringParser != null && this.stringParser == null) {
+            setDefaultStringParser();
+        }
+        if ((this.keyValidator != null || this.valueValidator != null) && this.validator == null) {
+            setDefaultValidator();
+        }
+        if ((this.keySerializer != null || this.valueSerializer != null) && this.serializer == null) {
+            setDefaultSerializer();
+        }
+        if (this.defaultValue == null) {
+            this.defaultValue = LinkedHashMap::new;
+        }
+    }
+
+    private void setDefaultSuggester() {
+        if (this.keySuggester instanceof SenderNodeSuggester || this.valueSuggester instanceof SenderNodeSuggester) {
+            this.suggester = (SenderNodeSuggester) this::suggestEntries;
+        } else {
+            this.suggester = input -> suggestEntries(null, input);
+        }
+    }
+
+    private @NotNull Collection<String> suggestEntries(@Nullable CommandSender sender, @Nullable String input) {
+        String content = input == null ? "" : input;
+        int lastComma = content.lastIndexOf(',');
+        String prefix = lastComma == -1 ? "" : content.substring(0, lastComma + 1);
+        String currentEntry = lastComma == -1 ? content : content.substring(lastComma + 1);
+
+        String[] keyValue = REPatterns.EQUALS.split(currentEntry, 2);
+        if (keyValue.length == 2 && valueSuggester != null) {
+            String keyPart = keyValue[0];
+            String valuePart = keyValue[1];
+            return suggestFrom(valueSuggester, sender, valuePart).stream()
+                    .map(suggestedValue -> prefix + keyPart + "=" + suggestedValue)
+                    .toList();
+        }
+
+        if (keySuggester == null) {
+            return Collections.emptyList();
+        }
+
+        return suggestFrom(keySuggester, sender, currentEntry).stream()
+                .map(suggestedKey -> prefix + suggestedKey + "=")
+                .toList();
+    }
+
+    private @NotNull Collection<String> suggestFrom(
+            @NotNull NodeSuggester suggester,
+            @Nullable CommandSender sender,
+            @Nullable String input) {
+        if (sender != null && suggester instanceof SenderNodeSuggester senderSuggester) {
+            return senderSuggester.suggest(sender, input);
+        }
+        return suggester.suggest(input);
+    }
+
+    private void setDefaultStringParser() {
+        this.stringParser = (input, type) -> Try.of(() -> {
+            Map<K, V> parsed = new LinkedHashMap<>();
+            if (input == null || input.isBlank()) {
+                return parsed;
+            }
+            for (String entry : REPatterns.SEMICOLON.split(input)) {
+                String[] keyValue = REPatterns.EQUALS.split(entry, 2);
+                if (keyValue.length != 2) {
+                    throw new IllegalArgumentException("Invalid map entry '" + entry + "'. Expected format key=value");
+                }
+                NodeStringParser<K> keyParser = Objects.requireNonNull(keyStringParser, "keyStringParser");
+                NodeStringParser<V> valueParser = Objects.requireNonNull(valueStringParser, "valueStringParser");
+                K parsedKey = keyParser.parse(keyValue[0].trim(), keyType).get();
+                V parsedValue = valueParser.parse(keyValue[1].trim(), valueType).get();
+                parsed.put(parsedKey, parsedValue);
+            }
+            return parsed;
+        });
+    }
+
+    private void setDefaultValidator() {
+        this.validator = value -> Try.of(() -> {
+            if (value == null) {
+                return null;
+            }
+            for (Map.Entry<K, V> entry : value.entrySet()) {
+                if (keyValidator != null) {
+                    keyValidator.apply(entry.getKey()).get();
+                }
+                if (valueValidator != null) {
+                    valueValidator.apply(entry.getValue()).get();
+                }
+            }
+            return null;
+        });
+    }
+
+    private void setDefaultSerializer() {
+        this.serializer = new NodeSerializer<>() {
+            @Override
+            public Map<K, V> deserialize(Object object, Class<Map<K, V>> type) {
+                if (object == null) {
+                    return new LinkedHashMap<>();
+                }
+
+                if (object instanceof Map<?, ?> rawMap) {
+                    Map<K, V> result = new LinkedHashMap<>();
+                    rawMap.forEach((key, value) -> {
+                        Map.Entry<K, V> entry = deserializeEntry(key, value);
+                        result.put(entry.getKey(), entry.getValue());
+                    });
+                    return result;
+                }
+
+                if (object instanceof ConfigurationSection section) {
+                    Map<K, V> result = new LinkedHashMap<>();
+                    for (String key : section.getKeys(false)) {
+                        Object rawValue = section.get(key);
+                        Map.Entry<K, V> entry = deserializeEntry(key, rawValue);
+                        result.put(entry.getKey(), entry.getValue());
+                    }
+                    return result;
+                }
+
+                throw new IllegalArgumentException("Invalid map object '" + object + "'. Expected map or section.");
+            }
+
+            @Override
+            public Object serialize(Map<K, V> object, Class<Map<K, V>> type) {
+                Map<Object, Object> serialized = new LinkedHashMap<>();
+                if (object == null) {
+                    return serialized;
+                }
+                object.forEach((key, value) -> {
+                    Map.Entry<Object, Object> entry = serializeEntry(key, value);
+                    serialized.put(entry.getKey(), entry.getValue());
+                });
+                return serialized;
+            }
+        };
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public @NotNull Try<Void> validateKey(@Nullable K key) {
+        return keyValidator == null ? Try.success(null) : keyValidator.apply(key);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public @NotNull Try<Void> validateValue(@Nullable V value) {
+        return valueValidator == null ? Try.success(null) : valueValidator.apply(value);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public @NotNull Try<Void> validateEntry(@Nullable K key, @Nullable V value) {
+        return validateKey(key).flatMap(ignored -> validateValue(value));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public @NotNull Map.Entry<K, V> deserializeEntry(@Nullable Object key, @Nullable Object value) {
+        K deserializedKey = keySerializer == null
+                ? keyType.isInstance(key) ? keyType.cast(key) : null
+                : keySerializer.deserialize(key, keyType);
+        V deserializedValue = valueSerializer == null
+                ? keyType.isInstance(value) ? valueType.cast(value) : null
+                : valueSerializer.deserialize(value, valueType);
+        return new SimpleEntry<>(deserializedKey, deserializedValue);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public @NotNull Map.Entry<Object, Object> serializeEntry(@Nullable K key, @Nullable V value) {
+        return new SimpleEntry<>(serializeKey(key), serializeValue(value));
+    }
+
+    private @Nullable Object serializeKey(@Nullable K key) {
+        return keySerializer == null ? key : keySerializer.serialize(key, keyType);
+    }
+
+    private @Nullable Object serializeValue(@Nullable V value) {
+        return valueSerializer == null ? value : valueSerializer.serialize(value, valueType);
+    }
+
+    private record SimpleEntry<K, V>(K key, V value) implements Map.Entry<K, V> {
+        @Override
+        public K getKey() {
+            return key;
+        }
+
+        @Override
+        public V getValue() {
+            return value;
+        }
+
+        @Override
+        public V setValue(V value) {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    /**
+     * Builder for {@link MapConfigNode} instances.
+     *
+     * <p>This builder extends {@link ConfigNode.Builder} with additional configuration specific to map entries:
+     * entry-level suggesters, string parsers, serializers and validators for both keys and values. When any
+     * entry-level component is omitted the builder provides a sensible default (for example default parsers,
+     * suggesters, serializers or an empty map default value).
+     *
+     * @param <K> The map key type.
+     * @param <V> The map value type.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public static class Builder<K, V> extends ConfigNode.Builder<Map<K, V>, Builder<K, V>> {
+
+        protected final @NotNull Class<K> keyType;
+        protected final @NotNull Class<V> valueType;
+        protected @Nullable NodeSuggester keySuggester;
+        protected @Nullable NodeSuggester valueSuggester;
+        protected @Nullable NodeStringParser<K> keyStringParser;
+        protected @Nullable NodeStringParser<V> valueStringParser;
+        protected @Nullable NodeSerializer<K> keySerializer;
+        protected @Nullable NodeSerializer<V> valueSerializer;
+        protected @Nullable Function<K, Try<Void>> keyValidator;
+        protected @Nullable Function<V, Try<Void>> valueValidator;
+
+        /**
+         * Creates a new builder for a map config node.
+         *
+         * @param path The configuration path for the node.
+         * @param keyType The runtime type of the map keys.
+         * @param valueType The runtime type of the map values.
+         *
+         * @since 5.7
+         */
+        @ApiStatus.AvailableSince("5.7")
+        protected Builder(@NotNull String path, @NotNull Class<K> keyType, @NotNull Class<V> valueType) {
+            //noinspection unchecked
+            super(path, (Class<Map<K, V>>) (Object) Map.class);
+            this.keyType = keyType;
+            this.valueType = valueType;
+            this.defaultValue = LinkedHashMap::new;
+        }
+
+        /**
+         * Sets a suggester for map keys. The suggester is used when computing tab-completion suggestions for the
+         * key part of an entry.
+         *
+         * @param keySuggester The suggester to use for keys.
+         * @return This builder for chaining.
+         *
+         * @since 5.7
+         */
+        @ApiStatus.AvailableSince("5.7")
+        public @NotNull Builder<K, V> keySuggester(@NotNull NodeSuggester keySuggester) {
+            this.keySuggester = keySuggester;
+            return self();
+        }
+
+        /**
+         * Sets a sender-aware suggester for map keys. Use this when suggestions depend on the command sender
+         * (permissions, location, etc.).
+         *
+         * @param keySuggester The sender-aware suggester.
+         * @return This builder for chaining.
+         *
+         * @since 5.7
+         */
+        @ApiStatus.AvailableSince("5.7")
+        public @NotNull Builder<K, V> keySuggester(@NotNull SenderNodeSuggester keySuggester) {
+            this.keySuggester = keySuggester;
+            return self();
+        }
+
+        /**
+         * Sets a suggester for map values. The suggester is used when computing tab-completion suggestions for the
+         * value part of an entry.
+         *
+         * @param valueSuggester The suggester to use for values.
+         * @return This builder for chaining.
+         *
+         * @since 5.7
+         */
+        @ApiStatus.AvailableSince("5.7")
+        public @NotNull Builder<K, V> valueSuggester(@NotNull NodeSuggester valueSuggester) {
+            this.valueSuggester = valueSuggester;
+            return self();
+        }
+
+        /**
+         * Sets a sender-aware suggester for map values. Use this when value suggestions depend on the
+         * command sender.
+         *
+         * @param valueSuggester The sender-aware suggester.
+         * @return This builder for chaining.
+         *
+         * @since 5.7
+         */
+        @ApiStatus.AvailableSince("5.7")
+        public @NotNull Builder<K, V> valueSuggester(@NotNull SenderNodeSuggester valueSuggester) {
+            this.valueSuggester = valueSuggester;
+            return self();
+        }
+
+        /**
+         * Sets the string parser for keys. The parser is used when parsing user-provided key strings into key
+         * instances (e.g. when parsing a map from a single-line string representation).
+         *
+         * @param keyStringParser The parser to use for keys.
+         * @return This builder for chaining.
+         *
+         * @since 5.7
+         */
+        @ApiStatus.AvailableSince("5.7")
+        public @NotNull Builder<K, V> keyStringParser(@NotNull NodeStringParser<K> keyStringParser) {
+            this.keyStringParser = keyStringParser;
+            return self();
+        }
+
+        /**
+         * Sets a sender-aware string parser for keys. Use this when parsing depends on the sender context.
+         *
+         * @param keyStringParser The sender-aware key parser.
+         * @return This builder for chaining.
+         *
+         * @since 5.7
+         */
+        @ApiStatus.AvailableSince("5.7")
+        public @NotNull Builder<K, V> keyStringParser(@NotNull SenderNodeStringParser<K> keyStringParser) {
+            this.keyStringParser = keyStringParser;
+            return self();
+        }
+
+        /**
+         * Sets the string parser for values. The parser converts the textual part after '=' in an entry into the
+         * value type.
+         *
+         * @param valueStringParser The parser to use for values.
+         * @return This builder for chaining.
+         *
+         * @since 5.7
+         */
+        @ApiStatus.AvailableSince("5.7")
+        public @NotNull Builder<K, V> valueStringParser(@NotNull NodeStringParser<V> valueStringParser) {
+            this.valueStringParser = valueStringParser;
+            return self();
+        }
+
+        /**
+         * Sets a sender-aware string parser for values.
+         *
+         * @param valueStringParser The sender-aware value parser.
+         * @return This builder for chaining.
+         *
+         * @since 5.7
+         */
+        @ApiStatus.AvailableSince("5.7")
+        public @NotNull Builder<K, V> valueStringParser(@NotNull SenderNodeStringParser<V> valueStringParser) {
+            this.valueStringParser = valueStringParser;
+            return self();
+        }
+
+        /**
+         * Sets the serializer for keys. Serializers convert keys to/from persisted forms stored in the configuration
+         * backend.
+         *
+         * @param keySerializer The key serializer.
+         * @return This builder for chaining.
+         *
+         * @since 5.7
+         */
+        @ApiStatus.AvailableSince("5.7")
+        public @NotNull Builder<K, V> keySerializer(@NotNull NodeSerializer<K> keySerializer) {
+            this.keySerializer = keySerializer;
+            return self();
+        }
+
+        /**
+         * Sets the serializer for values.
+         *
+         * @param valueSerializer The value serializer.
+         * @return This builder for chaining.
+         *
+         * @since 5.7
+         */
+        @ApiStatus.AvailableSince("5.7")
+        public @NotNull Builder<K, V> valueSerializer(@NotNull NodeSerializer<V> valueSerializer) {
+            this.valueSerializer = valueSerializer;
+            return self();
+        }
+
+        /**
+         * Sets a validator for keys. The validator should return a successful {@link Try} for valid keys or a failed
+         * {@link Try} describing the validation error for invalid keys.
+         *
+         * @param keyValidator The key validator.
+         * @return This builder for chaining.
+         *
+         * @since 5.7
+         */
+        @ApiStatus.AvailableSince("5.7")
+        public @NotNull Builder<K, V> keyValidator(@NotNull Function<K, Try<Void>> keyValidator) {
+            this.keyValidator = keyValidator;
+            return self();
+        }
+
+        /**
+         * Sets a validator for values.
+         *
+         * @param valueValidator The value validator.
+         * @return This builder for chaining.
+         *
+         * @since 5.7
+         */
+        @ApiStatus.AvailableSince("5.7")
+        public @NotNull Builder<K, V> valueValidator(@NotNull Function<V, Try<Void>> valueValidator) {
+            this.valueValidator = valueValidator;
+            return self();
+        }
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public @NotNull MapConfigNode<K, V> build() {
+            return new MapConfigNode<>(
+                    path,
+                    comments.toArray(new String[0]),
+                    name,
+                    type,
+                    aliases,
+                    defaultValue,
+                    suggester,
+                    stringParser,
+                    serializer,
+                    validator,
+                    onLoad,
+                    onLoadAndChange,
+                    onChange,
+                    keyType,
+                    valueType,
+                    keySuggester,
+                    valueSuggester,
+                    keyStringParser,
+                    valueStringParser,
+                    keySerializer,
+                    valueSerializer,
+                    keyValidator,
+                    valueValidator);
+        }
+    }
+}
@@ -0,0 +1,93 @@
+package org.mvplugins.multiverse.core.config.node;
+
+import io.vavr.control.Try;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Map;
+
+/**
+ * A {@link ValueNode} specialization that stores a {@link Map} of key-value pairs.
+ *
+ * @param <K> The key type.
+ * @param <V> The value type.
+ *
+ * @since 5.7
+ */
+@ApiStatus.AvailableSince("5.7")
+public interface MapValueNode<K, V> extends ValueNode<Map<K, V>> {
+
+    /**
+     * Validates a single map key.
+     * <br />
+     * Implementations should return a successful {@link Try} when the key is acceptable, or a failed
+     * {@link Try} when the key is invalid.
+     *
+     * @param key The key to validate, or {@code null} if the key is absent.
+     * @return A successful {@link Try} if the key is valid, or a failed {@link Try} if it is not.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @NotNull Try<Void> validateKey(@Nullable K key);
+
+    /**
+     * Validates a single map value.
+     * <br />
+     * Implementations should return a successful {@link Try} when the value is acceptable, or a failed
+     * {@link Try} when the value is invalid.
+     *
+     * @param value The value to validate, or {@code null} if the value is absent.
+     * @return A successful {@link Try} if the value is valid, or a failed {@link Try} if it is not.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @NotNull Try<Void> validateValue(@Nullable V value);
+
+    /**
+     * Validates a key-value entry.
+     * <br />
+     * This is typically implemented by composing {@link #validateKey(Object)} and {@link #validateValue(Object)}.
+     * If either part fails, the entry is considered invalid.
+     *
+     * @param key The entry key, or {@code null} if the key is absent.
+     * @param value The entry value, or {@code null} if the value is absent.
+     * @return A successful {@link Try} if both parts are valid, or a failed {@link Try} if either part is invalid.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @NotNull Try<Void> validateEntry(@Nullable K key, @Nullable V value);
+
+    /**
+     * Deserializes a raw key-value pair into a map entry.
+     * <br />
+     * This method converts a single persisted entry, not the full map. If either component cannot be converted,
+     * implementations may return {@code null} for that side of the entry.
+     *
+     * @param key The raw key object, or {@code null} if no key is present.
+     * @param value The raw value object, or {@code null} if no value is present.
+     * @return A map entry containing the deserialized key and value.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @NotNull Map.Entry<K, V> deserializeEntry(@Nullable Object key, @Nullable Object value);
+
+    /**
+     * Serializes a map entry into raw configuration objects.
+     * <br />
+     * This method converts a single entry to a persisted representation, not the full map. The returned entry
+     * contains the serialized key and serialized value.
+     *
+     * @param key The entry key, or {@code null} if the key is absent.
+     * @param value The entry value, or {@code null} if the value is absent.
+     * @return A map entry containing the serialized key and value.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @NotNull Map.Entry<Object, Object> serializeEntry(@Nullable K key, @Nullable V value);
+}
@@ -5,11 +5,13 @@ import java.util.Collection;
 import io.vavr.control.Option;
 import io.vavr.control.Try;
 import org.apache.logging.log4j.util.Strings;
+import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

+import org.mvplugins.multiverse.core.config.handle.BaseConfigurationHandle;
 import org.mvplugins.multiverse.core.config.node.serializer.NodeSerializer;

 public interface ValueNode<T> extends Node {
@@ -32,7 +34,7 @@ public interface ValueNode<T> extends Node {
     * Gets the aliases of this node. Serves as shorter or legacy alternatives the {@link #getName()} and must be
     * unique within a node group.
     *
-     * @return The aliases of this node.
+     * @return The aliases of this node, or an empty array if the node has no aliases.
     *
     * @since 5.1
     */
@@ -42,27 +44,36 @@ public interface ValueNode<T> extends Node {
    }

    /**
-     * Gets the default value with type {@link T} of the node.
+     * Gets the default value for this node.
     *
-     * @return The default value of the node.
+     * <p>The returned value is used when no explicit value is present or when deserialization falls back to the
+     * node's default. Implementations may return {@code null} to indicate that no default value is available.
+     *
+     * @return The default value of the node, or {@code null} if none is configured.
     */
    @Nullable T getDefaultValue();

    /**
-     * Suggests possible string values for this node. Generated based on the current user input.
+     * Suggests possible string values for this node.
     *
-     * @param input The current partial user input
+     * <p>The returned values are based on the current partial user input and should be suitable for command-line
+     * tab completion or other interactive hints.
+     *
+     * @param input The current partial user input, or {@code null} if no input has been typed yet.
     * @return A collection of possible string values.
     */
    @NotNull Collection<String> suggest(@Nullable String input);

    /**
-     * Suggests possible string values for this node. Use contextural information from the sender such as
-     * sender name, permissions, or player location for better suggestions.
+     * Suggests possible string values for this node using sender context.
     *
-     * @param sender    The sender context.
-     * @param input     The input string.
-     * @return A collection of possible string values
+     * <p>Implementations may use the sender's name, permissions, or player location to tailor the returned
+     * suggestions. If no sender-specific logic is available, implementations should fall back to
+     * {@link #suggest(String)}.
+     *
+     * @param sender The sender context.
+     * @param input The current partial user input, or {@code null} if no input has been typed yet.
+     * @return A collection of possible string values.
     *
     * @since 5.1
     */
@@ -70,20 +81,25 @@ public interface ValueNode<T> extends Node {
    @NotNull Collection<String> suggest(@NotNull CommandSender sender, @Nullable String input);

    /**
-     * Parses the given string into a value of type {@link T}. Used for property set by user input.
+     * Parses the given string into a value of type {@link T}.
     *
-     * @param input The string to parse.
-     * @return The parsed value, or given exception if parsing failed.
+     * <p>This is typically used for values entered by a user or read from configuration text.
+     *
+     * @param input The string to parse, or {@code null} if the source value is absent.
+     * @return The parsed value, or a failed {@link Try} containing the parsing error.
     */
    @NotNull Try<T> parseFromString(@Nullable String input);

    /**
     * Parses the given string into a value of type {@link T} with context from the sender.
-     * Used for property set by user input.
     *
-     * @param sender    The sender context.
-     * @param input     The string to parse.
-     * @return The parsed value, or given exception if parsing failed.
+     * <p>Sender-aware implementations may use permissions or other sender-specific information when converting the
+     * input. If no sender-aware parser is available, implementations should fall back to
+     * {@link #parseFromString(String)}.
+     *
+     * @param sender The sender context.
+     * @param input The string to parse, or {@code null} if the source value is absent.
+     * @return The parsed value, or a failed {@link Try} containing the parsing error.
     *
     * @since 5.1
     */
@@ -95,24 +111,108 @@ public interface ValueNode<T> extends Node {
    /**
     * Gets the serializer for this node.
     *
-     * @return  The serializer for this node.
+     * <p>This method exists for backward compatibility while the preferred API is
+     * {@link #serialize(Object)} and {@link #deserialize(Object)}.
+     *
+     * @return The serializer for this node, or {@code null} if none is configured.
+     *
+     * @deprecated Use {@link #serialize(Object)} and {@link #deserialize(Object)} instead.
     */
+    @Deprecated(forRemoval = true, since = "5.7")
+    @ApiStatus.ScheduledForRemoval(inVersion = "6.0")
    @Nullable NodeSerializer<T> getSerializer();

+    /**
+     * Deserializes a raw configuration object into a value of type {@link T}.
+     *
+     * <p>The input is typically a value read from YAML or another configuration source. Implementations should
+     * return a sensible fallback, such as {@link #getDefaultValue()}, when the object cannot be converted.
+     *
+     * @param object The raw object to deserialize.
+     * @return The deserialized value, or {@code null} if the object cannot be converted and no fallback exists.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @Nullable T deserialize(@Nullable Object object);
+
+    /**
+     * Serializes a value of type {@link T} into a configuration-friendly object.
+     *
+     * <p>The returned object should be suitable for persistence in a configuration file.
+     *
+     * @param value The value to serialize.
+     * @return The serialized representation, or {@code null} if the value cannot be serialized.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @Nullable Object serialize(@Nullable T value);
+
    /**
     * Validates the value of this node.
     *
     * @param value The value to validate.
-     * @return An empty {@link Try} if the value is valid, or a {@link Try} containing an exception if the value is
-     *         invalid.
+     * @return A successful {@link Try} if the value is valid, or a failed {@link Try} containing the validation
+     *         exception if the value is invalid.
     */
    Try<Void> validate(@Nullable T value);

+    /**
+     * Called when the value of this node is loaded by {@link BaseConfigurationHandle#load()}.
+     *
+     * <p>This callback is invoked after the value has been deserialized and validated during a configuration load.
+     *
+     * @param value The loaded value, or {@code null} if the configured value could not be resolved.
+     *
+     * @since 5.4
+     */
+    @ApiStatus.AvailableSince("5.4")
+    void onLoad(@Nullable T value);
+
+    /**
+     * Called when the value of this node is loaded or changed.
+     *
+     * <p>This callback is shared by both initial load and subsequent updates. When invoked during a load, the
+     * {@code oldValue} parameter will be {@code null} and the sender will be the console sender.
+     *
+     * @param sender The sender who triggered the change. If triggered by loading or no target sender is specified,
+     *               it will be the console sender.
+     * @param oldValue The previous value, or {@code null} when called during load.
+     * @param newValue The new value.
+     *
+     * @since 5.4
+     */
+    @ApiStatus.AvailableSince("5.4")
+    void onLoadAndChange(@NotNull CommandSender sender, @Nullable T oldValue, @Nullable T newValue);
+
+    /**
+     * Called when the value of this node is changed by {@link BaseConfigurationHandle#set(ValueNode, Object)}.
+     *
+     * <p>This callback is only invoked for explicit updates after the value already exists.
+     *
+     * @param sender The sender who changed the value, or the console sender if no target sender was specified.
+     * @param oldValue The old value.
+     * @param newValue The new value.
+     *
+     * @since 5.4
+     */
+    @ApiStatus.AvailableSince("5.4")
+    void onChange(@NotNull CommandSender sender, @Nullable T oldValue, @Nullable T newValue);
+
    /**
     * Called when the value of this node is set.
     *
+     * <p>This is the legacy, senderless form of {@link #onLoadAndChange(CommandSender, Object, Object)}.
+     *
     * @param oldValue The old value.
     * @param newValue The new value.
+     *
+     * @deprecated Use {@link #onLoadAndChange(CommandSender, Object, Object)} instead.
     */
-    void onSetValue(@Nullable T oldValue, @Nullable T newValue);
+    @Deprecated(since = "5.4", forRemoval = true)
+    @ApiStatus.ScheduledForRemoval(inVersion = "6.0")
+    default void onSetValue(@Nullable T oldValue, @Nullable T newValue) {
+        onLoadAndChange(Bukkit.getConsoleSender(), oldValue, newValue);
+    }
 }
@@ -8,6 +8,10 @@ import co.aikar.commands.ACFUtil;
 import io.vavr.control.Option;
 import io.vavr.control.Try;
 import org.mvplugins.multiverse.core.exceptions.MultiverseException;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
+import org.mvplugins.multiverse.core.locale.message.Message;
+
+import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.replace;

 /**
 * Provides default string parsers for common types.
@@ -51,24 +55,33 @@ public final class DefaultStringParserProvider {
            () -> switch (String.valueOf(input).toLowerCase(Locale.ENGLISH)) {
                case "t", "true", "on", "y", "yes", "1", "allow" -> true;
                case "f", "false", "off", "n", "no", "0", "deny" -> false;
-                default -> throw new MultiverseException("Unable to convert '" + input + "' to boolean. Please use 'true' or 'false'");
+                default -> throw new MultiverseException(Message.of(MVCorei18n.CONFIG_STRING_PARSER_INVALIDBOOLEAN,
+                        replace("{input}").with(input)));
            });

    private static final NodeStringParser<Integer> INTEGER_STRING_PARSER = (input, type) -> Try.of(
            () -> ACFUtil.parseInt(input))
-            .flatMap(number -> Option.of(number).toTry(() -> new MultiverseException("Unable to convert '" + input + "' to number. (integer)")));
+            .flatMap(number -> Option.of(number).toTry(() -> new MultiverseException(Message.of(
+                    MVCorei18n.CONFIG_STRING_PARSER_INVALIDINTEGER,
+                    replace("{input}").with(input)))));

    private static final NodeStringParser<Double> DOUBLE_STRING_PARSER = (input, type) -> Try.of(
            () -> ACFUtil.parseDouble(input))
-            .flatMap(number -> Option.of(number).toTry(() -> new MultiverseException("Unable to convert '" + input + "' to number. (double)")));
+            .flatMap(number -> Option.of(number).toTry(() -> new MultiverseException(Message.of(
+                    MVCorei18n.CONFIG_STRING_PARSER_INVALIDDOUBLE,
+                    replace("{input}").with(input)))));

    private static final NodeStringParser<Float> FLOAT_STRING_PARSER = (input, type) -> Try.of(
            () -> ACFUtil.parseFloat(input))
-            .flatMap(number -> Option.of(number).toTry(() -> new MultiverseException("Unable to convert '" + input + "' to number. (float)")));
+            .flatMap(number -> Option.of(number).toTry(() -> new MultiverseException(Message.of(
+                    MVCorei18n.CONFIG_STRING_PARSER_INVALIDFLOAT,
+                    replace("{input}").with(input)))));

    private static final NodeStringParser<Long> LONG_STRING_PARSER = (input, type) -> Try.of(
            () -> ACFUtil.parseLong(input))
-            .flatMap(number -> Option.of(number).toTry(() -> new MultiverseException("Unable to convert '" + input + "' to number. (long)")));
+            .flatMap(number -> Option.of(number).toTry(() -> new MultiverseException(Message.of(
+                    MVCorei18n.CONFIG_STRING_PARSER_INVALIDLONG,
+                    replace("{input}").with(input)))));

    static {
        addDefaultStringParser(String.class, STRING_STRING_PARSER);
@@ -0,0 +1,65 @@
+package org.mvplugins.multiverse.core.config.node.functions;
+
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.ApiStatus;
+
+/**
+ * A callback interface for handling changes to configuration node values.
+ *
+ * @param <T> The type of the node value.
+ *
+ * @since 5.4
+ */
+@ApiStatus.AvailableSince("5.4")
+@FunctionalInterface
+public interface NodeChangeCallback<T> {
+    /**
+     * Called when the value of a node changes.
+     *
+     * @param oldValue The old value of the node.
+     * @param newValue The new value of the node.
+     *
+     * @since 5.4
+     */
+    @ApiStatus.AvailableSince("5.4")
+    void run(T oldValue, T newValue);
+
+    /**
+     * Called when the value of a node changes, with the sender of the change.
+     *
+     * @param sender   The sender of the change.
+     * @param oldValue The old value of the node.
+     * @param newValue The new value of the node.
+     *
+     * @since 5.4
+     */
+    @ApiStatus.AvailableSince("5.4")
+    default void run(CommandSender sender, T oldValue, T newValue) {
+        run(oldValue, newValue);
+    }
+
+    /**
+     * Chains another {@link NodeChangeCallback} to be executed after this one.
+     *
+     * @param after The callback to execute after this one.
+     * @return A new {@link NodeChangeCallback} that executes both callbacks in order.
+     *
+     * @since 5.4
+     */
+    @ApiStatus.AvailableSince("5.4")
+    default NodeChangeCallback<T> then(NodeChangeCallback<T> after) {
+        return new SenderNodeChangeCallback<T>() {
+            @Override
+            public void run(CommandSender sender, T oldValue, T newValue) {
+                NodeChangeCallback.this.run(sender, oldValue, newValue);
+                after.run(sender, oldValue, newValue);
+            }
+
+            @Override
+            public void run(T oldValue, T newValue) {
+                NodeChangeCallback.this.run(oldValue, newValue);
+                after.run(oldValue, newValue);
+            }
+        };
+    }
+}
@@ -0,0 +1,38 @@
+package org.mvplugins.multiverse.core.config.node.functions;
+
+import org.jetbrains.annotations.ApiStatus;
+
+/**
+ * Handler called when an action is performed on a node such as loading.
+ *
+ * @since 5.4
+ */
+@ApiStatus.AvailableSince("5.4")
+@FunctionalInterface
+public interface NodeValueCallback<T> {
+    /**
+     * Called when an action is performed on a node.
+     *
+     * @param value The value of the node.
+     *
+     * @since 5.4
+     */
+    @ApiStatus.AvailableSince("5.4")
+    void run(T value);
+
+    /**
+     * Chains another {@link NodeValueCallback} to be executed after this one.
+     *
+     * @param after The callback to execute after this one.
+     * @return A new {@link NodeValueCallback} that executes both callbacks in order.
+     *
+     * @since 5.4
+     */
+    @ApiStatus.AvailableSince("5.4")
+    default NodeValueCallback<T> then(NodeValueCallback<T> after) {
+        return (T value) -> {
+            this.run(value);
+            after.run(value);
+        };
+    }
+}
@@ -0,0 +1,31 @@
+package org.mvplugins.multiverse.core.config.node.functions;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.ApiStatus;
+
+/**
+ * A callback interface for handling changes to configuration node values with contextual information from the sender.
+ *
+ * @param <T> The type of the node value.
+ *
+ * @since 5.4
+ */
+@ApiStatus.AvailableSince("5.4")
+@FunctionalInterface
+public interface SenderNodeChangeCallback<T> extends NodeChangeCallback<T> {
+    /**
+     * {@inheritDoc}
+     */
+    @ApiStatus.AvailableSince("5.4")
+    void run(CommandSender sender, T oldValue, T newValue);
+
+    /**
+     * {@inheritDoc}
+     */
+    @ApiStatus.AvailableSince("5.4")
+    @Override
+    default void run(T oldValue, T newValue) {
+        run(Bukkit.getConsoleSender(), oldValue, newValue);
+    }
+}
@@ -11,8 +11,11 @@ import org.jetbrains.annotations.Nullable;
 * A function that parses a string into a node value object of type {@link T} with contextual information from the sender.
 *
 * @param <T>   The type of the object to parse.
+ *
+ * @since 5.1
 */
@ApiStatus.AvailableSince("5.1")
+@FunctionalInterface
 public interface SenderNodeStringParser<T> extends NodeStringParser<T> {
    /**
     * Parses a string into a node value object of type {@link T} with contextual information from the sender.
@@ -4,8 +4,9 @@ import io.vavr.control.Option;
 import org.bukkit.Location;
 import org.bukkit.entity.Entity;
 import org.bukkit.util.Vector;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
-import org.mvplugins.multiverse.core.utils.result.FailureReason;
+import org.mvplugins.multiverse.core.locale.message.Message;
 import org.mvplugins.multiverse.core.world.location.UnloadedWorldLocation;

 /**
@@ -79,6 +80,20 @@ public abstract class DestinationInstance<I extends  DestinationInstance<I, T>,
     */
    public abstract @NotNull Option<String> getFinerPermissionSuffix();

+    /**
+     * Gets a user-friendly display text for this destination instance. This is used when displaying the destination
+     * to the player. By default, this returns the same as {@link #toString()}. Override this method to provide a more
+     * user-friendly display text with colors, formatting and localization support.
+     *
+     * @return The display message.
+     * @since 5.4
+     */
+    @ApiStatus.AvailableSince("5.4")
+    @NotNull
+    public Message getDisplayMessage() {
+        return Message.of(this.toString());
+    }
+
    /**
     * Serialises the destination instance to a savable string.
     *
@@ -7,6 +7,10 @@ import org.bukkit.util.Vector;
 import org.jetbrains.annotations.NotNull;

 import org.mvplugins.multiverse.core.destination.DestinationInstance;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
+import org.mvplugins.multiverse.core.locale.message.Message;
+
+import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.replace;

 /**
 * Destination instance implementation for the {@link AnchorDestination}.
@@ -63,6 +67,14 @@ public final class AnchorDestinationInstance extends DestinationInstance<AnchorD
        return Option.of(anchorName);
    }

+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public @NotNull Message getDisplayMessage() {
+        return Message.of(MVCorei18n.DESTINATION_ANCHOR_DISPLAY, replace("{anchor}").with(anchorName));
+    }
+
    /**
     * {@inheritDoc}
     */
@@ -6,7 +6,7 @@ import java.util.stream.Collectors;

 import co.aikar.locales.MessageKey;
 import co.aikar.locales.MessageKeyProvider;
-import org.bukkit.Bukkit;
+import jakarta.inject.Inject;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
@@ -20,8 +20,7 @@ import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
 import org.mvplugins.multiverse.core.utils.PlayerFinder;
 import org.mvplugins.multiverse.core.utils.result.Attempt;
 import org.mvplugins.multiverse.core.utils.result.FailureReason;
-
-import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.replace;
+import org.mvplugins.multiverse.core.world.helpers.ConcurrentPlayerWorldTracker;

 /**
 * {@link Destination} implementation for beds.
@@ -30,7 +29,11 @@ import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.re
 public final class BedDestination implements Destination<BedDestination, BedDestinationInstance, BedDestination.InstanceFailureReason> {
    static final String OWN_BED_STRING = "playerbed";

-    BedDestination() {
+    private final ConcurrentPlayerWorldTracker worldTracker;
+
+    @Inject
+    BedDestination(@NotNull ConcurrentPlayerWorldTracker worldTracker) {
+        this.worldTracker = worldTracker;
    }

    /**
@@ -62,8 +65,8 @@ public final class BedDestination implements Destination<BedDestination, BedDest
    @Override
    public @NotNull Collection<DestinationSuggestionPacket> suggestDestinations(
            @NotNull CommandSender sender, @Nullable String destinationParams) {
-        List<DestinationSuggestionPacket> collect = Bukkit.getOnlinePlayers().stream()
-                .map(player -> new DestinationSuggestionPacket(this, player.getName(), player.getName()))
+        List<DestinationSuggestionPacket> collect = worldTracker.getOnlinePlayers().stream()
+                .map(player -> new DestinationSuggestionPacket(this, player, player))
                .collect(Collectors.toList());
        if (sender instanceof Player) {
            collect.add(new DestinationSuggestionPacket(this, OWN_BED_STRING, OWN_BED_STRING));
@@ -9,12 +9,15 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 import org.mvplugins.multiverse.core.destination.DestinationInstance;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
+import org.mvplugins.multiverse.core.locale.message.Message;
+import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;

 /**
 * Destination instance implementation for the {@link BedDestination}.
 */
 public final class BedDestinationInstance extends DestinationInstance<BedDestinationInstance, BedDestination> {
-    private final Player player;
+    private final @Nullable Player player;

    /**
     * Constructor.
@@ -64,6 +67,16 @@ public final class BedDestinationInstance extends DestinationInstance<BedDestina
        return Option.of(player != null ? player.getName() : BedDestination.OWN_BED_STRING);
    }

+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public @NotNull Message getDisplayMessage() {
+        return player == null
+                ? Message.of(MVCorei18n.DESTINATION_BED_DISPLAY_OWN)
+                : Message.of(MVCorei18n.DESTINATION_BED_DISPLAY_OTHER, Replace.PLAYER.with(player.getName()));
+    }
+
    /**
     * {@inheritDoc}
     */
@@ -23,14 +23,11 @@ import org.mvplugins.multiverse.core.exceptions.utils.position.PositionParseExce
 import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.utils.REPatterns;
 import org.mvplugins.multiverse.core.utils.position.EntityPosition;
-import org.mvplugins.multiverse.core.utils.position.PositionNumber;
-import org.mvplugins.multiverse.core.utils.position.VectorPosition;
 import org.mvplugins.multiverse.core.utils.result.Attempt;
 import org.mvplugins.multiverse.core.utils.result.FailureReason;
 import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
 import org.mvplugins.multiverse.core.world.WorldManager;
 import org.mvplugins.multiverse.core.world.entrycheck.WorldEntryCheckerProvider;
-import org.mvplugins.multiverse.core.world.location.UnloadedWorldLocation;

 import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.*;

@@ -68,6 +65,7 @@ public final class ExactDestination implements Destination<ExactDestination, Exa
    public @NotNull ExactDestinationInstance fromLocation(@NotNull Location location) {
        return new ExactDestinationInstance(
                this,
+                worldManager,
                location.getWorld().getName(),
                EntityPosition.ofLocation(location)
        );
@@ -88,6 +86,7 @@ public final class ExactDestination implements Destination<ExactDestination, Exa
                        .map(location -> Attempt.<ExactDestinationInstance, InstanceFailureReason>success(
                                new ExactDestinationInstance(
                                        this,
+                                        worldManager,
                                        location.getWorld().getName(),
                                        EntityPosition.ofLocation(location)
                                )
@@ -97,12 +96,14 @@ public final class ExactDestination implements Destination<ExactDestination, Exa
            return Attempt.failure(InstanceFailureReason.INVALID_FORMAT);
        }

-        String worldName = items[0];
+        String worldNameOrAlias = items[0];
        String positionStr = items[1];

-        World world = getLoadedMultiverseWorld(worldName).flatMap(LoadedMultiverseWorld::getBukkitWorld).getOrNull();
+        World world = getLoadedMultiverseWorld(worldNameOrAlias)
+                .flatMap(LoadedMultiverseWorld::getBukkitWorld)
+                .getOrNull();
        if (world == null) {
-            return Attempt.failure(InstanceFailureReason.WORLD_NOT_FOUND, Replace.WORLD.with(worldName));
+            return Attempt.failure(InstanceFailureReason.WORLD_NOT_FOUND, Replace.WORLD.with(worldNameOrAlias));
        }

        EntityPosition position;
@@ -112,7 +113,7 @@ public final class ExactDestination implements Destination<ExactDestination, Exa
            return Attempt.failure(InstanceFailureReason.INVALID_NUMBER_FORMAT, Replace.ERROR.with(e));
        }

-        return Attempt.success(new ExactDestinationInstance(this, worldName, position));
+        return Attempt.success(new ExactDestinationInstance(this, worldManager, world.getName(), position));
    }

    //TODO: Extract to a world finder class
@@ -9,14 +9,16 @@ import org.bukkit.util.Vector;
 import org.jetbrains.annotations.NotNull;

 import org.mvplugins.multiverse.core.destination.DestinationInstance;
+import org.mvplugins.multiverse.core.locale.message.Message;
 import org.mvplugins.multiverse.core.utils.position.EntityPosition;
-import org.mvplugins.multiverse.core.utils.position.VectorPosition;
-import org.mvplugins.multiverse.core.world.location.UnloadedWorldLocation;
+import org.mvplugins.multiverse.core.world.MultiverseWorld;
+import org.mvplugins.multiverse.core.world.WorldManager;

 /**
 * Destination instance implementation for the {@link ExactDestination}.
 */
 public final class ExactDestinationInstance extends DestinationInstance<ExactDestinationInstance, ExactDestination> {
+    private final WorldManager worldManager;
    private final String worldName;
    private final EntityPosition position;

@@ -28,9 +30,11 @@ public final class ExactDestinationInstance extends DestinationInstance<ExactDes
     * @param position    The position in the world.
     */
    ExactDestinationInstance(@NotNull ExactDestination destination,
+                             @NotNull WorldManager worldManager,
                             @NotNull String worldName,
                             @NotNull EntityPosition position) {
        super(destination);
+        this.worldManager = worldManager;
        this.worldName = worldName;
        this.position = position;
    }
@@ -73,6 +77,17 @@ public final class ExactDestinationInstance extends DestinationInstance<ExactDes
        return Option.of(worldName);
    }

+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public @NotNull Message getDisplayMessage() {
+        String displayWorldName = worldManager.getWorld(worldName)
+                .map(MultiverseWorld::getAliasOrName)
+                .getOrElse(worldName);
+        return Message.of(displayWorldName + " at " + position.toString());
+    }
+
    /**
     * {@inheritDoc}
     */
@@ -4,7 +4,7 @@ import java.util.Collection;

 import co.aikar.locales.MessageKey;
 import co.aikar.locales.MessageKeyProvider;
-import org.bukkit.Bukkit;
+import jakarta.inject.Inject;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
@@ -14,21 +14,26 @@ import org.jvnet.hk2.annotations.Service;
 import org.mvplugins.multiverse.core.destination.Destination;
 import org.mvplugins.multiverse.core.destination.DestinationSuggestionPacket;
 import org.mvplugins.multiverse.core.locale.MVCorei18n;
-import org.mvplugins.multiverse.core.locale.message.MessageReplacement;
 import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
 import org.mvplugins.multiverse.core.utils.PlayerFinder;
 import org.mvplugins.multiverse.core.utils.result.Attempt;
 import org.mvplugins.multiverse.core.utils.result.FailureReason;
+import org.mvplugins.multiverse.core.world.helpers.ConcurrentPlayerWorldTracker;

 /**
 * {@link Destination} implementation for players.s
 */
@Service
 public final class PlayerDestination implements Destination<PlayerDestination, PlayerDestinationInstance, PlayerDestination.InstanceFailureReason> {
+
+    private final ConcurrentPlayerWorldTracker playerWorldTracker;
+
    /**
     * Creates a new instance of the PlayerDestination.
     */
-    PlayerDestination() {
+    @Inject
+    PlayerDestination(@NotNull ConcurrentPlayerWorldTracker playerWorldTracker) {
+        this.playerWorldTracker = playerWorldTracker;
    }

    /**
@@ -60,8 +65,8 @@ public final class PlayerDestination implements Destination<PlayerDestination, P
    @Override
    public @NotNull Collection<DestinationSuggestionPacket> suggestDestinations(
            @NotNull CommandSender sender, @Nullable String destinationParams) {
-        return Bukkit.getOnlinePlayers().stream()
-                .map(p -> new DestinationSuggestionPacket(this, p.getName(), p.getName()))
+        return playerWorldTracker.getOnlinePlayers().stream()
+                .map(player -> new DestinationSuggestionPacket(this, player, player))
                .toList();
    }

@@ -9,6 +9,7 @@ import org.bukkit.util.Vector;
 import org.jetbrains.annotations.NotNull;

 import org.mvplugins.multiverse.core.destination.DestinationInstance;
+import org.mvplugins.multiverse.core.locale.message.Message;

 import java.util.UUID;

@@ -66,6 +67,14 @@ public final class PlayerDestinationInstance extends DestinationInstance<PlayerD
        return Option.of(playerName);
    }

+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public @NotNull Message getDisplayMessage() {
+        return Message.of(playerName);
+    }
+
    /**
     * {@inheritDoc}
     */
@@ -6,6 +6,7 @@ import co.aikar.locales.MessageKey;
 import co.aikar.locales.MessageKeyProvider;
 import jakarta.inject.Inject;
 import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jvnet.hk2.annotations.Service;
@@ -14,13 +15,11 @@ import org.mvplugins.multiverse.core.config.CoreConfig;
 import org.mvplugins.multiverse.core.destination.Destination;
 import org.mvplugins.multiverse.core.destination.DestinationSuggestionPacket;
 import org.mvplugins.multiverse.core.locale.MVCorei18n;
-import org.mvplugins.multiverse.core.locale.message.MessageReplacement;
 import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
 import org.mvplugins.multiverse.core.teleportation.LocationManipulation;
 import org.mvplugins.multiverse.core.utils.REPatterns;
 import org.mvplugins.multiverse.core.utils.result.Attempt;
 import org.mvplugins.multiverse.core.utils.result.FailureReason;
-import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
 import org.mvplugins.multiverse.core.world.MultiverseWorld;
 import org.mvplugins.multiverse.core.world.WorldManager;
 import org.mvplugins.multiverse.core.world.entrycheck.WorldEntryCheckerProvider;
@@ -56,6 +55,19 @@ public final class WorldDestination implements Destination<WorldDestination, Wor
        return "w";
    }

+    /**
+     * Directly create a world destination instance for a Multiverse World without any string parsing validation needed.
+     *
+     * @param multiverseWorld   The destination's target world.
+     * @return The destination instance with the target world.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public @NotNull WorldDestinationInstance fromWorld(MultiverseWorld multiverseWorld) {
+        return new WorldDestinationInstance(this, multiverseWorld, null, -1.0f);
+    }
+
    /**
     * {@inheritDoc}
     */
@@ -8,12 +8,9 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 import org.mvplugins.multiverse.core.destination.DestinationInstance;
-import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
+import org.mvplugins.multiverse.core.locale.message.Message;
 import org.mvplugins.multiverse.core.world.MultiverseWorld;

-import java.lang.ref.Reference;
-import java.lang.ref.WeakReference;
-
 /**
 * Destination instance implementation for the {@link WorldDestination}.
 */
@@ -87,6 +84,14 @@ public final class WorldDestinationInstance extends DestinationInstance<WorldDes
        return Option.of(world.getName());
    }

+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public @NotNull Message getDisplayMessage() {
+        return Message.of(world.getAliasOrName());
+    }
+
    /**
     * {@inheritDoc}
     */
@@ -2,8 +2,6 @@ package org.mvplugins.multiverse.core.display.handlers;

 import java.util.List;

-import co.aikar.commands.BukkitCommandIssuer;
-import org.bukkit.ChatColor;
 import org.bukkit.command.ConsoleCommandSender;
 import org.jetbrains.annotations.NotNull;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
@@ -69,12 +67,12 @@ public class PagedSendHandler extends BaseSendHandler<PagedSendHandler> {
    private void sendPaged(@NotNull MVCommandIssuer issuer, @NotNull List<String> content) {
        int totalPages = (content.size() + linesPerPage - 1) / linesPerPage; // Basically just divide round up
        if (targetPage < 1 || targetPage > totalPages) {
-            issuer.sendMessage(String.format("%sInvalid page number. Please enter a page number between 1 and %s", ChatColor.RED, totalPages));
+            issuer.sendMessage(MVCorei18n.CONTENTDISPLAY_INVALIDPAGE, replace("{total}").with(totalPages));
            return;
        }

        if (filter.needToFilter()) {
-            issuer.sendMessage("{page} {filter}",
+            issuer.sendMessage(MVCorei18n.CONTENTDISPLAY_PAGEFILTER,
                    replace("{page}").with(Message.of(MVCorei18n.CONTENTDISPLAY_PAGE,
                            replace("{current}").with(targetPage),
                            replace("{total}").with(totalPages))),
@@ -35,7 +35,7 @@ public final class DynamicListenerRegistration {
    private static final boolean hasEventExecutorCreate;

    static {
-        hasEventExecutorCreate = ReflectHelper.getMethod(EventExecutor.class, "create", Method.class, Class.class) != null;
+        hasEventExecutorCreate = ReflectHelper.hasMethod(EventExecutor.class, "create", Method.class, Class.class);
    }

    private final EventPriorityMapper eventPriorityMapper;
@@ -98,18 +98,22 @@ public final class DynamicListenerRegistration {
        }

        method.setAccessible(true);
-        Object methodOutput = ReflectHelper.invokeMethod(listener, method);
-        if (!(methodOutput instanceof EventRunnable eventRunnable)) {
-            Logging.warning("Event method %s in %s did not return a SingleEventListener",
-                    method.getName(), listener.getClass().getName());
-            return;
-        }
-        EventExecutor executor = new EventRunnableExecutor<>(eventClass, eventRunnable);
-        EventPriority priority = getDynamicEventPriority(method);
-        boolean ignoreCancelled = isIgnoreIfCancelled(method);

-        Logging.finest("Registering dynamic event for %s with priority %s", eventClass.getName(), priority);
-        Bukkit.getPluginManager().registerEvent(eventClass, listener, priority, executor, plugin, ignoreCancelled);
+        ReflectHelper.tryInvokeMethod(listener, method)
+                .onFailure(e -> Logging.warning("Failed to invoke event method %s in %s: $s",
+                        method.getName(), listener.getClass().getName(), e.getMessage()))
+                .filter(EventRunnable.class::isInstance)
+                .onFailure(e -> Logging.warning("Event method %s in %s did not return an EventRunnable instance!",
+                        method.getName(), listener.getClass().getName()))
+                .map(EventRunnable.class::cast)
+                .map(eventRunnable -> new EventRunnableExecutor<>(eventClass, eventRunnable))
+                .peek(executor -> {
+                    EventPriority priority = getDynamicEventPriority(method);
+                    boolean ignoreCancelled = isIgnoreIfCancelled(method);
+                    Bukkit.getPluginManager().registerEvent(eventClass, listener, priority, executor, plugin, ignoreCancelled);
+                    Logging.finest("Registered dynamic event: %s, priority: %s, ignore if cancelled: %s",
+                            eventClass.getName(), priority, ignoreCancelled);
+                });
    }

    private Class<? extends Event> getEventClass(Method method) {
@@ -129,13 +133,12 @@ public final class DynamicListenerRegistration {
    }

    private Class<? extends Event> getEventClassFromString(String className) {
-        Class<?> annotatedClass = ReflectHelper.getClass(className);
-        if (annotatedClass == null || !Event.class.isAssignableFrom(annotatedClass)) {
-            // Usually means the server software used did not implement the event
-            Logging.fine("Event class does not exist: %s", className);
-            return null;
-        }
-        return annotatedClass.asSubclass(Event.class);
+        return ReflectHelper.tryGetClass(className)
+                .onFailure(throwable -> Logging.fine("Failed to find event class: %s", className))
+                .filter(Event.class::isAssignableFrom)
+                .onFailure(throwable -> Logging.warning("Class is not an Event: %s", className))
+                .map(clazz -> (Class<? extends Event>) clazz.asSubclass(Event.class))
+                .getOrNull();
    }

    private EventPriority getDynamicEventPriority(Method method) {
@@ -7,6 +7,7 @@ import java.io.FileReader;
 import java.io.IOException;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.Map;

 import com.dumptruckman.minecraft.util.Logging;
@@ -24,7 +25,7 @@ public final class MVDumpsDebugInfoEvent extends Event {

    public MVDumpsDebugInfoEvent() {
        debugInfoBuilder = new StringBuilder();
-        detailedDebugInfo = new HashMap<>();
+        detailedDebugInfo = new LinkedHashMap<>();
    }

    private static final HandlerList HANDLERS = new HandlerList();
@@ -1,8 +1,11 @@
 package org.mvplugins.multiverse.core.event.world;

 import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
+import org.mvplugins.multiverse.core.world.MultiverseWorld;

 /**
 * Called when a world has been successfully cloned.
@@ -10,14 +13,24 @@ import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
 public final class MVWorldClonedEvent extends MultiverseWorldEvent<LoadedMultiverseWorld> {
    private static final HandlerList HANDLERS = new HandlerList();

-    private final LoadedMultiverseWorld fromWorld;
+    private final MultiverseWorld fromWorld;

-    public MVWorldClonedEvent(LoadedMultiverseWorld world, LoadedMultiverseWorld fromWorld) {
+    public MVWorldClonedEvent(LoadedMultiverseWorld world, MultiverseWorld fromWorld) {
        super(world);
        this.fromWorld = fromWorld;
    }

-    public LoadedMultiverseWorld getFromWorld() {
+    /**
+     * @deprecated Cloning can be done from unloaded worlds as well. Use {@link #getSourceWorld()} instead.
+     */
+    @Deprecated(forRemoval = true, since = "5.6")
+    @ApiStatus.ScheduledForRemoval(inVersion = "6.0")
+    public @Nullable LoadedMultiverseWorld getFromWorld() {
+        return fromWorld.asLoadedWorld().getOrNull();
+    }
+
+    @ApiStatus.AvailableSince("5.6")
+    public @NotNull MultiverseWorld getSourceWorld() {
        return fromWorld;
    }

@@ -37,5 +50,4 @@ public final class MVWorldClonedEvent extends MultiverseWorldEvent<LoadedMultive
    public static HandlerList getHandlerList() {
        return HANDLERS;
    }
-
 }
@@ -1,6 +1,5 @@
 package org.mvplugins.multiverse.core.exceptions;

-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 import org.mvplugins.multiverse.core.locale.message.LocalizableMessage;
@@ -1,6 +1,9 @@
 package org.mvplugins.multiverse.core.exceptions.command;

 import co.aikar.commands.InvalidCommandArgument;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.mvplugins.multiverse.core.locale.message.LocalizableMessage;
 import org.mvplugins.multiverse.core.locale.message.LocalizedMessage;
 import org.mvplugins.multiverse.core.locale.message.Message;

@@ -9,21 +12,41 @@ import org.mvplugins.multiverse.core.locale.message.Message;
 */
 public class MVInvalidCommandArgument extends InvalidCommandArgument {

-    public static MVInvalidCommandArgument of(Message message) {
+    @ApiStatus.AvailableSince("5.7")
+    public static MVInvalidCommandArgument causeBy(Throwable throwable) {
+        return causeBy(throwable, true);
+    }
+
+    @ApiStatus.AvailableSince("5.7")
+    public static MVInvalidCommandArgument causeBy(Throwable throwable, boolean showSyntax) {
+        if (throwable instanceof LocalizableMessage localizableMessage) {
+            Message message = localizableMessage.getLocalizableMessage();
+            return message == null
+                    ? new MVInvalidCommandArgument(throwable.getLocalizedMessage(), showSyntax)
+                    : of(message, showSyntax);
+        }
+        return new MVInvalidCommandArgument(throwable.getLocalizedMessage(), showSyntax);
+    }
+
+    public static MVInvalidCommandArgument of(@NotNull Message message) {
        return of(message, true);
    }

-    public static MVInvalidCommandArgument of(Message message, boolean showSyntax) {
+    public static MVInvalidCommandArgument of(@NotNull Message message, boolean showSyntax) {
        return message instanceof LocalizedMessage
                ? new MVInvalidCommandArgument((LocalizedMessage) message, showSyntax)
                : new MVInvalidCommandArgument(message, showSyntax);
    }

+    private MVInvalidCommandArgument(String message, boolean showSyntax) {
+        super(message, showSyntax);
+    }
+
    private MVInvalidCommandArgument(Message message, boolean showSyntax) {
        super(message.formatted(), showSyntax);
    }

    private MVInvalidCommandArgument(LocalizedMessage message, boolean showSyntax) {
-        super(message.getMessageKey(), showSyntax, message.getReplacements());
+        super(message.getMessageKey(), showSyntax, message.getRawReplacements());
    }
 }
@@ -16,6 +16,7 @@ import org.mvplugins.multiverse.core.dynamiclistener.annotations.IgnoreIfCancell
 import org.mvplugins.multiverse.core.dynamiclistener.annotations.SkipIfEventExist;
 import org.mvplugins.multiverse.core.utils.text.ChatTextFormatter;
 import org.mvplugins.multiverse.core.world.WorldManager;
+import org.mvplugins.multiverse.core.world.helpers.ConcurrentPlayerWorldTracker;

 /**
 * Multiverse's Listener for players.
@@ -24,16 +25,17 @@ import org.mvplugins.multiverse.core.world.WorldManager;
 final class MVChatListener implements CoreListener {
    private final CoreConfig config;
    private final WorldManager worldManager;
-    private final MVPlayerListener playerListener;
+    private final ConcurrentPlayerWorldTracker playerWorldTracker;

    @Inject
    MVChatListener(
            CoreConfig config,
            WorldManager worldManager,
-            MVPlayerListener playerListener) {
+            ConcurrentPlayerWorldTracker playerWorldTracker
+    ) {
        this.config = config;
        this.worldManager = worldManager;
-        this.playerListener = playerListener;
+        this.playerWorldTracker = playerWorldTracker;
    }

    @EventClass("io.papermc.paper.event.player.AsyncChatEvent")
@@ -94,12 +96,9 @@ final class MVChatListener implements CoreListener {
    }

    private String getWorldName(Player player) {
-        String world = playerListener.getPlayerWorld().get(player.getName());
-        if (world == null) {
-            world = player.getWorld().getName();
-            playerListener.getPlayerWorld().put(player.getName(), world);
-        }
-        return this.worldManager.getLoadedWorld(world)
+        String worldName = playerWorldTracker.getPlayerWorld(player.getName())
+                .getOrElse(() -> player.getWorld().getName());
+        return this.worldManager.getLoadedWorld(worldName)
                .map(mvworld -> mvworld.isHidden() ? "" : mvworld.getAliasOrName())
                .getOrElse("");
    }
@@ -7,8 +7,10 @@

 package org.mvplugins.multiverse.core.listeners;

+import com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent;
 import com.dumptruckman.minecraft.util.Logging;
 import jakarta.inject.Inject;
+import org.bukkit.entity.Entity;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.Listener;
@@ -18,12 +20,19 @@ import org.bukkit.event.entity.EntityRegainHealthEvent;
 import org.bukkit.event.entity.EntityRegainHealthEvent.RegainReason;
 import org.bukkit.event.entity.EntitySpawnEvent;
 import org.bukkit.event.entity.FoodLevelChangeEvent;
+import org.bukkit.event.world.ChunkLoadEvent;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jvnet.hk2.annotations.Service;

+import org.mvplugins.multiverse.core.dynamiclistener.EventRunnable;
+import org.mvplugins.multiverse.core.dynamiclistener.annotations.EventClass;
 import org.mvplugins.multiverse.core.dynamiclistener.annotations.EventMethod;
+import org.mvplugins.multiverse.core.utils.compatibility.EntityCompatibility;
 import org.mvplugins.multiverse.core.world.WorldManager;

+import java.util.Arrays;
+
 /**
 * Multiverse's Entity {@link Listener}.
 */
@@ -77,6 +86,34 @@ final class MVEntityListener implements CoreListener {
                });
    }

+    /**
+     * Fired before other spawn checks is done, helps in performance by cancelling early and preventing unnecessary
+     * checks for spawn reasons that are not allowed in the world.
+     *
+     * @return Event wrapper
+     */
+    @EventClass("com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent")
+    EventRunnable<?> preCreatureSpawn() {
+        return new EventRunnable<PreCreatureSpawnEvent>() {
+            @Override
+            public void onEvent(PreCreatureSpawnEvent event) {
+                // Always allow custom command and plugins to spawn creatures
+                if (isAlwaysAllowedSpawnReason(event.getReason())) {
+                    return;
+                }
+
+                worldManager.getLoadedWorld(event.getSpawnLocation().getWorld())
+                        .peek(world -> {
+                            if (!world.getEntitySpawnConfig().shouldAllowSpawn(event.getType())) {
+                                Logging.finest("Cancelling Pre Creature Spawn Event for: " + event.getType());
+                                event.setCancelled(true);
+                                event.setShouldAbortSpawn(true);
+                            }
+                        });
+            }
+        };
+    }
+
    /**
     * Handle Spawn Category settings.
     *
@@ -89,16 +126,13 @@ final class MVEntityListener implements CoreListener {
        }

        // Always allow custom command and plugins to spawn creatures
-        if (event.getSpawnReason() == SpawnReason.CUSTOM
-                || event.getSpawnReason() == SpawnReason.COMMAND
-                || event.getSpawnReason() == SpawnReason.BREEDING
-                || event.getSpawnReason() == SpawnReason.SPAWNER_EGG) {
+        if (isAlwaysAllowedSpawnReason(event.getSpawnReason())) {
            return;
        }

        worldManager.getLoadedWorld(event.getEntity().getWorld())
                .peek(world -> {
-                    if (!world.getEntitySpawnConfig().shouldAllowSpawn(event.getEntity())) {
+                    if (!world.getEntitySpawnConfig().shouldAllowSpawn(event.getEntityType())) {
                        Logging.finest("Cancelling Creature Spawn Event for: " + event.getEntity());
                        event.setCancelled(true);
                    }
@@ -117,10 +151,34 @@ final class MVEntityListener implements CoreListener {

        worldManager.getLoadedWorld(event.getEntity().getWorld())
                .peek(world -> {
-                    if (!world.getEntitySpawnConfig().shouldAllowSpawn(event.getEntity())) {
+                    if (!world.getEntitySpawnConfig().shouldAllowSpawn(event.getEntityType())) {
                        Logging.finest("Cancelling Entity Spawn Event for: " + event.getEntity());
                        event.setCancelled(true);
                    }
                });
    }
+
+    @EventMethod
+    void chunkLoad(ChunkLoadEvent event) {
+        worldManager.getLoadedWorld(event.getWorld())
+                .peek(world -> {
+                    long count = Arrays.stream(event.getChunk().getEntities())
+                            .filter(entity -> !(entity instanceof Player))
+                            .filter(entity -> !isAlwaysAllowedSpawnReason(EntityCompatibility.getEntitySpawnReason(entity)))
+                            .filter(entity -> !world.getEntitySpawnConfig().shouldAllowSpawn(entity))
+                            .peek(Entity::remove)
+                            .count();
+                    if (count > 0) {
+                        Logging.finest("Removed %d entities from chunk %d, %d in world %s due to spawn category settings.",
+                                count, event.getChunk().getX(), event.getChunk().getZ(), event.getWorld().getName());
+                    }
+                });
+    }
+
+    private boolean isAlwaysAllowedSpawnReason(@Nullable SpawnReason reason) {
+        return reason == SpawnReason.CUSTOM
+                || reason == SpawnReason.COMMAND
+                || reason == SpawnReason.BREEDING
+                || reason == SpawnReason.SPAWNER_EGG;
+    }
 }
@@ -7,9 +7,7 @@

 package org.mvplugins.multiverse.core.listeners;

-import java.util.Map;
 import java.util.Objects;
-import java.util.concurrent.ConcurrentHashMap;

 import com.dumptruckman.minecraft.util.Logging;
 import io.vavr.control.Option;
@@ -38,6 +36,7 @@ import org.mvplugins.multiverse.core.destination.DestinationsProvider;
 import org.mvplugins.multiverse.core.dynamiclistener.annotations.DefaultEventPriority;
 import org.mvplugins.multiverse.core.dynamiclistener.annotations.EventMethod;
 import org.mvplugins.multiverse.core.dynamiclistener.annotations.EventPriorityKey;
+import org.mvplugins.multiverse.core.dynamiclistener.annotations.IgnoreIfCancelled;
 import org.mvplugins.multiverse.core.economy.MVEconomist;
 import org.mvplugins.multiverse.core.event.MVRespawnEvent;
 import org.mvplugins.multiverse.core.locale.PluginLocales;
@@ -74,8 +73,6 @@ final class MVPlayerListener implements CoreListener {
    private final CorePermissionsChecker corePermissionsChecker;
    private final AsyncSafetyTeleporter asyncSafetyTeleporter;

-    private final Map<String, String> playerWorld = new ConcurrentHashMap<>();
-
    @Inject
    MVPlayerListener(
            MultiverseCore plugin,
@@ -120,15 +117,6 @@ final class MVPlayerListener implements CoreListener {
        return getCommandManager().getLocales();
    }

-    /**
-     * Gets the map of player and the world name they are in.
-     *
-     * @return the playerWorld-map
-     */
-    Map<String, String> getPlayerWorld() {
-        return playerWorld;
-    }
-
    /**
     * This method is called when a player respawns.
     *
@@ -256,11 +244,11 @@ final class MVPlayerListener implements CoreListener {
    }

    private void teleportToDestinationOnJoin(Player player, DestinationInstance<?, ?> destination) {
-        asyncSafetyTeleporter.to(destination).teleportSingle(player)
+        asyncSafetyTeleporter.to(destination).passengerMode(config.getPassengerMode()).teleportSingle(player)
                .onSuccess(result -> Logging.fine("Player %s has been teleported on join",
                        player.getName()))
                .onFailure(failure -> Logging.warning("Failed to teleport player %s on join: %s",
-                        player.getName(), failure.getFirst()));
+                        player.getName(), failure.get(0)));
    }

    /**
@@ -268,11 +256,10 @@ final class MVPlayerListener implements CoreListener {
     * @param event The Event that was fired.
     */
    @EventMethod
-    @DefaultEventPriority(EventPriority.MONITOR)
+    @EventPriorityKey("mvcore-player-changed-world")
+    @DefaultEventPriority(EventPriority.NORMAL)
    void playerChangedWorld(PlayerChangedWorldEvent event) {
-        // Permissions now determine whether or not to handle a gamemode.
        this.handleGameModeAndFlight(event.getPlayer(), event.getPlayer().getWorld());
-        playerWorld.put(event.getPlayer().getName(), event.getPlayer().getWorld().getName());
    }

    /**
@@ -283,12 +270,28 @@ final class MVPlayerListener implements CoreListener {
    @EventPriorityKey("mvcore-player-teleport")
    @DefaultEventPriority(EventPriority.HIGHEST)
    void playerTeleport(PlayerTeleportEvent event) {
-        Logging.finer("Got teleport event for player '"
-                + event.getPlayer().getName() + "' with cause '" + event.getCause() + "'");
+        Player teleportee = event.getPlayer();
+
        if (event.isCancelled()) {
+            Logging.finer("Teleport event for player '" + teleportee.getName() + "' was already cancelled.");
            return;
        }
-        Player teleportee = event.getPlayer();
+
+        Logging.finer("Got teleport event for player '"
+                + teleportee.getName() + "' with cause '" + event.getCause() + "'");
+
+        Location fromLocation = event.getFrom();
+        if (fromLocation == null || fromLocation.getWorld() == null) { // should never be null, but just in case
+            Logging.finer("Teleport event for player '" + teleportee.getName() + "' has null from-location or world.");
+            return;
+        }
+
+        Location toLocation = event.getTo();
+        if (toLocation == null || toLocation.getWorld() == null) { // may be null on spigot
+            Logging.finer("Teleport event for player '" + teleportee.getName() + "' has null to-location or world.");
+            return;
+        }
+
        Option<String> teleporterName = teleportQueue.popFromQueue(teleportee.getName());
        CommandSender teleporter = teleporterName.map(name -> {
            if (name.equalsIgnoreCase("CONSOLE")) {
@@ -309,17 +312,17 @@ final class MVPlayerListener implements CoreListener {
        }

        Logging.finer("Teleporter %s is teleporting %s from %s to %s", teleporter.getName(), teleportee.getName(),
-                event.getFrom(), event.getTo());
+                fromLocation, toLocation);

-        MultiverseWorld fromWorld = getWorldManager().getLoadedWorld(event.getFrom().getWorld()).getOrNull();
-        LoadedMultiverseWorld toWorld = getWorldManager().getLoadedWorld(event.getTo().getWorld()).getOrNull();
+        MultiverseWorld fromWorld = getWorldManager().getLoadedWorld(fromLocation.getWorld()).getOrNull();
+        LoadedMultiverseWorld toWorld = getWorldManager().getLoadedWorld(toLocation.getWorld()).getOrNull();
        if (toWorld == null) {
            Logging.fine("Player '" + teleportee.getName() + "' is teleporting to world '"
-                    + event.getTo().getWorld().getName() + "' which is not managed by Multiverse-Core.  No further "
+                    + toLocation.getWorld().getName() + "' which is not managed by Multiverse-Core.  No further "
                    + "actions will be taken by Multiverse-Core.");
            return;
        }
-        if (event.getFrom().getWorld().equals(event.getTo().getWorld())) {
+        if (fromLocation.getWorld().equals(toLocation.getWorld())) {
            // The player is Teleporting to the same world.
            Logging.finer("Player '" + teleportee.getName() + "' is teleporting to the same world.");
            this.stateSuccess(teleportee.getName(), toWorld.getName());
@@ -353,20 +356,19 @@ final class MVPlayerListener implements CoreListener {
     */
    @EventMethod
    @DefaultEventPriority(EventPriority.LOWEST)
+    @IgnoreIfCancelled
    void playerPortalCheck(PlayerPortalEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
-        if (event.getFrom().getWorld() == null) {
+        Location fromLocation = event.getFrom();
+        if (fromLocation == null || fromLocation.getWorld() == null) {
            Logging.warning("PlayerPortalEvent's from world is null!");
            return;
        }
-        if (event.getFrom().getWorld().getBlockAt(event.getFrom()).getType() == Material.NETHER_PORTAL) {
+        if (fromLocation.getWorld().getBlockAt(fromLocation).getType() == Material.NETHER_PORTAL) {
            return;
        }

        // Player was actually outside of the portal, adjust the from location
-        Location newLocation = blockSafety.findPortalBlockNextTo(event.getFrom());
+        Location newLocation = blockSafety.findPortalBlockNextTo(fromLocation);
        if (newLocation != null) {
            event.setFrom(newLocation);
        }
@@ -379,28 +381,33 @@ final class MVPlayerListener implements CoreListener {
    @EventMethod
    @EventPriorityKey("mvcore-player-portal")
    @DefaultEventPriority(EventPriority.HIGH)
+    @IgnoreIfCancelled
    void playerPortal(PlayerPortalEvent event) {
-        if (event.isCancelled()) {
+        Location fromLocation = event.getFrom();
+        if (fromLocation == null || fromLocation.getWorld() == null) { // should never be null, but just in case
+            Logging.finer("PlayerPortalEvent's from world is null!");
            return;
        }
-        if (event.getTo() == null || event.getTo().getWorld() == null) {
+
+        Location toLocation = event.getTo();
+        if (toLocation == null || toLocation.getWorld() == null) { // may be null on spigot
            Logging.finer("PlayerPortalEvent's to world is null!");
            return;
        }
        if (config.isUsingCustomPortalSearch()) {
            event.setSearchRadius(config.getCustomPortalSearchRadius());
        }
-        if (Objects.equals(event.getFrom().getWorld(), event.getTo().getWorld())) {
+        if (Objects.equals(fromLocation.getWorld(), toLocation.getWorld())) {
            // The player is Portaling to the same world.
            Logging.finer("Player '" + event.getPlayer().getName() + "' is portaling to the same world.");
            return;
        }

-        MultiverseWorld fromWorld = getWorldManager().getLoadedWorld(event.getFrom().getWorld()).getOrNull();
-        LoadedMultiverseWorld toWorld = getWorldManager().getLoadedWorld(event.getTo().getWorld()).getOrNull();
+        MultiverseWorld fromWorld = getWorldManager().getLoadedWorld(fromLocation.getWorld()).getOrNull();
+        LoadedMultiverseWorld toWorld = getWorldManager().getLoadedWorld(toLocation.getWorld()).getOrNull();
        if (toWorld == null) {
            Logging.fine("Player '" + event.getPlayer().getName() + "' is portaling to world '"
-                    + event.getTo().getWorld().getName() + "' which is not managed by Multiverse-Core.  No further "
+                    + toLocation.getWorld().getName() + "' which is not managed by Multiverse-Core.  No further "
                    + "actions will be taken by Multiverse-Core.");
            return;
        }
@@ -414,21 +421,31 @@ final class MVPlayerListener implements CoreListener {
    }

    /**
-     * Handles the gamemode for the specified {@link Player}.
+     * Handles the gamemode for the specified {@link Player}. Delays the enforcement if configured to do so
+     * to ensure multiverse has final say over other plugins changing gamemodes.
     *
     * @param player The {@link Player}.
     * @param world  The {@link World} the player is supposed to be in.
     */
    private void handleGameModeAndFlight(final Player player, World world) {
-        // We perform this task one tick later to MAKE SURE that the player actually reaches the
-        // destination world, otherwise we'd be changing the player mode if they havent moved anywhere.
-        this.server.getScheduler().runTaskLater(this.plugin, () -> {
-            if (!player.isOnline() || !player.getWorld().equals(world)) {
-                return;
-            }
-            Logging.finer("Handling gamemode and flight for player %s in world '%s'", player.getName(), world.getName());
-            enforcementHandler.handleFlightEnforcement(player);
-            enforcementHandler.handleGameModeEnforcement(player);
-        }, 1L);
+        if (config.getGamemodeAndFlightEnforceDelay() <= 0) {
+            doGameModeAndFlightEnforcement(player, world);
+            return;
+        }
+        server.getScheduler().runTaskLater(
+                this.plugin,
+                () -> doGameModeAndFlightEnforcement(player, world),
+                config.getGamemodeAndFlightEnforceDelay()
+        );
+    }
+
+    private void doGameModeAndFlightEnforcement(Player player, World world) {
+        if (!player.isOnline() || !player.getWorld().equals(world)) {
+            Logging.finer("Player %s is no longer online or not in the expected world '%s'", player.getName(), world.getName());
+            return;
+        }
+        Logging.finer("Handling gamemode and flight for player %s in world '%s'", player.getName(), world.getName());
+        enforcementHandler.handleFlightEnforcement(player);
+        enforcementHandler.handleGameModeEnforcement(player);
    }
 }
@@ -18,9 +18,11 @@ import org.bukkit.event.player.PlayerInteractEvent;
 import org.bukkit.event.world.PortalCreateEvent;
 import org.jetbrains.annotations.NotNull;
 import org.jvnet.hk2.annotations.Service;
+import org.mvplugins.multiverse.core.command.MVCommandManager;
 import org.mvplugins.multiverse.core.config.CoreConfig;
 import org.mvplugins.multiverse.core.dynamiclistener.annotations.EventMethod;
 import org.mvplugins.multiverse.core.dynamiclistener.annotations.IgnoreIfCancelled;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.world.WorldManager;

 import static org.bukkit.PortalType.CUSTOM;
@@ -33,11 +35,15 @@ final class MVPortalListener implements CoreListener {

    private final CoreConfig config;
    private final WorldManager worldManager;
+    private final MVCommandManager commandManager;

    @Inject
-    MVPortalListener(@NotNull CoreConfig config, @NotNull WorldManager worldManager) {
+    MVPortalListener(@NotNull CoreConfig config,
+                     @NotNull WorldManager worldManager,
+                     @NotNull MVCommandManager commandManager) {
        this.config = config;
        this.worldManager = worldManager;
+        this.commandManager = commandManager;
    }

    /**
@@ -59,6 +65,7 @@ final class MVPortalListener implements CoreListener {
            if (!world.getPortalForm().isPortalAllowed(targetType)) {
                Logging.fine("Cancelling creation of %s portal because portalForm disallows.", targetType);
                event.setCancelled(true);
+                commandManager.getCommandIssuer(event.getEntity()).sendError(MVCorei18n.PORTALFORM_DISABLED_NETHER);
            }
        }).onEmpty(() ->
                Logging.fine("World '%s' is not managed by Multiverse! Ignoring at PortalCreateEvent.",
@@ -101,6 +108,7 @@ final class MVPortalListener implements CoreListener {
            if (!world.getPortalForm().isPortalAllowed(PortalType.ENDER)) {
                Logging.fine("Cancelling creation of ENDER portal because portalForm disallows.");
                event.setCancelled(true);
+                commandManager.getCommandIssuer(event.getPlayer()).sendError(MVCorei18n.PORTALFORM_DISABLED_END);
            }
        }).onEmpty(() ->
                Logging.fine("World '%s' is not managed by Multiverse! Ignoring at PlayerInteractEvent.",
@@ -20,6 +20,25 @@ public enum MVCorei18n implements MessageKeyProvider {
    // configuration
    CONFIG_SAVE_FAILED,
    CONFIG_NODE_NOTFOUND,
+    CONFIG_NODE_INVALIDYAMLKEY,
+    CONFIG_STRING_PARSER_INVALIDBOOLEAN,
+    CONFIG_STRING_PARSER_INVALIDINTEGER,
+    CONFIG_STRING_PARSER_INVALIDDOUBLE,
+    CONFIG_STRING_PARSER_INVALIDFLOAT,
+    CONFIG_STRING_PARSER_INVALIDLONG,
+
+    // core config
+    CORE_CONFIG_CUSTOMPORTALSEARCHRADIUS_NONNEGATIVE,
+    CORE_CONFIG_CONFIRMTIMEOUT_POSITIVE,
+    CORE_CONFIG_DEBUGLEVEL_RANGE,
+
+    // /mv anchor
+    ANCHOR_DELETE_SUCCESS,
+    ANCHOR_DELETE_FAILURE,
+    ANCHOR_LIST_HEADER,
+    ANCHOR_LIST_ENTRY,
+    ANCHOR_SET_SUCCESS,
+    ANCHOR_SET_FAILURE,

    // /mv check
    CHECK_DESCRIPTION,
@@ -91,8 +110,18 @@ public enum MVCorei18n implements MessageKeyProvider {

    // /mv dumps
    DUMPS_DESCRIPTION,
+    DUMPS_STARTING,
    DUMPS_URL_LIST,

+    // /mv entity-spawn-config
+    ENTITYSPAWNCONFIG_INFO_HEADER,
+    ENTITYSPAWNCONFIG_INFO_CATEGORY,
+    ENTITYSPAWNCONFIG_INFO_SPAWN,
+    ENTITYSPAWNCONFIG_INFO_TICKRATE,
+    ENTITYSPAWNCONFIG_INFO_EXCEPTIONS,
+    ENTITYSPAWNCONFIG_MODIFY_SUCCESS,
+    ENTITYSPAWNCONFIG_MODIFY_FAILURE,
+
    // /mv gamerule set
    GAMERULE_SET_DESCRIPTION,
    GAMERULE_SET_GAMERULE_DESCRIPTION,
@@ -119,7 +148,12 @@ public enum MVCorei18n implements MessageKeyProvider {
    // /mv generators
    GENERATORS_DESCRIPTION,
    GENERATORS_DESCRIPTION_FLAGS,
+    GENERATORS_HEADER,
    GENERATORS_EMPTY,
+    GENERATORS_INFO_PLUGIN,
+    GENERATORS_INFO_EXAMPLEUSAGES,
+    GENERATORS_INFO_USAGES,
+    GENERATORS_INFO_INFOLINK,

    // /mv import
    IMPORT_DESCRIPTION,
@@ -146,6 +180,19 @@ public enum MVCorei18n implements MessageKeyProvider {
    LOAD_LOADING,
    LOAD_SUCCESS,

+    // /mv meta info
+    META_INFO_DESCRIPTION,
+    META_INFO_WORLD_DESCRIPTION,
+    META_INFO_HEADER,
+    META_INFO_NOCONTENT,
+
+    // /mv meta modify
+    META_MODIFY_SET_SUCCESS,
+    META_MODIFY_SET_FAILURE,
+    META_MODIFY_REMOVE_SUCCESS,
+    META_MODIFY_REMOVE_FAILURE,
+    META_MODIFY_INVALIDACTION,
+
    // /mv modify
    MODIFY_DESCRIPTION,
    MODIFY_WORLD_DESCRIPTION,
@@ -158,6 +205,13 @@ public enum MVCorei18n implements MessageKeyProvider {
    MODIFY_FAILURE,
    MODIFY_FAILURE_NOVALUE,

+    // /mv purge-all-entities
+    PURGEALLENTITIES_SUCCESS,
+    PURGEALLENTITIES_SUCCESS_CATEGORIES,
+
+    // /mv purge-entities
+    PURGEENTITIES_SUCCESS,
+
    // /mv regen
    REGEN_DESCRIPTION,
    REGEN_WORLD_DESCRIPTION,
@@ -192,6 +246,8 @@ public enum MVCorei18n implements MessageKeyProvider {
    // /mv spawn
    SPAWN_DESCRIPTION,
    SPAWN_PLAYER_DESCRIPTION,
+    SPAWN_NOTMVWORLD,
+    SPAWN_NOPERMISSION,
    SPAWN_SUCCESS,
    SPAWN_FAILED,

@@ -200,6 +256,9 @@ public enum MVCorei18n implements MessageKeyProvider {
    TELEPORT_PLAYER_DESCRIPTION,
    TELEPORT_DESTINATION_DESCRIPTION,
    TELEPORT_TOOMANYPLAYERS,
+    TELEPORT_NOPERMISSION_SELF,
+    TELEPORT_NOPERMISSION_OTHER,
+    TELEPORT_NOPERMISSION_ALL,
    TELEPORT_SUCCESS,
    TELEPORT_FAILED,

@@ -250,9 +309,26 @@ public enum MVCorei18n implements MessageKeyProvider {
    WORLDBORDER_WARNINGTIME_NOTHINGCHANGED,
    WORLDBORDER_WARNINGTIME_SUCCESS,

+    WORLDBORDER_ROUNDOFF_WARNING,
+
    // commands error
    COMMANDS_ERROR_PLAYERSONLY,
    COMMANDS_ERROR_MULTIVERSEWORLDONLY,
+    COMMANDS_ERROR_LOADEDMULTIVERSEWORLD_PLAYERSONLY,
+    COMMANDS_ERROR_LOADEDMULTIVERSEWORLD_ISSUER,
+    COMMANDS_ERROR_LOADEDMULTIVERSEWORLD_INPUTCONSOLE,
+    COMMANDS_ERROR_LOADEDMULTIVERSEWORLD_INPUT,
+    COMMANDS_ERROR_MULTIVERSEWORLD_PLAYERSONLY,
+    COMMANDS_ERROR_MULTIVERSEWORLD_ISSUER,
+    COMMANDS_ERROR_MULTIVERSEWORLD_INPUTCONSOLE,
+    COMMANDS_ERROR_MULTIVERSEWORLD_INPUT,
+    COMMANDS_ERROR_PLAYER_ISSUERINPUT,
+    COMMANDS_ERROR_PLAYER_INPUT,
+    COMMANDS_ERROR_PLAYER_SELECTOR,
+    COMMANDS_ERROR_PLAYERS_INPUT,
+    COMMANDS_ERROR_RESOLVE_PLAYER,
+    COMMANDS_ERROR_RESOLVE_INPUT,
+    COMMANDS_ERROR_REMOVEPLAYERS_NODEFAULT,

    // entry check
    ENTRYCHECK_BLACKLISTED,
@@ -269,7 +345,10 @@ public enum MVCorei18n implements MessageKeyProvider {

    // multiverse parse destination failure reason
    DESTINATION_ANCHOR_FAILUREREASON_ANCHORNOTFOUND,
+    DESTINATION_ANCHOR_DISPLAY,
    DESTINATION_BED_FAILUREREASON_PLAYERNOTFOUND,
+    DESTINATION_BED_DISPLAY_OWN,
+    DESTINATION_BED_DISPLAY_OTHER,
    DESTINATION_CANNON_FAILUREREASON_INVALIDFORMAT,
    DESTINATION_EXACT_FAILUREREASON_INVALIDFORMAT,
    DESTINATION_PLAYER_FAILUREREASON_PLAYERNOTFOUND,
@@ -278,6 +357,10 @@ public enum MVCorei18n implements MessageKeyProvider {
    DESTINATION_SHARED_FAILUREREASON_WORLDNOTFOUND,
    DESTINATION_PARSE_FAILUREREASON_INVALIDDESTINATIONID,

+    // portal form disabled
+    PORTALFORM_DISABLED_END,
+    PORTALFORM_DISABLED_NETHER,
+
    // teleport failure reason
    TELEPORTFAILUREREASON_NULL_DESTINATION,
    TELEPORTFAILUREREASON_NULL_LOCATION,
@@ -287,11 +370,17 @@ public enum MVCorei18n implements MessageKeyProvider {
    TELEPORTFAILUREREASON_TELEPORT_FAILED_EXCEPTION,
    TELEPORTFAILUREREASON_EVENT_CANCELLED,

+    // alias name conflict
+    ALIASNAMECONFLICT_DETECTED,
+    ALIASNAMECONFLICT_DUPLICATEALIAS,
+    ALIASNAMECONFLICT_DUPLICATEWORLDNAME,
+
    // world manager result
    CLONEWORLD_INVALIDWORLDNAME,
    CLONEWORLD_WORLDEXISTFOLDER,
    CLONEWORLD_WORLDEXISTUNLOADED,
    CLONEWORLD_WORLDEXISTLOADED,
+    CLONEWORLD_FROMWORLDFOLDERINVALID,
    CLONEWORLD_COPYFAILED,

    CREATEWORLD_INVALIDWORLDNAME,
@@ -309,12 +398,14 @@ public enum MVCorei18n implements MessageKeyProvider {
    IMPORTWORLD_WORLDEXISTLOADED,
    IMPORTWORLD_WORLDFOLDERINVALID,
    IMPORTWORLD_BUKKITENVIRONMENTMISMATCH,
+    IMPORTWORLD_BUKKITNAMESPACEDKEYMISMATCH,

    LOADWORLD_WORLDALREADYLOADING,
    LOADWORLD_WORLDNONEXISTENT,
    LOADWORLD_WORLDEXISTFOLDER,
    LOADWORLD_WORLDEXISTLOADED,
    LOADWORLD_BUKKITENVIRONMENTMISMATCH,
+    LOADWORLD_BUKKITNAMESPACEDKEYMISMATCH,

    REMOVEWORLD_WORLDNONEXISTENT,

@@ -328,6 +419,9 @@ public enum MVCorei18n implements MessageKeyProvider {
    WORLDCREATOR_BUKKITCREATIONFAILED,

    // queue command result
+    QUEUECOMMAND_DEFAULTPROMPT,
+    QUEUECOMMAND_PROMPT,
+    QUEUECOMMAND_EXPIRED,
    QUEUECOMMAND_NOCOMMANDINQUEUE,
    QUEUECOMMAND_INVALIDOTP,
    QUEUECOMMAND_COMMANDEXECUTIONERROR,
@@ -336,6 +430,7 @@ public enum MVCorei18n implements MessageKeyProvider {
    CONTENTDISPLAY_NOCONTENT,
    CONTENTDISPLAY_FILTER,
    CONTENTDISPLAY_PAGE,
+    CONTENTDISPLAY_PAGEFILTER,
    CONTENTDISPLAY_INVALIDPAGE,
    CONTENTDISPLAY_NULL,
    CONTENTDISPLAY_EMPTY,
@@ -351,12 +446,21 @@ public enum MVCorei18n implements MessageKeyProvider {
    EXCEPTION_POSITIONPARSE_INVALIDCOORDINATES,
    EXCEPTION_POSITIONPARSE_INVALIDNUMBER,

+    // world key parse failures
+    WORLDKEYPARSE_EMPTY,
+    WORLDKEYPARSE_INVALIDWORLDNAME,
+    WORLDKEYPARSE_INVALIDNAMESPACEDKEY,
+    WORLDKEYPARSE_NAMESPACEDKEYUNSUPPORTED,
+
    // generic
    GENERIC_SUCCESS,
    GENERIC_FAILURE,
    GENERIC_ERROR,
+    GENERIC_ERROR_DETAILS,
    GENERIC_NULL,
    GENERIC_YOU,
+    GENERIC_PLAYERCOUNT,
+    GENERIC_TELEPORTPLAYERS_FAILED,
    ;

    // END CHECKSTYLE-SUPPRESSION: Javadoc
@@ -1,17 +1,23 @@
 package org.mvplugins.multiverse.core.locale.message;

-import java.util.Objects;
-
 import co.aikar.commands.ACFUtil;
 import co.aikar.commands.CommandIssuer;
 import co.aikar.commands.Locales;
 import co.aikar.locales.MessageKey;
 import co.aikar.locales.MessageKeyProvider;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 public final class LocalizedMessage extends Message implements MessageKeyProvider {

+    private static @Nullable Locales locales;
+
+    @ApiStatus.Internal
+    public static void setDefaultLocalesManager(@Nullable Locales locales) {
+        LocalizedMessage.locales = locales;
+    }
+
    private final @NotNull MessageKeyProvider messageKeyProvider;

    LocalizedMessage(
@@ -22,44 +28,39 @@ public final class LocalizedMessage extends Message implements MessageKeyProvide
        this.messageKeyProvider = messageKeyProvider;
    }

+    /**
+     * {@inheritDoc}
+     */
    @Override
    public MessageKey getMessageKey() {
        return messageKeyProvider.getMessageKey();
    }

+    /**
+     * {@inheritDoc}
+     */
    @Override
-    public @NotNull String[] getReplacements(@NotNull Locales locales, @Nullable CommandIssuer commandIssuer) {
-        return toReplacementsArray(locales, commandIssuer, replacements);
+    public @NotNull String[] getReplacements() {
+        return locales == null ? super.getReplacements() : getReplacements(locales, null);
    }

+    /**
+     * {@inheritDoc}
+     */
    @Override
-    public @NotNull String formatted(@NotNull CommandIssuer commandIssuer) {
-        return formatted(commandIssuer.getManager().getLocales(), commandIssuer);
+    public @NotNull String formatted() {
+        return locales == null ? super.formatted() : formatted(locales, null);
    }

+    /**
+     * {@inheritDoc}
+     */
    @Override
    public @NotNull String formatted(@NotNull Locales locales, @Nullable CommandIssuer commandIssuer) {
-        Objects.requireNonNull(locales, "locales must not be null");
-
        String[] parsedReplacements = getReplacements(locales, commandIssuer);
        if (parsedReplacements.length == 0) {
            return locales.getMessage(commandIssuer, getMessageKey());
        }
        return ACFUtil.replaceStrings(locales.getMessage(commandIssuer, getMessageKey()), parsedReplacements);
    }
-
-    private static String[] toReplacementsArray(
-            @NotNull Locales locales,
-            @Nullable CommandIssuer commandIssuer,
-            @NotNull MessageReplacement... replacements) {
-        String[] replacementsArray = new String[replacements.length * 2];
-        int i = 0;
-        for (MessageReplacement replacement : replacements) {
-            replacementsArray[i++] = replacement.getKey();
-            replacementsArray[i++] = replacement.getReplacement().fold(
-                    str -> str,
-                    message -> message.formatted(locales, commandIssuer));
-        }
-        return replacementsArray;
-    }
 }
@@ -6,9 +6,11 @@ import co.aikar.commands.ACFUtil;
 import co.aikar.commands.CommandIssuer;
 import co.aikar.commands.Locales;
 import co.aikar.locales.MessageKeyProvider;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.mvplugins.multiverse.core.command.MVCommandManager;

 /**
 * A message that can be formatted with replacements and localized.
@@ -81,15 +83,45 @@ public sealed class Message permits LocalizedMessage {
    }

    /**
-     * Gets the replacements for this message.
+     * Gets the replacements for this message. This is the raw, non-localized parsing of replacements.
     * <br/>
     * This array is guaranteed to be of even length and suitable for use with
     * {@link ACFUtil#replaceStrings(String, String...)}.
     *
     * @return The replacements
+     *
+     * @since 5.8
+     */
+    @ApiStatus.AvailableSince("5.8")
+    public @NotNull String[] getRawReplacements() {
+        return toReplacementsArray(replacements);
+    }
+
+    /**
+     * Gets the replacements for this message with localization support when the plugin has loaded and injected its
+     * default {@link MVCommandManager#getLocales()} instance.
+     * Otherwise, it will fall back to use {@link getRawReplacements()}.
+     *
+     * @return The replacements
     */
    public @NotNull String[] getReplacements() {
-        return toReplacementsArray(replacements);
+        return getRawReplacements();
+    }
+
+    /**
+     * Gets the replacements for this message with localization support based on the command issuer's locale config.
+     * <br/>
+     * This array is guaranteed to be of even length and suitable for use with
+     * {@link ACFUtil#replaceStrings(String, String...)}.
+     *
+     * @param issuer The command issuer the message is for
+     * @return The replacements
+     *
+     * @since 5.8
+     */
+    @ApiStatus.AvailableSince("5.8")
+    public @NotNull String[] getReplacements(@NotNull CommandIssuer issuer) {
+        return getReplacements(issuer.getManager().getLocales(), issuer);
    }

    /**
@@ -103,7 +135,7 @@ public sealed class Message permits LocalizedMessage {
     * @return The replacements
     */
    public @NotNull String[] getReplacements(@NotNull Locales locales, @Nullable CommandIssuer commandIssuer) {
-        return getReplacements();
+        return toReplacementsArray(locales, commandIssuer, replacements);
    }

    /**
@@ -116,20 +148,36 @@ public sealed class Message permits LocalizedMessage {
    }

    /**
-     * Gets the formatted message.
+     * Gets the raw formatted message.
     * <br/>
     * This is the raw, non-localized message with replacements applied.
+     * This method will never use the locale message key.
     *
     * @return The formatted message
+     *
+     * @since 5.8
     */
-    public @NotNull String formatted() {
-        String[] parsedReplacements = getReplacements();
+    @ApiStatus.AvailableSince("5.8")
+    public @NotNull String rawFormatted() {
+        String[] parsedReplacements = getRawReplacements();
        if (parsedReplacements.length == 0) {
            return raw();
        }
        return ACFUtil.replaceStrings(message, parsedReplacements);
    }

+    /**
+     * Gets the formatted message.
+     * <br/>
+     * This is the localized message with replacements applied when the plugin has loaded and injected its default
+     * {@link MVCommandManager#getLocales()} instance. Otherwise, it will fall back to use {@link rawFormatted()}.
+     *
+     * @return The formatted message
+     */
+    public @NotNull String formatted() {
+        return rawFormatted();
+    }
+
    /**
     * Gets the formatted message from localization data.
     * <br/>
@@ -146,13 +194,13 @@ public sealed class Message permits LocalizedMessage {
     * Gets the formatted message from localization data.
     * <br/>
     * This is the localized message with replacements applied. The message is localized using the locale of the given
-     * command issuer, if not null.
+     * command issuer.
     *
-     * @param commandIssuer The command issuer the message is for, or null for the console (default locale)
+     * @param commandIssuer The command issuer the message is for.
     * @return The formatted, localized message
     */
    public @NotNull String formatted(@NotNull CommandIssuer commandIssuer) {
-        return formatted();
+        return formatted(commandIssuer.getManager().getLocales(), commandIssuer);
    }

    /**
@@ -166,7 +214,11 @@ public sealed class Message permits LocalizedMessage {
     * @return The formatted, localized message
     */
    public @NotNull String formatted(@NotNull Locales locales, @Nullable CommandIssuer commandIssuer) {
-        return formatted();
+        String[] parsedReplacements = getReplacements(locales, commandIssuer);
+        if (parsedReplacements.length == 0) {
+            return raw();
+        }
+        return ACFUtil.replaceStrings(message, parsedReplacements);
    }

    private static String[] toReplacementsArray(@NotNull MessageReplacement... replacements) {
@@ -174,7 +226,22 @@ public sealed class Message permits LocalizedMessage {
        int i = 0;
        for (MessageReplacement replacement : replacements) {
            replacementsArray[i++] = replacement.getKey();
-            replacementsArray[i++] = replacement.getReplacement().fold(s -> s, Message::formatted);
+            replacementsArray[i++] = replacement.getReplacement().fold(s -> s, Message::rawFormatted);
+        }
+        return replacementsArray;
+    }
+
+    private static String[] toReplacementsArray(
+            @NotNull Locales locales,
+            @Nullable CommandIssuer commandIssuer,
+            @NotNull MessageReplacement... replacements) {
+        String[] replacementsArray = new String[replacements.length * 2];
+        int i = 0;
+        for (MessageReplacement replacement : replacements) {
+            replacementsArray[i++] = replacement.getKey();
+            replacementsArray[i++] = replacement.getReplacement().fold(
+                    str -> str,
+                    message -> message.formatted(locales, commandIssuer));
        }
        return replacementsArray;
    }
@@ -1,6 +1,7 @@
 package org.mvplugins.multiverse.core.locale.message;

 import io.vavr.control.Either;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -107,6 +108,7 @@ public final class MessageReplacement {
        GAMERULE(replace("{gamerule}")),
        LOCATION(replace("{location}")),
        NAME(replace("{name}")),
+        NAMESPACE(replace("{namespace}")),
        PLAYER(replace("{player}")),
        REASON(replace("{reason}")),
        VALUE(replace("{value}")),
@@ -147,9 +147,10 @@ public abstract class MultiverseModule extends JavaPlugin {
        Try.of(() -> commandManagerProvider.get())
                .mapTry(MVCommandManager::getLocales)
                .andThen(pluginLocales -> {
-                    pluginLocales.addFileResClassLoader(this);
                    pluginLocales.addBundleClassLoader(this.getClassLoader());
+                    pluginLocales.addFileResClassLoader(this);
                    pluginLocales.addMessageBundles(this.getName().toLowerCase(Locale.ENGLISH));
+                    pluginLocales.loadLanguages();
                })
                .onFailure(e -> {
                    Logging.severe("Failed to register locales");
@@ -13,6 +13,7 @@ import org.mvplugins.multiverse.core.destination.Destination;
 import org.mvplugins.multiverse.core.world.MultiverseWorld;

 import static org.mvplugins.multiverse.core.permissions.PermissionUtils.concatPermission;
+import static org.mvplugins.multiverse.core.permissions.PermissionUtils.registerPermissionWithWildcards;

@Service
 public final class CorePermissions {
@@ -60,28 +61,34 @@ public final class CorePermissions {

    @PostConstruct
    void registerBasePermissions() {
-        pluginManager.addPermission(new Permission(JOINLOCATION_BYPASS, PermissionDefault.FALSE));
-        Logging.fine("Successfully registered base permissions");
+        Try.run(() -> {
+            registerPermissionWithWildcards(new Permission(JOINLOCATION_BYPASS, PermissionDefault.FALSE));
+        }).onSuccess(ignore -> {
+            Logging.fine("Successfully registered base permissions");
+        }).onFailure(e -> {
+            Logging.fine("Failed to register base permissions: %s", e.getMessage());
+        });
    }

    public Try<Void> addWorldPermissions(@NotNull MultiverseWorld world) {
        return Try.run(() -> {
-            pluginManager.addPermission(new Permission(
+            registerPermissionWithWildcards(new Permission(
                    concatPermission(WORLD_ACCESS, world.getName()), PermissionDefault.OP));
-            pluginManager.addPermission(new Permission(
+            registerPermissionWithWildcards(new Permission(
                    concatPermission(WORLD_EXEMPT, world.getName()), PermissionDefault.OP));
-            pluginManager.addPermission(new Permission(
+            registerPermissionWithWildcards(new Permission(
                    concatPermission(GAMEMODE_BYPASS, world.getName()), PermissionDefault.FALSE));
-            pluginManager.addPermission(new Permission(
+            registerPermissionWithWildcards(new Permission(
                    concatPermission(PLAYERLIMIT_BYPASS, world.getName()), PermissionDefault.FALSE));
-            pluginManager.addPermission(new Permission(
+            registerPermissionWithWildcards(new Permission(
                    concatPermission(SPAWN, world.getName()), PermissionDefault.OP));
-            pluginManager.addPermission(new Permission(
+            registerPermissionWithWildcards(new Permission(
                    concatPermission(SPAWN, "self", world.getName()), PermissionDefault.OP));
-            pluginManager.addPermission(new Permission(
+            registerPermissionWithWildcards(new Permission(
                    concatPermission(SPAWN, "other", world.getName()), PermissionDefault.OP));
            Logging.fine("Successfully registered permissions for world %s", world.getName());
-        });
+        }).onFailure(e -> Logging.fine("Failed to register permissions for world %s: %s",
+                world.getName(), e.getMessage()));
    }

    public Try<Void> removeWorldPermissions(@NotNull MultiverseWorld world) {
@@ -90,20 +97,23 @@ public final class CorePermissions {
            pluginManager.removePermission(concatPermission(WORLD_EXEMPT, world.getName()));
            pluginManager.removePermission(concatPermission(GAMEMODE_BYPASS, world.getName()));
            pluginManager.removePermission(concatPermission(PLAYERLIMIT_BYPASS, world.getName()));
+            pluginManager.removePermission(concatPermission(SPAWN, world.getName()));
            pluginManager.removePermission(concatPermission(SPAWN, "self", world.getName()));
            pluginManager.removePermission(concatPermission(SPAWN, "other", world.getName()));
            Logging.fine("Successfully removed permissions for world %s", world.getName());
-        });
+        }).onFailure(e -> Logging.fine("Failed to remove permissions for world %s: %s",
+                world.getName(), e.getMessage()));
    }

    public Try<Void> addDestinationPermissions(@NotNull Destination destination) {
        return Try.run(() -> {
-            pluginManager.addPermission(new Permission(
+            registerPermissionWithWildcards(new Permission(
                    concatPermission(TELEPORT, "self", destination.getIdentifier()), PermissionDefault.OP));
-            pluginManager.addPermission(new Permission(
+            registerPermissionWithWildcards(new Permission(
                    concatPermission(TELEPORT, "other", destination.getIdentifier()), PermissionDefault.OP));
            Logging.fine("Successfully registered permissions for destination %s", destination.getIdentifier());
-        });
+        }).onFailure(e -> Logging.fine("Failed to register permissions for destination %s: %s",
+                destination.getIdentifier(), e.getMessage()));
    }

    public Try<Void> removeDestinationPermissions(@NotNull Destination destination) {
@@ -111,6 +121,7 @@ public final class CorePermissions {
            pluginManager.removePermission(concatPermission(TELEPORT, "self", destination.getIdentifier()));
            pluginManager.removePermission(concatPermission(TELEPORT, "other", destination.getIdentifier()));
            Logging.fine("Successfully removed permissions for destination %s", destination.getIdentifier());
-        });
+        }).onFailure(e -> Logging.fine("Failed to remove permissions for destination %s: %s",
+                destination.getIdentifier(), e.getMessage()));
    }
 }
@@ -1,8 +1,14 @@
 package org.mvplugins.multiverse.core.permissions;

 import com.dumptruckman.minecraft.util.Logging;
+import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.permissions.Permission;
+import org.bukkit.permissions.PermissionDefault;
+import org.jetbrains.annotations.ApiStatus;
+
+import java.util.Arrays;

 public final class PermissionUtils {

@@ -20,6 +26,37 @@ public final class PermissionUtils {
        PermissionUtils.debugPermissions = debugPermissions;
    }

+    /**
+     * Registers a permission along with all its wildcard parents.
+     * <br />
+     * For example, registering "mv.bypass.joinlocation" will also register "mv.*" and "mv.bypass.*" as parents.
+     *
+     * @param permission    The permission to register.
+     *
+     * @since 5.4
+     */
+    @ApiStatus.AvailableSince("5.4")
+    public static void registerPermissionWithWildcards(Permission permission) {
+        Bukkit.getServer().getPluginManager().addPermission(permission);
+        String[] split = permission.getName().split("\\.");
+        StringBuilder prefix = new StringBuilder();
+        // Skip the last element since it's the actual permission
+        Arrays.stream(Arrays.copyOfRange(split, 0, split.length - 1)).forEach(s -> {
+            prefix.append(s).append(".");
+            Permission perm = getOrAddPermission(prefix + "*");
+            permission.addParent(perm, true);
+        });
+    }
+
+    private static Permission getOrAddPermission(String permission) {
+        Permission perm = Bukkit.getServer().getPluginManager().getPermission(permission);
+        if (perm == null) {
+            perm = new Permission(permission, PermissionDefault.FALSE);
+            Bukkit.getServer().getPluginManager().addPermission(perm);
+        }
+        return perm;
+    }
+
    /**
     * Joins permissions with a dot.
     *
@@ -132,6 +132,10 @@ public final class BlockSafety {
     */
    public boolean canSpawnAtBlockSafely(@NotNull Block block) {
        Logging.finest("Checking spawn safety for location: %s, %s, %s", block.getX(), block.getY(), block.getZ());
+        if (!block.getWorld().getWorldBorder().isInside(block.getLocation())) {
+            Logging.finest("Location is outside world border.");
+            return false;
+        }
        if (isUnsafeSpawnBody(block)) {
            // Player body will be stuck in solid
            Logging.finest("Unsafe location for player's body: " + block);
@@ -0,0 +1,92 @@
+package org.mvplugins.multiverse.core.utils;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A map with case-insensitive String keys. All keys are stored in lower-case form.
+ *
+ * @param <T> the type of mapped values
+ *
+ * @since 5.5
+ */
+@ApiStatus.AvailableSince("5.5")
+public class CaseInsensitiveStringMap<T> implements Map<String, T> {
+
+    private final Map<String, T> map;
+
+    public CaseInsensitiveStringMap() {
+        map = new HashMap<>();
+    }
+
+    @Override
+    public int size() {
+        return map.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return map.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return map.containsKey(normalizeKey(key));
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return map.containsValue(value);
+    }
+
+    @Override
+    public T get(Object key) {
+        return map.get(normalizeKey(key));
+    }
+
+    @Override
+    public @Nullable T put(String key, T value) {
+        return map.put(normalizeKey(key), value);
+    }
+
+    @Override
+    public T remove(Object key) {
+        return map.remove(normalizeKey(key));
+    }
+
+    @Override
+    public void putAll(@NotNull Map<? extends String, ? extends T> m) {
+        m.forEach((key, value) -> map.put(normalizeKey(key), value));
+    }
+
+    @Override
+    public void clear() {
+        map.clear();
+    }
+
+    @Override
+    public @NotNull Set<String> keySet() {
+        return map.keySet();
+    }
+
+    @Override
+    public @NotNull Collection<T> values() {
+        return map.values();
+    }
+
+    @Override
+    public @NotNull Set<Entry<String, T>> entrySet() {
+        return map.entrySet();
+    }
+
+    private String normalizeKey(Object key) {
+        return String.valueOf(key).toLowerCase(Locale.ROOT);
+    }
+}
@@ -18,6 +18,7 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;

 import com.dumptruckman.minecraft.util.Logging;
@@ -210,28 +211,31 @@ public final class FileUtils {

        private final Path sourceDir;
        private final Path targetDir;
-        private final List<String> excludeFiles;
+        private final List<Path> excludeFiles;

        private CopyDirFileVisitor(@NotNull Path sourceDir, @NotNull Path targetDir, @NotNull List<String> excludeFiles) {
            this.sourceDir = sourceDir;
            this.targetDir = targetDir;
-            this.excludeFiles = excludeFiles;
+            this.excludeFiles = excludeFiles.stream()
+                    .map(sourceDir::resolve)
+                    .toList();
+            Logging.finest(this.excludeFiles.stream().map(Path::toString).collect(Collectors.joining(", ", "Exclude files: [", "]")));
        }

        @Override
-        public @NotNull FileVisitResult preVisitDirectory(Path dir, @NotNull BasicFileAttributes attrs) throws IOException {
+        public @NotNull FileVisitResult preVisitDirectory(@NotNull Path dir, @NotNull BasicFileAttributes attrs) throws IOException {
            Path newDir = targetDir.resolve(sourceDir.relativize(dir));
            if (!Files.isDirectory(newDir)) {
-                Files.createDirectory(newDir);
+                Files.createDirectories(newDir);
            }
            return FileVisitResult.CONTINUE;
        }

        @Override
-        public @NotNull FileVisitResult visitFile(Path file, @NotNull BasicFileAttributes attrs) throws IOException {
+        public @NotNull FileVisitResult visitFile(@NotNull Path file, @NotNull BasicFileAttributes attrs) throws IOException {
            // Pass files that are set to ignore
-            if (excludeFiles.contains(file.getFileName().toString())) {
-                Logging.finest("Ignoring file: " + file.getFileName());
+            if (excludeFiles.contains(file)) {
+                Logging.finest("Ignoring file: " + file);
                return FileVisitResult.CONTINUE;
            }
            // Copy the files
@@ -1,8 +1,8 @@
 package org.mvplugins.multiverse.core.utils;

 import io.vavr.control.Try;
-import org.checkerframework.checker.nullness.qual.Nullable;
 import org.jetbrains.annotations.ApiStatus;
+import org.mvplugins.multiverse.core.utils.tick.TickDuration;

 import java.time.LocalTime;
 import java.time.format.DateTimeFormatter;
@@ -15,10 +15,6 @@ import java.time.format.DateTimeFormatter;
@ApiStatus.AvailableSince("5.1")
 public final class MinecraftTimeFormatter {

-    private static final double TIME_MULTIPLIER = 3.6;
-    private static final long DAY_SECONDS = 24 * 60 * 60;
-    private static final long START_OFFSET = 6 * 60 * 60;
-
    /**
     * Formats Minecraft time to 12-hour format.
     *
@@ -48,19 +44,14 @@ public final class MinecraftTimeFormatter {
     * See <a href="https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html">DateTimeFormatter documentation</a>
     * for available patterns.
     *
-     * @param time   The Minecraft time to format.
-     * @param format The format string for the time.
+     * @param ticks     The Minecraft time to format.
+     * @param format    The format string for the time.
     *
     * @since 5.1
     */
    @ApiStatus.AvailableSince("5.1")
-    public static String formatTime(long time, String format) {
-        // Convert Minecraft time to real-world time
-        long realTime = (long) ((time * TIME_MULTIPLIER) + START_OFFSET) % DAY_SECONDS;  // Minecraft ticks to seconds
-
-        // Convert seconds to LocalTime
-        LocalTime localTime = LocalTime.ofSecondOfDay(realTime);
-
+    public static String formatTime(long ticks, String format) {
+        LocalTime localTime = TickDuration.ofTicks(ticks).toLocalTime();
        return Try.of(() -> DateTimeFormatter.ofPattern(format))
                .map(localTime::format)
                .getOrElse("invalid time format: " + format);
@@ -1,16 +1,18 @@
 package org.mvplugins.multiverse.core.utils;

 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.UUID;
-import java.util.regex.Pattern;
 import java.util.stream.Collectors;

 import com.dumptruckman.minecraft.util.Logging;
 import com.google.common.base.Strings;
+import io.vavr.control.Try;
 import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

@@ -76,22 +78,33 @@ public final class PlayerFinder {
    public static @NotNull List<Player> getMulti(@Nullable String playerIdentifiers,
                                                 @NotNull CommandSender sender
    ) {
-        List<Player> playerResults = new ArrayList<>();
+        return tryGetMulti(playerIdentifiers, sender)
+                .getOrElse(Collections.emptyList());
+    }

+    /**
+     * Get multiple {@link Player} based on many identifiers of name UUID or selector.
+     *
+     * @param playerIdentifiers An identifier of multiple names, UUIDs or selectors, separated by comma.
+     * @param sender            Target sender for selector.
+     * @return A list of all the {@link Player} found.
+     *
+     * @since 5.4
+     */
+    @ApiStatus.AvailableSince("5.4")
+    public static @NotNull Try<@NotNull List<Player>> tryGetMulti(@Nullable String playerIdentifiers,
+                                                                   @NotNull CommandSender sender
+    ) {
        if (playerIdentifiers == null || Strings.isNullOrEmpty(playerIdentifiers)) {
-            return playerResults;
+            return Try.success(Collections.emptyList());
        }

        // TODO: Currently just assume entire string is a selector. Add support for comma seperated mixture of names, uuids and selectors
        if (isSelector(playerIdentifiers)) {
-            Logging.finer("Using selector: %s", playerIdentifiers);
-            List<Player> targetPlayers = getMultiBySelector(playerIdentifiers, sender);
-            if (targetPlayers != null) {
-                playerResults.addAll(targetPlayers);
-            }
-            return playerResults;
+            return tryGetMultiBySelector(playerIdentifiers, sender);
        }

+        List<Player> playerResults = new ArrayList<>();
        String[] playerIdentifierArray = REPatterns.COMMA.split(playerIdentifiers);
        for (String playerIdentifier : playerIdentifierArray) {
            Player targetPlayer = getByName(playerIdentifier);
@@ -104,15 +117,25 @@ public final class PlayerFinder {
                playerResults.add(targetPlayer);
                continue;
            }
-            List<Player> targetPlayers = getMultiBySelector(playerIdentifier, sender);
-            if (targetPlayers != null) {
-                playerResults.addAll(targetPlayers);
+            Try<@NotNull List<Player>> selectorParseResult = tryGetMultiBySelector(playerIdentifier, sender);
+            if  (selectorParseResult.isFailure()) {
+                return Try.failure(selectorParseResult.getCause());
            }
+            playerResults.addAll(selectorParseResult.getOrElse(Collections.emptyList()));
        }
-        return playerResults;
+        return Try.success(playerResults);
    }

-    private static boolean isSelector(@NotNull String playerIdentifier) {
+    /**
+     * Check if the player identifier is a selector.
+     *
+     * @param playerIdentifier  An identifier of name, UUID or selector.
+     * @return True if the identifier is a selector, else false.
+     *
+     * @since 5.4
+     */
+    @ApiStatus.AvailableSince("5.4")
+    public static boolean isSelector(@NotNull String playerIdentifier) {
        return VANILLA_SELECTORS.stream().anyMatch(playerIdentifier::startsWith);
    }

@@ -167,7 +190,7 @@ public final class PlayerFinder {
                                                 @NotNull CommandSender sender
    ) {
        List<Player> matchedPlayers = getMultiBySelector(playerSelector, sender);
-        if (matchedPlayers == null || matchedPlayers.isEmpty()) {
+        if (matchedPlayers.isEmpty()) {
            Logging.fine("No player found with selector '%s' for %s.", playerSelector, sender.getName());
            return null;
        }
@@ -186,22 +209,36 @@ public final class PlayerFinder {
     * @param sender            Target sender for selector.
     * @return A list of all the {@link Player} found.
     */
-    public static @Nullable List<Player> getMultiBySelector(@NotNull String playerSelector,
+    public static @NotNull List<Player> getMultiBySelector(@NotNull String playerSelector,
                                                            @NotNull CommandSender sender
+    ) {
+        return tryGetMultiBySelector(playerSelector, sender)
+                .onFailure(throwable -> Logging.warning(
+                        "Error selecting entities with selector '%s' for %s: %s",
+                        playerSelector, sender.getName(), throwable.getMessage()
+                ))
+                .getOrElse(Collections::emptyList);
+    }
+
+    /**
+     * Get multiple {@link Player} based on <a href="https://minecraft.gamepedia.com/Commands#Target_selectors">vanilla selectors</a>.
+     *
+     * @param playerSelector    A target selector, usually starts with an '@'.
+     * @param sender            Target sender for selector.
+     * @return A list of all the {@link Player} found.
+     *
+     * @since 5.4
+     */
+    @ApiStatus.AvailableSince("5.4")
+    public static @NotNull Try<@NotNull List<Player>> tryGetMultiBySelector(@NotNull String playerSelector,
+                                                                            @NotNull CommandSender sender
    ) {
        if (playerSelector.charAt(0) != '@') {
-            return null;
-        }
-        try {
-            return Bukkit.selectEntities(sender, playerSelector).stream()
-                    .filter(e -> e instanceof Player)
-                    .map(e -> ((Player) e))
-                    .collect(Collectors.toList());
-        } catch (IllegalArgumentException e) {
-            Logging.warning("An error occurred while parsing selector '%s' for %s. Is it is the correct format?",
-                    playerSelector, sender.getName());
-            e.printStackTrace();
-            return null;
+            return Try.success(Collections.emptyList());
        }
+        return Try.of(() -> Bukkit.selectEntities(sender, playerSelector).stream()
+                .filter(e -> e instanceof Player)
+                .map(e -> ((Player) e))
+                .collect(Collectors.toList()));
    }
 }
@@ -1,5 +1,7 @@
 package org.mvplugins.multiverse.core.utils;

+import org.jetbrains.annotations.ApiStatus;
+
 import java.util.HashMap;
 import java.util.Map;
 import java.util.regex.Pattern;
@@ -16,7 +18,17 @@ public class REPatterns {
    public static final Pattern COMMA = get(",");
    public static final Pattern DOT = get("\\.");
    public static final Pattern EQUALS = get("=");
+    @ApiStatus.AvailableSince("5.4")
+    public static final Pattern HYPHEN = get("-");
+    @ApiStatus.AvailableSince("5.4")
+    public static final Pattern NAMESPACE = get("^[a-z0-9_.-]+$");
+    @ApiStatus.AvailableSince("5.4")
+    public static final Pattern NAMESPACE_KEY = get("^[a-z0-9/_.-]+$");
    public static final Pattern SEMICOLON = get(";");
+    @ApiStatus.AvailableSince("5.4")
+    public static final Pattern SPACE = get(" ");
    public static final Pattern UNDERSCORE = get("_");
    public static final Pattern UUID = get("[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}");
+    @ApiStatus.AvailableSince("5.4")
+    public static final Pattern YAML_KEY = get("^[a-zA-Z0-9\\[\\]_-]+$");
 }
@@ -3,6 +3,8 @@ package org.mvplugins.multiverse.core.utils;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;

+import io.vavr.control.Try;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

@@ -15,8 +17,179 @@ public final class ReflectHelper {
     * Try to get the {@link Class} based on its classpath.
     *
     * @param classPath The target classpath.
-     * @return A {@link Class} if found, else null.
+     * @return A {@link Try} containing the {@link Class} if found, else a failure.
+     *
+     * @since 5.7
     */
+    @ApiStatus.AvailableSince("5.7")
+    @NotNull
+    public static Try<Class<?>> tryGetClass(@NotNull String classPath) {
+        return Try.of(() -> Class.forName(classPath));
+    }
+
+    /**
+     * Check if the {@link Class} for a give classpath is present/valid.
+     *
+     * @param classPath Target classpath.
+     * @return True if class path is a valid class, else false.
+     */
+    public static boolean hasClass(String classPath) {
+        return tryGetClass(classPath).isSuccess();
+    }
+
+    /**
+     * Try to get a {@link Method} from a given class.
+     *
+     * @param clazz             The class to search the method on.
+     * @param methodName        Name of the method to get.
+     * @param parameterTypes    Parameters present for that method.
+     * @param <C>               The class type.
+     * @return A {@link Try} containing the {@link Method} if found, else a failure.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @NotNull
+    public static <C> Try<Method> tryGetMethod(@NotNull Class<C> clazz, @NotNull String methodName, Class<?>... parameterTypes) {
+        return Try.of(() -> clazz.getMethod(methodName, parameterTypes))
+                .orElse(Try.of(() -> {
+                    Method method = clazz.getDeclaredMethod(methodName, parameterTypes);
+                    method.setAccessible(true);
+                    return method;
+                }));
+    }
+
+    /**
+     * Check if a {@link Method} exists on a given class.
+     *
+     * @param clazz             The class to search the method on.
+     * @param methodName        Name of the method to check.
+     * @param parameterTypes    Parameters present for that method.
+     * @return True if method exists, else false.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public static boolean hasMethod(@NotNull Class<?> clazz, @NotNull String methodName, Class<?>... parameterTypes) {
+        return tryGetMethod(clazz, methodName, parameterTypes).isSuccess();
+    }
+
+    /**
+     * Try to invoke a {@link Method} on a class instance.
+     *
+     * @param classInstance Instance of the class responsible for the method.
+     * @param method        The method to invoke.
+     * @param parameters    Parameters needed when invoking the method.
+     * @param <C>           The class type.
+     * @param <R>           The return type of the method.
+     * @return A {@link Try} containing the return value of the method if found, else a failure.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @NotNull
+    @SuppressWarnings("unchecked")
+    public static <C, R> Try<R> tryInvokeMethod(@NotNull C classInstance, @NotNull Method method, Object...parameters) {
+        return Try.of(() -> (R) method.invoke(classInstance, parameters));
+    }
+
+    /**
+     * Try to invoke a static {@link Method}.
+     *
+     * @param method        The static method to invoke.
+     * @param parameters    Parameters needed when invoking the method.
+     * @param <R>           The return type of the method.
+     * @return A {@link Try} containing the return value of the method if found, else a failure.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @NotNull
+    @SuppressWarnings("unchecked")
+    public static <R> Try<R> tryInvokeStaticMethod(@NotNull Method method, Object...parameters) {
+        return Try.of(() -> (R) method.invoke(null, parameters));
+    }
+
+    /**
+     * Try to get a {@link Field} from a given class.
+     *
+     * @param clazz     The class to search the field on.
+     * @param fieldName Name of the field to get.
+     * @param <C>       The class type.
+     * @return A {@link Try} containing the {@link Field} if found, else a failure.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @NotNull
+    public static <C> Try<Field> tryGetField(@NotNull Class<C> clazz, @NotNull String fieldName) {
+        return Try.of(() -> clazz.getField(fieldName))
+                .orElse(Try.of(() -> {
+                    Field field = clazz.getDeclaredField(fieldName);
+                    field.setAccessible(true);
+                    return field;
+                }));
+    }
+
+    /**
+     * Check if a {@link Field} exists on a given class.
+     *
+     * @param clazz     The class to search the field on.
+     * @param fieldName Name of the field to check.
+     * @return True if field exists, else false.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public static boolean hasField(@NotNull Class<?> clazz, @NotNull String fieldName) {
+        return tryGetField(clazz, fieldName).isSuccess();
+    }
+
+    /**
+     * Try to get the value of a {@link Field} from an instance of the class responsible.
+     *
+     * @param classInstance Instance of the class to get the field value from.
+     * @param field         The field to get the value from.
+     * @param fieldType     Type of the field.
+     * @param <C>           The class type.
+     * @param <V>           The field value type.
+     * @return A {@link Try} containing the field value if found, else a failure.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @NotNull
+    public static <C, V> Try<V> tryGetFieldValue(@NotNull C classInstance, @NotNull Field field, @NotNull Class<V> fieldType) {
+        return Try.of(() -> fieldType.cast(field.get(classInstance)));
+    }
+
+    /**
+     * Try to get the value of a static {@link Field}.
+     *
+     * @param field     The static field to get the value from.
+     * @param fieldType Type of the field.
+     * @param <V>       The field value type.
+     * @return A {@link Try} containing the field value if found, else a failure.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @NotNull
+    public static <V> Try<V> tryGetStaticFieldValue(@NotNull Field field, @NotNull Class<V> fieldType) {
+        return Try.of(() -> fieldType.cast(field.get(null)));
+    }
+
+    /**
+     * Try to get the {@link Class} based on its classpath.
+     *
+     * @param classPath The target classpath.
+     * @return A {@link Class} if found, else null.
+     *
+     * @deprecated Use {@link #tryGetClass(String)} instead, which returns a {@link Try} that can be used to handle
+     * the failure case more explicitly.
+     */
+    @Deprecated(forRemoval = true, since = "5.7")
+    @ApiStatus.ScheduledForRemoval(inVersion = "6.0")
    @Nullable
    public static Class<?> getClass(String classPath) {
        try {
@@ -26,16 +199,6 @@ public final class ReflectHelper {
        }
    }

-    /**
-     * Check if the {@link Class} for a give classpath is present/valid.
-     *
-     * @param classPath Target classpath.
-     * @return True if class path is a valid class, else false.
-     */
-    public static boolean hasClass(String classPath) {
-        return getClass(classPath) != null;
-    }
-
    /**
     * Try to get a {@link Method} from a given class.
     *
@@ -44,7 +207,12 @@ public final class ReflectHelper {
     * @param parameterTypes    Parameters present for that method.
     * @param <C>               The class type.
     * @return A {@link Method} if found, else null.
+     *
+     * @deprecated Use {@link #tryGetMethod(Class, String, Class[])} instead, which returns a {@link Try} that can be
+     * used to handle the failure case more explicitly.
     */
+    @Deprecated(forRemoval = true, since = "5.7")
+    @ApiStatus.ScheduledForRemoval(inVersion = "6.0")
    @Nullable
    public static <C> Method getMethod(Class<C> clazz, String methodName, Class<?>... parameterTypes) {
        try {
@@ -64,7 +232,12 @@ public final class ReflectHelper {
     * @param parameterTypes    Parameters present for that method.
     * @param <C>               The class type.
     * @return A {@link Method} if found, else null.
+     *
+     * @deprecated Use {@link #tryGetMethod(Class, String, Class[])} instead, which returns a {@link Try} that can be
+     * used to handle the failure case more explicitly.
     */
+    @Deprecated(forRemoval = true, since = "5.7")
+    @ApiStatus.ScheduledForRemoval(inVersion = "6.0")
    @Nullable
    public static <C> Method getMethod(C classInstance, String methodName, Class<?>... parameterTypes) {
        return getMethod(classInstance.getClass(), methodName, parameterTypes);
@@ -79,8 +252,14 @@ public final class ReflectHelper {
     * @param <C>           The class type.
     * @param <R>           The return type.
     * @return Return value of the method call if any, else null.
+     *
+     * @deprecated Use {@link #tryInvokeMethod(Object, Method, Object...)} instead, which returns a {@link Try} that can
+     * be used to handle the failure case more explicitly.
     */
+    @Deprecated(forRemoval = true, since = "5.7")
+    @ApiStatus.ScheduledForRemoval(inVersion = "6.0")
    @Nullable
+    @SuppressWarnings("unchecked")
    public static <C, R> R invokeMethod(C classInstance, Method method, Object...parameters) {
        try {
            return (R) method.invoke(classInstance, parameters);
@@ -96,7 +275,12 @@ public final class ReflectHelper {
     * @param fieldName Name of the field to get.
     * @param <C>       The class type.
     * @return A {@link Field} if found, else null.
+     *
+     * @deprecated Use {@link #tryGetField(Class, String)} instead, which returns a {@link Try} that can be used to
+     * handle the failure case more explicitly.
     */
+    @Deprecated(forRemoval = true, since = "5.7")
+    @ApiStatus.ScheduledForRemoval(inVersion = "6.0")
    @Nullable
    public static <C> Field getField(Class<C> clazz, String fieldName) {
        try {
@@ -115,7 +299,12 @@ public final class ReflectHelper {
     * @param fieldName     Name of the field to get.
     * @param <C>           The class type.
     * @return A {@link Field} if found, else null.
+     *
+     * @deprecated Use {@link #tryGetField(Class, String)} instead, which returns a {@link Try} that can be used to
+     * handle the failure case more explicitly.
     */
+    @Deprecated(forRemoval = true, since = "5.7")
+    @ApiStatus.ScheduledForRemoval(inVersion = "6.0")
    @Nullable
    public static <C> Field getField(C classInstance, String fieldName) {
        return getField(classInstance.getClass(), fieldName);
@@ -130,7 +319,12 @@ public final class ReflectHelper {
     * @param <C>           The class type.
     * @param <V>           The field value type.
     * @return The field value if any, else null.
+     *
+     * @deprecated Use {@link #tryGetFieldValue(Object, Field, Class)} instead, which returns a {@link Try} that can be
+     * used to handle the failure case more explicitly.
     */
+    @Deprecated(forRemoval = true, since = "5.7")
+    @ApiStatus.ScheduledForRemoval(inVersion = "6.0")
    @Nullable
    public static <C, V> V getFieldValue(C classInstance, @Nullable Field field, @NotNull Class<V> fieldType) {
        try {
@@ -153,7 +347,12 @@ public final class ReflectHelper {
     * @param <C>           The class type.
     * @param <V>           The field value type.
     * @return The field value if any, else null.
+     *
+     * @deprecated Use {@link #tryGetField(Class, String)} then map to {@link #tryGetFieldValue(Object, Field, Class)} instead,
+     * which returns a {@link Try} that can be used to handle the failure case more explicitly.
     */
+    @Deprecated(forRemoval = true, since = "5.7")
+    @ApiStatus.ScheduledForRemoval(inVersion = "6.0")
    @Nullable
    public static <C, V> V getFieldValue(C classInstance, @Nullable String fieldName, @NotNull Class<V> fieldType) {
        return getFieldValue(classInstance, getField(classInstance, fieldName), fieldType);