test(release): verify versioned pack URL

src/main/java/games/dmg/fantasystick/FantasyStickPlugin.java

@@ -280,6 +280,10 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 stoneSkinSettings, stoneSkin, shieldBashSettings, shieldBash, hexSettings, hex,
                 inspireSettings, inspire, abilityRegistry);
             admin.attachAdminRevival(adminRevival, adminReviveSettings);
+            admin.attachExperienceGrant(new games.dmg.fantasystick.session.AdminExperienceGrant(
+                characters, rules, sessions, nextTick, getServer()::getPlayer,
+                problem -> getLogger().log(Level.WARNING,
+                    "Admin experience grant for character " + problem.character(), problem.cause())));
             admin.attachSwitchDelay(switchDelaySettings);
             admin.attachRoleplaySettings(roleplaySettings);
             admin.attachPartySettings(partySettings);

src/main/java/games/dmg/fantasystick/session/AdminExperienceGrant.java

@@ -0,0 +1,114 @@
+package games.dmg.fantasystick.session;
+
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.progression.ProgressionRules;
+import java.math.BigInteger;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import org.bukkit.Color;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+
+/** Acknowledged administrator XP mutation captured against one exact active character/session. */
+public final class AdminExperienceGrant implements AutoCloseable {
+    public enum Status { APPLIED, AT_CAP, STALE, UNAVAILABLE, FAILED }
+    public record Result(Status status, String name, BigInteger requested, BigInteger applied,
+                         int level, int levels) { }
+    public record Failure(UUID character, Throwable cause) { }
+
+    private final CharacterStorage characters;
+    private final ProgressionRules progression;
+    private final EquipmentSessions sessions;
+    private final Consumer<Runnable> nextTick;
+    private final Function<UUID, Player> players;
+    private final Consumer<Failure> failures;
+    private volatile boolean closed;
+
+    public AdminExperienceGrant(CharacterStorage characters, ProgressionRules progression, EquipmentSessions sessions,
+            Consumer<Runnable> nextTick, Function<UUID, Player> players, Consumer<Failure> failures) {
+        this.characters = Objects.requireNonNull(characters);
+        this.progression = Objects.requireNonNull(progression);
+        this.sessions = Objects.requireNonNull(sessions);
+        this.nextTick = Objects.requireNonNull(nextTick);
+        this.players = Objects.requireNonNull(players);
+        this.failures = Objects.requireNonNull(failures);
+    }
+
+    /** Returns false before persistence when the captured active identity is no longer authoritative. */
+    public boolean grant(EquipmentSessions.Active active, CharacterRecord captured, BigInteger amount,
+                         Consumer<Result> completion) {
+        Objects.requireNonNull(active); Objects.requireNonNull(captured);
+        Objects.requireNonNull(amount); Objects.requireNonNull(completion);
+        if (amount.signum() <= 0) throw new IllegalArgumentException("Experience grant must be positive");
+        if (closed || !sessions.current(active)
+                || sessions.currentRecord(active).filter(captured::equals).isEmpty()) return false;
+        characters.awardExperience(captured.id(), captured.revision(), amount, progression)
+            .whenComplete((award, failure) -> schedule(active, captured, amount, completion, award, failure));
+        return true;
+    }
+
+    private void schedule(EquipmentSessions.Active active, CharacterRecord captured, BigInteger amount,
+            Consumer<Result> completion, CharacterStorage.ExperienceAward award, Throwable failure) {
+        if (failure != null) report(captured.id(), failure);
+        if (closed) return;
+        try {
+            nextTick.accept(() -> complete(active, captured, amount, completion, award, failure));
+        } catch (RuntimeException rejected) { report(captured.id(), rejected); }
+    }
+
+    private void complete(EquipmentSessions.Active active, CharacterRecord captured, BigInteger amount,
+            Consumer<Result> completion, CharacterStorage.ExperienceAward award, Throwable failure) {
+        if (closed) return;
+        if (failure != null) {
+            completion.accept(new Result(Status.FAILED, captured.name(), amount, BigInteger.ZERO,
+                captured.level(), 0));
+            return;
+        }
+        var saved = award.record().orElse(captured);
+        Status status = switch (award.status()) {
+            case APPLIED -> Status.APPLIED;
+            case AT_CAP, UNCHANGED -> Status.AT_CAP;
+            case STALE -> Status.STALE;
+            case UNAVAILABLE -> Status.UNAVAILABLE;
+        };
+        BigInteger applied = status == Status.APPLIED
+            ? saved.experience().subtract(captured.experience()) : BigInteger.ZERO;
+        if (status == Status.APPLIED && sessions.current(active)) {
+            boolean synchronizedSession = sessions.acknowledgeProgress(active, captured.revision(), saved);
+            if (!synchronizedSession && sessions.current(active)
+                    && sessions.currentRecord(active).filter(saved::equals).isEmpty()) {
+                report(captured.id(), new IllegalStateException(
+                    "Saved administrator XP could not synchronize with its captured active session"));
+            }
+            if (synchronizedSession && sessions.current(active)) feedback(active, saved, applied, award.levels());
+        }
+        completion.accept(new Result(status, captured.name(), amount, applied, saved.level(), award.levels()));
+    }
+
+    private void feedback(EquipmentSessions.Active active, CharacterRecord saved, BigInteger applied, int levels) {
+        Player player;
+        try { player = players.apply(active.player()); }
+        catch (RuntimeException failure) { report(saved.id(), failure); return; }
+        if (player == null || !player.isOnline() || !sessions.current(active)
+                || sessions.currentRecord(active).filter(saved::equals).isEmpty()) return;
+        try {
+            player.sendMessage("Received " + applied + " fantasy XP from an administrator.");
+            for (int gained = 1; gained <= levels; gained++) {
+                int level = saved.level() - levels + gained;
+                player.sendMessage("Level " + level + "! Gained 1 character point.");
+                SessionVisuals.burst(player, Color.BLUE, 12);
+                player.playSound(player.getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 1, 1);
+            }
+        } catch (RuntimeException failure) { report(saved.id(), failure); }
+    }
+
+    private void report(UUID character, Throwable failure) {
+        try { failures.accept(new Failure(character, failure)); }
+        catch (RuntimeException ignored) { /* Diagnostics do not replay a grant. */ }
+    }
+
+    @Override public void close() { closed = true; }
+}

src/main/java/games/dmg/fantasystick/session/EquipmentAdminCommand.java

@@ -1,6 +1,7 @@
 package games.dmg.fantasystick.session;
 
 import games.dmg.fantasystick.persistence.EquipmentSessionStore;
+import java.math.BigInteger;
 import java.util.List;
 import java.util.Objects;
 import java.util.UUID;
@@ -40,6 +41,7 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     private games.dmg.fantasystick.ability.Inspire inspire;
     private AdminCharacterIssuer characterIssuer;
     private AdminRevival adminRevival;
+    private AdminExperienceGrant experienceGrant;
     private games.dmg.fantasystick.persistence.AdminReviveSettings adminReviveSettings;
     private games.dmg.fantasystick.persistence.SwitchDelaySettings switchDelaySettings;
     private games.dmg.fantasystick.persistence.RoleplaySettings roleplaySettings;
@@ -220,6 +222,11 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     public void attachPartySettings(games.dmg.fantasystick.persistence.PartySettings settings){if(closed||partySettings!=null)throw new IllegalStateException("Party settings already attached or command closed");partySettings=Objects.requireNonNull(settings);}
     public void attachSheetResourcePack(games.dmg.fantasystick.persistence.SheetResourcePackSettings settings,games.dmg.fantasystick.presentation.SheetResourcePack delivery){if(closed||sheetResourcePackSettings!=null)throw new IllegalStateException("Sheet resource pack already attached or command closed");sheetResourcePackSettings=Objects.requireNonNull(settings);sheetResourcePack=Objects.requireNonNull(delivery);}
 
+    public void attachExperienceGrant(AdminExperienceGrant grant) {
+        if (closed || experienceGrant != null) throw new IllegalStateException("Experience grant already attached or command closed");
+        experienceGrant = Objects.requireNonNull(grant);
+    }
+
     public void attachAdminRevival(AdminRevival revival, games.dmg.fantasystick.persistence.AdminReviveSettings settings) {
         if (closed || adminRevival != null) throw new IllegalStateException("Admin revival already attached or command closed");
         adminRevival=Objects.requireNonNull(revival);adminReviveSettings=Objects.requireNonNull(settings);
@@ -247,6 +254,9 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         if (args.length > 0 && args[0].equals("revive")) {
             adminRevive(sender,args);return true;
         }
+        if (args.length > 0 && args[0].equals("experience")) {
+            experience(sender, args); return true;
+        }
         UUID owner;
         try {
             if (args.length != 2 || !(args[0].equals("inspect") || args[0].equals("recover"))) {
@@ -307,6 +317,54 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         return true;
     }
 
+    private void experience(CommandSender sender, String[] args) {
+        if (experienceGrant == null || args.length < 4 || !args[1].equals("give")) {
+            sender.sendMessage("Usage: /fantasystick experience give <active-character-name...> <positive-amount>"); return;
+        }
+        BigInteger amount;
+        try { amount = new BigInteger(args[args.length - 1]); }
+        catch (NumberFormatException invalid) {
+            sender.sendMessage("Experience amount is invalid; enter a positive whole number."); return;
+        }
+        if (amount.signum() <= 0) {
+            sender.sendMessage("Experience amount is invalid; enter a positive whole number."); return;
+        }
+        String name = String.join(" ", java.util.Arrays.copyOfRange(args, 2, args.length - 1));
+        if (name.isBlank()) {
+            sender.sendMessage("Usage: /fantasystick experience give <active-character-name...> <positive-amount>"); return;
+        }
+        var matches = sessions.activeCharacters().stream().filter(active -> active.record().name().equals(name)).toList();
+        if (matches.isEmpty()) {
+            sender.sendMessage("Experience grant refused: character '" + name + "' is not active. No fantasy XP changed."); return;
+        }
+        if (matches.size() != 1) {
+            sender.sendMessage("Experience grant refused: active character name '" + name
+                + "' is ambiguous. No fantasy XP changed."); return;
+        }
+        if (!sender.hasPermission(PERMISSION)
+                || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) {
+            sender.sendMessage("Experience grant refused before persistence. No fantasy XP changed."); return;
+        }
+        var target = matches.getFirst();
+        boolean accepted = experienceGrant.grant(target.session(), target.record(), amount, result -> {
+            if (closed || !sender.hasPermission(PERMISSION)
+                    || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+            sender.sendMessage(switch (result.status()) {
+                case APPLIED -> "Granted " + result.requested() + " fantasy XP to " + result.name()
+                    + "; applied " + result.applied() + " after cap clamping; resulting level " + result.level() + ".";
+                case AT_CAP -> "Granted 0 of requested " + result.requested() + " fantasy XP to " + result.name()
+                    + "; the character is already capped at level " + result.level() + ".";
+                case STALE -> "Experience grant refused: " + result.name()
+                    + " changed concurrently. No grant success was recorded.";
+                case UNAVAILABLE -> "Experience grant refused: " + result.name()
+                    + " is unavailable or dead. No fantasy XP changed.";
+                case FAILED -> "Experience grant failed before acknowledgment for " + result.name()
+                    + "; no success was reported. See server diagnostics.";
+            });
+        });
+        if (!accepted) sender.sendMessage("Experience grant refused: the captured character session changed before persistence. No fantasy XP changed.");
+    }
+
     private void adminRevive(CommandSender sender,String[] args){if(args.length!=2||args[1].isBlank()||adminRevival==null||!(sender instanceof org.bukkit.entity.Player admin)){sender.sendMessage("Usage: /fantasystick revive <online-player> (an in-game administrator must select the Tail)");return;}var matches=server.getOnlinePlayers().stream().filter(player->player.isOnline()&&player.getName().equalsIgnoreCase(args[1])).toList();if(matches.size()!=1){sender.sendMessage("Admin revival refused: target must name one online player. No item changed.");return;}adminRevival.open(admin,matches.getFirst(),adminReviveSettings.timeout());}
 
     private void give(CommandSender sender, String[] args) {
@@ -597,7 +655,9 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     @Override public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
         if (closed || !sender.hasPermission(PERMISSION)) return List.of();
         if (args.length == 1) return matching(sender instanceof org.bukkit.entity.Player
-            ? List.of("config", "give", "inspect", "recover", "revive") : List.of("config", "give", "inspect", "recover"), args[0]);
+            ? List.of("config", "experience", "give", "inspect", "recover", "revive") : List.of("config", "experience", "give", "inspect", "recover"), args[0]);
+        if (args.length == 2 && args[0].equals("experience")) return matching(List.of("give"), args[1]);
+        if (args.length >= 3 && args[0].equals("experience") && args[1].equals("give")) return experienceNames(args);
         if (args.length == 2 && (args[0].equals("inspect") || args[0].equals("recover"))) return matching(
             server.getOnlinePlayers().stream().filter(org.bukkit.entity.Player::isOnline)
                 .map(player -> player.getUniqueId().toString()).toList(), args[1]);
@@ -661,8 +721,18 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         return List.of();
     }
 
+    private List<String> experienceNames(String[] args) {
+        int priorTokens = args.length - 3;
+        String prefix = args[args.length - 1];
+        return matching(sessions.activeCharacters().stream().map(active -> active.record().name())
+            .map(name -> name.split(" ")).filter(tokens -> tokens.length > priorTokens)
+            .filter(tokens -> java.util.stream.IntStream.range(0, priorTokens)
+                .allMatch(index -> tokens[index].equals(args[index + 2])))
+            .map(tokens -> tokens[priorTokens]).toList(), prefix);
+    }
+
     private static List<String> matching(java.util.Collection<String> values, String prefix) {
         return values.stream().filter(value -> value.startsWith(prefix)).distinct().sorted().toList();
     }
-    @Override public void close() { closed = true; if (characterIssuer != null) characterIssuer.close(); if(adminRevival!=null)adminRevival.close(); }
+    @Override public void close() { closed = true; if (characterIssuer != null) characterIssuer.close(); if(adminRevival!=null)adminRevival.close(); if(experienceGrant!=null)experienceGrant.close(); }
 }

src/main/java/games/dmg/fantasystick/session/EquipmentSessions.java

@@ -12,6 +12,7 @@ import java.time.Duration;
 import java.time.Instant;
 import java.util.Arrays;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
@@ -34,6 +35,7 @@ public final class EquipmentSessions implements AutoCloseable {
     public record Notice(UUID player, String code, String message) { }
     public record Failure(UUID player, UUID session, Throwable cause) { }
     public record Active(UUID player, UUID session, UUID character) { }
+    public record ActiveCharacter(Active session, CharacterRecord record) { }
     public record SelectedControl(Active session, int slot, String ability) { }
 
     private final CharacterStorage characters;
@@ -224,6 +226,14 @@ public final class EquipmentSessions implements AutoCloseable {
             && sheets.identify(attempt.player.getInventory().getItemInOffHand()).filter(attempt.character::equals).isPresent();
     }
 
+    /** Side-effect-free server-thread snapshots for exact active-character command resolution/autocomplete. */
+    public synchronized List<ActiveCharacter> activeCharacters() {
+        if (closed) return List.of();
+        return active.values().stream().filter(attempt -> attempt.record != null)
+            .map(attempt -> new ActiveCharacter(new Active(attempt.owner, attempt.session, attempt.character), attempt.record))
+            .filter(snapshot -> current(snapshot.session())).toList();
+    }
+
     /** Current active holder for a transferable identity, used only to synchronize acknowledged character writes. */
     public synchronized Optional<Active> activeCharacter(UUID character) {
         Objects.requireNonNull(character);

src/main/resources/plugin.yml

@@ -7,10 +7,10 @@ description: Transferable characters, native fantasy health, recoverable equipme
 author: dmg.games
 commands:
   fantasystick:
-    description: Issue or revive character sheets, inspect/recover sessions or configure Fantasy Stick.
-    usage: /fantasystick <give|revive> <online-player> | <inspect|recover> <player-uuid> | config <setting> [value]
+    description: Issue or revive sheets, grant fantasy experience, recover sessions or configure Fantasy Stick.
+    usage: /fantasystick <give|revive> <online-player> | experience give <active-character-name...> <amount> | <inspect|recover> <player-uuid> | config <setting> [value]
     permission: fantasystick.admin
 permissions:
   fantasystick.admin:
-    description: Issue/revive sheets, inspect/recover sessions and configure fantasy mode.
+    description: Issue/revive sheets, grant fantasy experience, recover sessions and configure fantasy mode.
     default: op

src/nativeTest/java/games/dmg/fantasystick/AdminExperienceGrantNativeTest.java

@@ -0,0 +1,73 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import games.dmg.fantasystick.crafting.CharacterFactory;
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.progression.ProgressionRules;
+import games.dmg.fantasystick.session.AdminExperienceGrant;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.jupiter.api.Test;
+
+class AdminExperienceGrantNativeTest {
+    @Test void acceptedPersistenceCannotRedirectFeedbackAfterCharacterSwitch() {
+        var storage = mock(CharacterStorage.class); var sessions = mock(EquipmentSessions.class);
+        var rules = ProgressionRules.defaults(); CharacterRecord captured = new CharacterFactory().create(rules);
+        var active = new EquipmentSessions.Active(UUID.randomUUID(), UUID.randomUUID(), captured.id());
+        var current = new AtomicBoolean(true);
+        when(sessions.current(active)).thenAnswer(call -> current.get());
+        when(sessions.currentRecord(active)).thenReturn(Optional.of(captured));
+        var future = new CompletableFuture<CharacterStorage.ExperienceAward>();
+        when(storage.awardExperience(captured.id(), captured.revision(), BigInteger.TEN, rules)).thenReturn(future);
+        var tasks = new ArrayList<Runnable>(); var results = new ArrayList<AdminExperienceGrant.Result>();
+        var playerLookups = new java.util.concurrent.atomic.AtomicInteger();
+        var grant = new AdminExperienceGrant(storage, rules, sessions, tasks::add,
+            ignored -> { playerLookups.incrementAndGet(); return null; }, failure -> fail(failure.cause()));
+
+        assertTrue(grant.grant(active, captured, BigInteger.TEN, results::add));
+        current.set(false);
+        var saved = new CharacterRecord(captured.id(), captured.name(), BigInteger.ONE, captured.stats(), 1,
+            BigInteger.TEN, captured.unspentPoints(), captured.health(), captured.learned(), captured.loadout(),
+            captured.cooldowns(), captured.restrictedKills(), false, captured.deathId(), captured.diedAt());
+        future.complete(new CharacterStorage.ExperienceAward(CharacterStorage.ExperienceAwardStatus.APPLIED,
+            Optional.of(saved), 0));
+        assertEquals(1, tasks.size()); tasks.getFirst().run();
+
+        assertEquals(AdminExperienceGrant.Status.APPLIED, results.getFirst().status());
+        assertEquals(BigInteger.TEN, results.getFirst().applied());
+        verify(sessions, never()).acknowledgeProgress(any(), any(), any());
+        assertEquals(0, playerLookups.get(), "A replacement holder/session cannot receive captured feedback");
+    }
+
+    @Test void persistenceFailureReportsOnceAndClosedLifetimePublishesNoStaleCallback() {
+        var storage = mock(CharacterStorage.class); var sessions = mock(EquipmentSessions.class);
+        var rules = ProgressionRules.defaults(); CharacterRecord captured = new CharacterFactory().create(rules);
+        var active = new EquipmentSessions.Active(UUID.randomUUID(), UUID.randomUUID(), captured.id());
+        when(sessions.current(active)).thenReturn(true); when(sessions.currentRecord(active)).thenReturn(Optional.of(captured));
+        var failed = new CompletableFuture<CharacterStorage.ExperienceAward>();
+        when(storage.awardExperience(captured.id(), captured.revision(), BigInteger.ONE, rules)).thenReturn(failed);
+        var tasks = new ArrayList<Runnable>(); var results = new ArrayList<AdminExperienceGrant.Result>();
+        var failures = new ArrayList<AdminExperienceGrant.Failure>();
+        var grant = new AdminExperienceGrant(storage, rules, sessions, tasks::add, ignored -> null, failures::add);
+        assertTrue(grant.grant(active, captured, BigInteger.ONE, results::add));
+        failed.completeExceptionally(new java.io.IOException("save failed"));
+        assertEquals(1, failures.size()); assertEquals(1, tasks.size()); tasks.removeFirst().run();
+        assertEquals(List.of(AdminExperienceGrant.Status.FAILED), results.stream().map(AdminExperienceGrant.Result::status).toList());
+
+        var pending = new CompletableFuture<CharacterStorage.ExperienceAward>();
+        when(storage.awardExperience(captured.id(), captured.revision(), BigInteger.TWO, rules)).thenReturn(pending);
+        assertTrue(grant.grant(active, captured, BigInteger.TWO, results::add)); grant.close();
+        pending.complete(new CharacterStorage.ExperienceAward(CharacterStorage.ExperienceAwardStatus.AT_CAP,
+            Optional.of(captured), 0));
+        assertTrue(tasks.isEmpty()); assertEquals(1, results.size());
+    }
+}

src/nativeTest/java/games/dmg/fantasystick/AdminExperienceNativeTest.java

@@ -0,0 +1,212 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import games.dmg.fantasystick.items.CharacterSheets;
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import java.math.BigInteger;
+import java.nio.file.Path;
+import java.util.List;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class AdminExperienceNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void registeredCommandResolvesExactActiveCharacterPersistsThenSynchronizesFeedbackAndBook() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var target = new FantasyStickLifecycleNativeTest.Actor(data);
+            var storage = storage(f);
+            storage.renameCharacter(target.core.record.id(), "Mira 雪").get();
+            f.players.put(target.core.id, target.player); f.activate(target);
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            var before = storage.find(target.core.record.id()).get().orElseThrow();
+
+            assertEquals(List.of("experience"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"exp"}));
+            assertEquals(List.of("give"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"experience", "g"}));
+            assertEquals(List.of("Mira"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"experience", "give", "Mi"}));
+            assertEquals(List.of("雪"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"experience", "give", "Mira", ""}));
+            assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"experience", "give", "Mira", "雪", ""}).isEmpty());
+            assertTrue(f.command.execute(sender.port, "fantasystick", new String[]{"experience", "give", "Mira", "雪", "250"}));
+            storage.find(target.core.record.id()).get(); f.tick();
+
+            var saved = storage.find(target.core.record.id()).get().orElseThrow();
+            assertEquals(BigInteger.valueOf(250), saved.experience());
+            assertEquals(3, saved.level());
+            assertEquals(before.unspentPoints().add(BigInteger.TWO), saved.unspentPoints());
+            assertEquals(before.stats(), saved.stats()); assertEquals(before.health(), saved.health());
+            assertEquals(before.learned(), saved.learned()); assertEquals(before.loadout(), saved.loadout());
+            assertEquals(before.cooldowns(), saved.cooldowns()); assertEquals(before.restrictedKills(), saved.restrictedKills());
+            assertTrue(sender.messages.getLast().contains("Mira 雪"));
+            assertTrue(sender.messages.getLast().contains("250")); assertTrue(sender.messages.getLast().contains("level 3"));
+            assertTrue(target.messages.stream().anyMatch(message -> message.contains("250 fantasy XP")));
+            assertTrue(target.messages.stream().anyMatch(message -> message.contains("Level 2")));
+            assertTrue(target.messages.stream().anyMatch(message -> message.contains("Level 3")));
+            assertEquals(2, target.sounds.size());
+            assertEquals(2, org.mockito.Mockito.mockingDetails(target.world).getInvocations().stream()
+                .filter(invocation -> invocation.getMethod().getName().equals("spawnParticle")).count());
+            PartyBookNativeTest.open(f, target);
+            String text = bookText(target.books.getLast());
+            assertTrue(text.contains("Level: 3"), text); assertTrue(text.contains("XP: 50/100"), text);
+
+            f.plugin.setEnabled(false); f.plugin.setEnabled(true);
+            assertEquals(BigInteger.valueOf(250), storage(f).find(target.core.record.id()).get().orElseThrow().experience());
+        }
+    }
+
+    @Test void commandValidationAmbiguityExactCaseAndAutocompleteFailClosedWithoutMutation() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var first = active(f, data, "Twin Hero"); var second = active(f, data, "Twin Hero");
+            var unicode = active(f, data, "Árvíztűrő Tükörfúrógép");
+            var inactive = new FantasyStickLifecycleNativeTest.Actor(data);
+            storage(f).renameCharacter(inactive.core.record.id(), "Hidden Hero").get();
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            var firstBefore = storage(f).find(first.core.record.id()).get().orElseThrow();
+            var secondBefore = storage(f).find(second.core.record.id()).get().orElseThrow();
+
+            assertEquals(List.of("Twin"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"experience", "give", "Tw"}));
+            assertEquals(List.of("Hero"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"experience", "give", "Twin", "H"}));
+            assertEquals(List.of("Árvíztűrő"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"experience", "give", "Á"}));
+            assertEquals(List.of("Tükörfúrógép"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"experience", "give", "Árvíztűrő", "T"}));
+            assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"experience", "give", "Hidden", ""}).isEmpty());
+            int queued = f.tasks.size();
+            for (var args : List.of(
+                    new String[]{"experience", "give", "Twin", "Hero", "5"},
+                    new String[]{"experience", "give", "twin", "Hero", "5"},
+                    new String[]{"experience", "give", "Missing", "5"},
+                    new String[]{"experience", "give", "Hidden", "Hero", "5"},
+                    new String[]{"experience", "give", "Account", "5"},
+                    new String[]{"experience", "give", "Árvíztűrő", "Tükörfúrógép", "0"},
+                    new String[]{"experience", "give", "Árvíztűrő", "Tükörfúrógép", "-1"},
+                    new String[]{"experience", "give", "Árvíztűrő", "Tükörfúrógép", "1.5"},
+                    new String[]{"experience", "give", "Árvíztűrő", "Tükörfúrógép", "5", "extra"},
+                    new String[]{"experience", "give", "Árvíztűrő", "Tükörfúrógép"},
+                    new String[]{"experience", "extra", "Árvíztűrő", "Tükörfúrógép", "5"})) {
+                f.command.execute(sender.port, "fantasystick", args);
+            }
+            assertEquals(queued, f.tasks.size());
+            assertEquals(firstBefore, storage(f).find(first.core.record.id()).get().orElseThrow());
+            assertEquals(secondBefore, storage(f).find(second.core.record.id()).get().orElseThrow());
+            assertTrue(sender.messages.stream().anyMatch(message -> message.contains("ambiguous") && message.contains("Twin Hero")));
+            assertTrue(sender.messages.stream().anyMatch(message -> message.contains("not active") && message.contains("Missing")));
+            sender.allowed = false;
+            assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"exp"}).isEmpty());
+            f.command.execute(sender.port, "fantasystick", new String[]{"experience", "give", "Árvíztűrő", "Tükörfúrógép", "5"});
+            assertTrue(sender.messages.getLast().contains("Permission denied"));
+            assertEquals(BigInteger.ZERO, storage(f).find(unicode.core.record.id()).get().orElseThrow().experience());
+        }
+    }
+
+    @Test void arbitraryPrecisionGrantClampsAtCapPreservesCombatHistoryAndNeverTouchesNativeXp() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var target = new FantasyStickLifecycleNativeTest.Actor(data); var storage = storage(f);
+            var position = new games.dmg.fantasystick.progression.CombatRewardRules.KillPosition(java.util.UUID.randomUUID(),
+                java.math.BigDecimal.ONE, java.math.BigDecimal.TWO, java.math.BigDecimal.TEN);
+            var progressed = storage.awardCombatExperience(target.core.record.id(), target.core.record.revision(), BigInteger.TEN,
+                new games.dmg.fantasystick.progression.ProgressionRules(BigInteger.valueOf(40), BigInteger.valueOf(100), 30),
+                games.dmg.fantasystick.progression.CombatRewardRules.defaults(), position).get().record().orElseThrow();
+            storage.renameCharacter(target.core.record.id(), "Cap Hero").get();
+            f.players.put(target.core.id, target.player); f.activate(target);
+            var sender = new EquipmentAdminCommandNativeTest.Sender(); String huge = "9".repeat(1000);
+
+            f.command.execute(sender.port, "fantasystick", new String[]{"experience", "give", "Cap", "Hero", huge});
+            storage.find(target.core.record.id()).get(); f.tick();
+            var capped = storage.find(target.core.record.id()).get().orElseThrow();
+            assertEquals(30, capped.level()); assertEquals(BigInteger.valueOf(2900), capped.experience());
+            assertEquals(progressed.restrictedKills(), capped.restrictedKills());
+            assertTrue(sender.messages.getLast().contains("applied 2890"));
+            int feedback = target.messages.size(); int sounds = target.sounds.size();
+            f.command.execute(sender.port, "fantasystick", new String[]{"experience", "give", "Cap", "Hero", "1"});
+            storage.find(target.core.record.id()).get(); f.tick();
+            assertTrue(sender.messages.getLast().contains("Granted 0"));
+            assertEquals(feedback, target.messages.size()); assertEquals(sounds, target.sounds.size());
+            assertEquals(capped, storage.find(target.core.record.id()).get().orElseThrow());
+        }
+    }
+
+    @Test void revisionLogoutFailureAndRepeatedGrantRacesNeverRedirectDuplicateOrClaimFalseSuccess() throws Exception {
+        var staleDir = data.resolve("stale");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(staleDir)) {
+            f.plugin.setEnabled(true); var target = active(f, staleDir, "Before Rename"); var storage = storage(f);
+            var worker = (java.util.concurrent.ExecutorService) FantasyStickLifecycleNativeTest.Fixture.field(storage, "worker");
+            var entered = new java.util.concurrent.CountDownLatch(1); var release = new java.util.concurrent.CountDownLatch(1);
+            var gate = worker.submit(() -> { entered.countDown(); try { assertTrue(release.await(5, java.util.concurrent.TimeUnit.SECONDS)); }
+                catch (InterruptedException interrupted) { throw new AssertionError(interrupted); } });
+            var sender = new EquipmentAdminCommandNativeTest.Sender(); assertTrue(entered.await(5, java.util.concurrent.TimeUnit.SECONDS));
+            f.command.execute(sender.port, "fantasystick", new String[]{"experience", "give", "Before", "Rename", "75"});
+            var old = new games.dmg.fantasystick.persistence.YamlCharacterRepository(staleDir).load(target.core.record.id()).orElseThrow();
+            var renamed = copy(old, "After Rename", old.revision().add(BigInteger.ONE));
+            new games.dmg.fantasystick.persistence.YamlCharacterRepository(staleDir).replace(renamed, old.revision());
+            release.countDown(); gate.get(); storage.find(old.id()).get(); f.tick();
+            assertTrue(sender.messages.getLast().contains("changed concurrently"));
+            assertEquals(BigInteger.ZERO, storage.find(old.id()).get().orElseThrow().experience());
+            assertTrue(target.messages.stream().noneMatch(message -> message.contains("administrator")));
+        }
+        var logoutDir = data.resolve("logout");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(logoutDir)) {
+            f.plugin.setEnabled(true); var target = active(f, logoutDir, "Departing Hero"); var storage = storage(f);
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            f.command.execute(sender.port, "fantasystick", new String[]{"experience", "give", "Departing", "Hero", "75"});
+            target.core.online = false;
+            storage.find(target.core.record.id()).get(); f.tick();
+            assertEquals(BigInteger.valueOf(75), storage.find(target.core.record.id()).get().orElseThrow().experience());
+            assertTrue(sender.messages.getLast().contains("applied 75"));
+            assertTrue(target.messages.stream().noneMatch(message -> message.contains("administrator")));
+        }
+        var repeatDir = data.resolve("repeat");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(repeatDir)) {
+            f.plugin.setEnabled(true); var target = active(f, repeatDir, "One Award"); var storage = storage(f);
+            var first = new EquipmentAdminCommandNativeTest.Sender(); var second = new EquipmentAdminCommandNativeTest.Sender();
+            f.command.execute(first.port, "fantasystick", new String[]{"experience", "give", "One", "Award", "25"});
+            f.command.execute(second.port, "fantasystick", new String[]{"experience", "give", "One", "Award", "25"});
+            storage.find(target.core.record.id()).get(); f.tick(); f.tick();
+            assertEquals(BigInteger.valueOf(25), storage.find(target.core.record.id()).get().orElseThrow().experience());
+            assertEquals(1, List.of(first.messages.getLast(), second.messages.getLast()).stream()
+                .filter(message -> message.contains("applied 25")).count());
+            assertEquals(1, List.of(first.messages.getLast(), second.messages.getLast()).stream()
+                .filter(message -> message.contains("changed concurrently")).count());
+        }
+    }
+
+    @Test void realFilesystemSaveFailureReportsNoSuccessOrPlayerFeedback() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true); var target = active(f, data, "Broken Save");
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            var path = data.resolve("characters").resolve(target.core.record.id() + ".yml");
+            java.nio.file.Files.delete(path); java.nio.file.Files.createDirectory(path);
+            int feedback = target.messages.size();
+            f.command.execute(sender.port, "fantasystick", new String[]{"experience", "give", "Broken", "Save", "20"});
+            f.tick();
+            assertTrue(sender.messages.getLast().contains("failed before acknowledgment"));
+            assertEquals(feedback, target.messages.size());
+            assertTrue(sender.messages.stream().noneMatch(message -> message.startsWith("Granted 20")));
+        }
+    }
+
+    private static CharacterRecord copy(CharacterRecord old, String name, BigInteger revision) {
+        return new CharacterRecord(old.id(), name, revision, old.stats(), old.level(), old.experience(), old.unspentPoints(),
+            old.health(), old.learned(), old.loadout(), old.cooldowns(), old.restrictedKills(), old.dead(), old.deathId(), old.diedAt());
+    }
+
+    private static FantasyStickLifecycleNativeTest.Actor active(FantasyStickLifecycleNativeTest.Fixture f,
+            Path data, String name) throws Exception {
+        var actor = new FantasyStickLifecycleNativeTest.Actor(data);
+        storage(f).renameCharacter(actor.core.record.id(), name).get();
+        f.players.put(actor.core.id, actor.player); f.activate(actor); return actor;
+    }
+    private static CharacterStorage storage(FantasyStickLifecycleNativeTest.Fixture f) {
+        return (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+    }
+    private static String bookText(org.bukkit.inventory.ItemStack book) {
+        var content = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(book)
+            .get(net.minecraft.core.component.DataComponents.WRITTEN_BOOK_CONTENT);
+        assertNotNull(content);
+        return content.pages().stream().map(page -> page.raw().getString()).collect(java.util.stream.Collectors.joining("\n"));
+    }
+}

src/nativeTest/java/games/dmg/fantasystick/EquipmentAdminCommandNativeTest.java

@@ -53,7 +53,7 @@ class EquipmentAdminCommandNativeTest {
         try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
             f.plugin.setEnabled(true); var target = new FantasyStickLifecycleNativeTest.Actor(data); f.players.put(target.core.id,target.player);
             var sender=new Sender();
-            assertEquals(List.of("config","give","inspect","recover"),f.command.tabComplete(sender.port,"fantasystick",new String[]{""}));
+            assertEquals(List.of("config","experience","give","inspect","recover"),f.command.tabComplete(sender.port,"fantasystick",new String[]{""}));
             assertEquals(List.of("give"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"g"}));
             assertEquals(List.of("Account"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"give",""}));
             assertEquals(List.of("Account"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"give","Acc"}));
@@ -94,7 +94,7 @@ class EquipmentAdminCommandNativeTest {
             f.players.put(first.core.id, first.player); f.players.put(second.core.id, second.player); f.players.put(offline.core.id, offline.player);
             var sender = new Sender();
             var expected = java.util.stream.Stream.of(first.core.id.toString(), second.core.id.toString()).sorted().toList();
-            assertEquals(List.of("config", "give", "inspect", "recover"), f.command.tabComplete(sender.port, "fantasystick", new String[]{""}));
+            assertEquals(List.of("config", "experience", "give", "inspect", "recover"), f.command.tabComplete(sender.port, "fantasystick", new String[]{""}));
             assertEquals(List.of("inspect"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"in"}));
             assertEquals(List.of("recover"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"rec"}));
             assertEquals(expected, f.command.tabComplete(sender.port, "fantasystick", new String[]{"inspect", ""}));

src/nativeTest/java/games/dmg/fantasystick/LongbowNativeTest.java

@@ -348,7 +348,7 @@ class LongbowNativeTest {
             assertThrows(AssertionError.class, () -> abilityButton(unavailable, "[Learn]", "longbow"));
 
             var sender = new EquipmentAdminCommandNativeTest.Sender();
-            assertEquals(java.util.List.of("config", "give", "inspect", "recover"),
+            assertEquals(java.util.List.of("config", "experience", "give", "inspect", "recover"),
                 f.command.tabComplete(sender.port, "fantasystick", new String[]{""}));
             assertEquals(java.util.List.of("config"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"c"}));
             assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"unknown"}).isEmpty());

src/nativeTest/java/games/dmg/fantasystick/QuickstepNativeTest.java

@@ -202,7 +202,7 @@ class QuickstepNativeTest {
             assertEquals(0, new java.math.BigDecimal("6").compareTo(definition.parameters().get("distance")));
             assertEquals(0, new java.math.BigDecimal("1.5").compareTo(definition.parameters().get("speed")));
             var sender = new EquipmentAdminCommandNativeTest.Sender();
-            assertEquals(List.of("config", "give", "inspect", "recover"),
+            assertEquals(List.of("config", "experience", "give", "inspect", "recover"),
                 f.command.tabComplete(sender.port, "fantasystick", new String[]{""}));
             assertEquals(List.of("config"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"co"}));
             assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"unsupported"}).isEmpty());

src/nativeTest/java/games/dmg/fantasystick/SecondWindNativeTest.java

@@ -130,7 +130,7 @@ class SecondWindNativeTest {
             assertEquals(BigInteger.TEN.pow(500).subtract(BigInteger.TEN).divide(BigInteger.TWO).add(BigInteger.valueOf(6)),
                 games.dmg.fantasystick.ability.SecondWind.healing(BigInteger.TEN.pow(500)));
             var sender = new EquipmentAdminCommandNativeTest.Sender();
-            assertEquals(List.of("config", "give", "inspect", "recover"),
+            assertEquals(List.of("config", "experience", "give", "inspect", "recover"),
                 f.command.tabComplete(sender.port, "fantasystick", new String[]{""}));
             sender.allowed = false;
             assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "second"}).isEmpty());

src/nativeTest/java/games/dmg/fantasystick/SheetResourcePackNativeTest.java

@@ -2,7 +2,7 @@ package games.dmg.fantasystick;
 import static org.junit.jupiter.api.Assertions.*;import static org.mockito.ArgumentMatchers.*;import static org.mockito.Mockito.*;import java.nio.file.Path;import java.util.*;import net.kyori.adventure.text.Component;import org.bukkit.event.player.PlayerResourcePackStatusEvent;import org.junit.jupiter.api.BeforeAll;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.io.TempDir;
 class SheetResourcePackNativeTest{@TempDir Path data;@BeforeAll static void bootstrap()throws Exception{NativeRuntime.bootstrap();}
  record Request(UUID id,String url,byte[] hash,String prompt,boolean required){}
- @Test void packagedStartupJoinAndStatusesUseOptionalNativeDeliveryWithoutGameplayMutation()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){var a=new FantasyStickLifecycleNativeTest.Actor(data);a.core.inventory.setItemInOffHand(null);f.players.put(a.core.id,a.player);var before=a.core.snapshot();f.plugin.setEnabled(true);f.awaitCharacterAndReceipt(a);PartyBookNativeTest.drain(f);assertEquals(1,a.resourcePacks.size());var request=request(a.resourcePacks.getFirst());assertEquals(games.dmg.fantasystick.presentation.SheetResourcePack.ID,request.id());assertTrue(request.url().contains("/v0.1.0-SNAPSHOT/purpur-fantasy-stick-0.1.0-SNAPSHOT-resource-pack.zip"));assertEquals(20,request.hash().length);assertFalse(request.required());assertArrayEquals(before,a.core.snapshot());for(var status:List.of(PlayerResourcePackStatusEvent.Status.DECLINED,PlayerResourcePackStatusEvent.Status.FAILED_DOWNLOAD,PlayerResourcePackStatusEvent.Status.INVALID_URL,PlayerResourcePackStatusEvent.Status.FAILED_RELOAD,PlayerResourcePackStatusEvent.Status.DISCARDED)){f.dispatcher.accept(new PlayerResourcePackStatusEvent(a.player,request.id(),status));assertTrue(a.messages.getLast().toLowerCase().contains("cosmetic"));assertArrayEquals(before,a.core.snapshot());}int messages=a.messages.size();f.dispatcher.accept(new PlayerResourcePackStatusEvent(a.player,request.id(),PlayerResourcePackStatusEvent.Status.ACCEPTED));f.dispatcher.accept(new PlayerResourcePackStatusEvent(a.player,request.id(),PlayerResourcePackStatusEvent.Status.DOWNLOADED));f.dispatcher.accept(new PlayerResourcePackStatusEvent(a.player,request.id(),PlayerResourcePackStatusEvent.Status.SUCCESSFULLY_LOADED));assertEquals(messages,a.messages.size());var active=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(active.core.id,active.player);var legacyMeta=active.core.inventory.getItemInOffHand().getItemMeta();legacyMeta.setItemModel(null);active.core.inventory.getItemInOffHand().setItemMeta(legacyMeta);var activeBefore=active.core.snapshot();var expectedMeta=activeBefore[40].getItemMeta();expectedMeta.setItemModel(games.dmg.fantasystick.items.CharacterSheets.MODEL);activeBefore[40].setItemMeta(expectedMeta);var sessions=(games.dmg.fantasystick.session.EquipmentSessions)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sessions");sessions.enter(active.player);awaitPacked(f,active);assertEquals(games.dmg.fantasystick.items.CharacterSheets.MODEL,active.core.inventory.getItemInOffHand().getItemMeta().getItemModel());sessions.exit(active.player);f.awaitCharacterAndReceipt(active);assertArrayEquals(activeBefore,active.core.snapshot());var retained=(games.dmg.fantasystick.presentation.SheetResourcePack)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sheetResourcePack");f.plugin.setEnabled(false);retained.status(new PlayerResourcePackStatusEvent(a.player,request.id(),PlayerResourcePackStatusEvent.Status.DECLINED));assertEquals(messages,a.messages.size());f.plugin.setEnabled(true);var late=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(late.core.id,late.player);f.dispatcher.accept(new org.bukkit.event.player.PlayerJoinEvent(late.player,(Component)null));assertEquals(1,late.resourcePacks.size());}}
+ @Test void packagedStartupJoinAndStatusesUseOptionalNativeDeliveryWithoutGameplayMutation()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){var a=new FantasyStickLifecycleNativeTest.Actor(data);a.core.inventory.setItemInOffHand(null);f.players.put(a.core.id,a.player);var before=a.core.snapshot();f.plugin.setEnabled(true);f.awaitCharacterAndReceipt(a);PartyBookNativeTest.drain(f);assertEquals(1,a.resourcePacks.size());var request=request(a.resourcePacks.getFirst());assertEquals(games.dmg.fantasystick.presentation.SheetResourcePack.ID,request.id());assertEquals(games.dmg.fantasystick.persistence.SheetResourcePackSettings.packagedDefaults().url(),request.url());assertEquals(20,request.hash().length);assertFalse(request.required());assertArrayEquals(before,a.core.snapshot());for(var status:List.of(PlayerResourcePackStatusEvent.Status.DECLINED,PlayerResourcePackStatusEvent.Status.FAILED_DOWNLOAD,PlayerResourcePackStatusEvent.Status.INVALID_URL,PlayerResourcePackStatusEvent.Status.FAILED_RELOAD,PlayerResourcePackStatusEvent.Status.DISCARDED)){f.dispatcher.accept(new PlayerResourcePackStatusEvent(a.player,request.id(),status));assertTrue(a.messages.getLast().toLowerCase().contains("cosmetic"));assertArrayEquals(before,a.core.snapshot());}int messages=a.messages.size();f.dispatcher.accept(new PlayerResourcePackStatusEvent(a.player,request.id(),PlayerResourcePackStatusEvent.Status.ACCEPTED));f.dispatcher.accept(new PlayerResourcePackStatusEvent(a.player,request.id(),PlayerResourcePackStatusEvent.Status.DOWNLOADED));f.dispatcher.accept(new PlayerResourcePackStatusEvent(a.player,request.id(),PlayerResourcePackStatusEvent.Status.SUCCESSFULLY_LOADED));assertEquals(messages,a.messages.size());var active=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(active.core.id,active.player);var legacyMeta=active.core.inventory.getItemInOffHand().getItemMeta();legacyMeta.setItemModel(null);active.core.inventory.getItemInOffHand().setItemMeta(legacyMeta);var activeBefore=active.core.snapshot();var expectedMeta=activeBefore[40].getItemMeta();expectedMeta.setItemModel(games.dmg.fantasystick.items.CharacterSheets.MODEL);activeBefore[40].setItemMeta(expectedMeta);var sessions=(games.dmg.fantasystick.session.EquipmentSessions)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sessions");sessions.enter(active.player);awaitPacked(f,active);assertEquals(games.dmg.fantasystick.items.CharacterSheets.MODEL,active.core.inventory.getItemInOffHand().getItemMeta().getItemModel());sessions.exit(active.player);f.awaitCharacterAndReceipt(active);assertArrayEquals(activeBefore,active.core.snapshot());var retained=(games.dmg.fantasystick.presentation.SheetResourcePack)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sheetResourcePack");f.plugin.setEnabled(false);retained.status(new PlayerResourcePackStatusEvent(a.player,request.id(),PlayerResourcePackStatusEvent.Status.DECLINED));assertEquals(messages,a.messages.size());f.plugin.setEnabled(true);var late=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(late.core.id,late.player);f.dispatcher.accept(new org.bukkit.event.player.PlayerJoinEvent(late.player,(Component)null));assertEquals(1,late.resourcePacks.size());}}
  @Test void invalidStartupAndFailedRegisteredWriteNeverDeliverOrChangeEffectiveDefaults()throws Exception{int route=0;for(String value:List.of("sheet-resource-pack-url: 'http://bad.test/x.zip'\n","sheet-resource-pack-sha1: bad\n")){var dir=data.resolve("invalid-"+route++);java.nio.file.Files.createDirectories(dir);java.nio.file.Files.writeString(dir.resolve("config.yml"),value);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){assertThrows(IllegalArgumentException.class,()->f.plugin.setEnabled(true));assertTrue(f.order.isEmpty(),"native registration order "+f.order);assertTrue(f.tasks.isEmpty(),"queued tasks");}}var failed=data.resolve("failed");java.nio.file.Files.createDirectories(failed);try(var f=new FantasyStickLifecycleNativeTest.Fixture(failed)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(failed);f.players.put(a.core.id,a.player);java.nio.file.Files.createDirectory(failed.resolve("config.yml"));var sender=new EquipmentAdminCommandNativeTest.Sender();f.command.execute(sender.port,"fantasystick",new String[]{"config","sheet-resource-pack-url","https://packs.example.test/x.zip"});var callback=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(callback);callback.run();assertTrue(sender.messages.getLast().contains("save failed"),sender.messages::toString);assertTrue(a.resourcePacks.isEmpty());f.command.execute(sender.port,"fantasystick",new String[]{"config","sheet-resource-pack-url"});assertTrue(sender.messages.getLast().contains("git.garvis.dev"));}}
  @Test void registeredConfigurationDurablyPublishesAndRedeliversWhileFailureRetainsPair()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(a.core.id,a.player);var sender=new EquipmentAdminCommandNativeTest.Sender();assertEquals(List.of("sheet-resource-pack-sha1","sheet-resource-pack-url"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","sheet-r"}));assertEquals(1,f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","sheet-resource-pack-url",""}).size());sender.allowed=false;assertTrue(f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","sheet-r"}).isEmpty());f.command.execute(sender.port,"fantasystick",new String[]{"config","sheet-resource-pack-url","https://packs.example.test/sheet.zip"});assertTrue(sender.messages.getLast().contains("Permission denied"));sender.allowed=true;f.command.execute(sender.port,"fantasystick",new String[]{"config","sheet-resource-pack-url","https://packs.example.test/x.zip","extra"});assertTrue(sender.messages.getLast().contains("Usage"));for(var pair:List.of(new String[]{"sheet-resource-pack-url","http://bad.test/x.zip"},new String[]{"sheet-resource-pack-sha1","bad"})){f.command.execute(sender.port,"fantasystick",new String[]{"config",pair[0],pair[1]});assertTrue(sender.messages.getLast().contains("invalid"));}save(f,sender,"sheet-resource-pack-url","https://packs.example.test/sheet.zip");assertEquals(1,a.resourcePacks.size());assertEquals("https://packs.example.test/sheet.zip",request(a.resourcePacks.getLast()).url());save(f,sender,"sheet-resource-pack-sha1","a".repeat(40));assertEquals(2,a.resourcePacks.size());assertArrayEquals(java.util.HexFormat.of().parseHex("a".repeat(40)),request(a.resourcePacks.getLast()).hash());f.plugin.setEnabled(false);f.plugin.setEnabled(true);f.command.execute(sender.port,"fantasystick",new String[]{"config","sheet-resource-pack-url"});assertTrue(sender.messages.getLast().contains("https://packs.example.test/sheet.zip"));}}
  static void awaitPacked(FantasyStickLifecycleNativeTest.Fixture f,FantasyStickLifecycleNativeTest.Actor actor)throws Exception{long deadline=System.nanoTime()+java.util.concurrent.TimeUnit.SECONDS.toNanos(10);while(System.nanoTime()<deadline){var marker=actor.core.marker();if(marker!=null&&marker.endsWith("|PACKED"))return;var task=f.tasks.poll(100,java.util.concurrent.TimeUnit.MILLISECONDS);if(task!=null)task.run();}fail("Session did not activate; notices="+actor.messages);}

src/test/java/games/dmg/fantasystick/DistributionTest.java

@@ -31,6 +31,7 @@ class DistributionTest {
             assertEquals(java.util.List.of("ProtocolLib"), metadata.getDepend());
             assertEquals(java.util.Set.of("fantasystick"), metadata.getCommands().keySet());
             assertEquals("fantasystick.admin", metadata.getCommands().get("fantasystick").get("permission"));
+            assertTrue(metadata.getCommands().get("fantasystick").get("usage").toString().contains("experience give"));
             assertEquals(1, metadata.getPermissions().size());
             assertEquals("fantasystick.admin", metadata.getPermissions().getFirst().getName());
             assertEquals(org.bukkit.permissions.PermissionDefault.OP, metadata.getPermissions().getFirst().getDefault());