feat(ability): add Quickstep

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

@@ -51,6 +51,10 @@ public final class FantasyStickPlugin extends JavaPlugin {
     private games.dmg.fantasystick.ability.Fireball fireball;
     private games.dmg.fantasystick.ability.FrostShard frostShard;
     private games.dmg.fantasystick.persistence.FrostShardSettings frostShardSettings;
+    private games.dmg.fantasystick.ability.Longbow longbow;
+    private games.dmg.fantasystick.persistence.LongbowSettings longbowSettings;
+    private games.dmg.fantasystick.ability.Quickstep quickstep;
+    private games.dmg.fantasystick.persistence.QuickstepSettings quickstepSettings;
     private games.dmg.fantasystick.ability.GreatSword greatSword;
     private games.dmg.fantasystick.ability.Revive revive;
     private games.dmg.fantasystick.persistence.RevivalStore revivals;
@@ -84,6 +88,10 @@ public final class FantasyStickPlugin extends JavaPlugin {
             var greatSwordSettings = greatSwordSettings();
             var frostShardConfiguration = frostShardConfiguration();
             var frostShardInitial = games.dmg.fantasystick.persistence.FrostShardSettings.parse(frostShardConfiguration);
+            var longbowConfiguration = longbowConfiguration();
+            var longbowInitial = games.dmg.fantasystick.persistence.LongbowSettings.parse(longbowConfiguration);
+            var quickstepConfiguration = quickstepConfiguration();
+            var quickstepInitial = games.dmg.fantasystick.persistence.QuickstepSettings.parse(quickstepConfiguration);
             var factory = new CharacterFactory();
             characters = new CharacterStorage(new YamlCharacterRepository(getDataFolder().toPath()), Clock.systemUTC());
             crafting = new ManualCraftingController(characters, () -> factory.create(rules),
@@ -127,6 +135,13 @@ public final class FantasyStickPlugin extends JavaPlugin {
             frostShardSettings = new games.dmg.fantasystick.persistence.FrostShardSettings(
                 getDataFolder().toPath(), frostShardConfiguration);
             frostShard = new games.dmg.fantasystick.ability.FrostShard(frostShardInitial);
+            longbowSettings = new games.dmg.fantasystick.persistence.LongbowSettings(
+                getDataFolder().toPath(), longbowConfiguration);
+            longbow = new games.dmg.fantasystick.ability.Longbow(longbowInitial);
+            quickstepSettings = new games.dmg.fantasystick.persistence.QuickstepSettings(
+                getDataFolder().toPath(), quickstepConfiguration);
+            quickstep = new games.dmg.fantasystick.ability.Quickstep(quickstepInitial,
+                event -> getServer().getPluginManager().callEvent(event));
             greatSword = new games.dmg.fantasystick.ability.GreatSword(greatSwordSettings);
             revivals = new games.dmg.fantasystick.persistence.RevivalStore(getDataFolder().toPath());
             revive = new games.dmg.fantasystick.ability.Revive(characters, revivals, Clock.systemUTC(), nextTick,
@@ -134,6 +149,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 problem -> getLogger().log(Level.WARNING, "Revive transition failed", problem));
             abilityRegistry.register(fireball.definition());
             abilityRegistry.register(frostShard.definition());
+            abilityRegistry.register(longbow.definition());
+            abilityRegistry.register(quickstep.definition());
             abilityRegistry.register(greatSword.definition());
             abilityRegistry.register(revive.definition());
             sessions.attachAbilityRegistry(abilityRegistry);
@@ -177,7 +194,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
             admin = new EquipmentAdminCommand(receipts, sessions, getServer(), nextTick,
                 problem -> getLogger().log(Level.WARNING, "Equipment admin " + problem.operation()
                     + " for player " + problem.player(), problem.cause()), adventureSettings,
-                frostShardSettings, frostShard, abilityRegistry);
+                frostShardSettings, frostShard, longbowSettings, longbow,
+                quickstepSettings, quickstep, abilityRegistry);
             var command = java.util.Objects.requireNonNull(getCommand("fantasystick"), "Missing packaged fantasystick command");
             command.setExecutor(admin);
             command.setTabCompleter(admin);
@@ -193,6 +211,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
             combatExperience.install(this);
             getServer().getPluginManager().registerEvents(fireball, this);
             getServer().getPluginManager().registerEvents(frostShard, this);
+            getServer().getPluginManager().registerEvents(longbow, this);
+            getServer().getPluginManager().registerEvents(quickstep, this);
             getServer().getPluginManager().registerEvents(greatSword, this);
             getServer().getPluginManager().registerEvents(revive, this);
             getServer().getPluginManager().registerEvents(localBasicAttack, this);
@@ -240,6 +260,10 @@ public final class FantasyStickPlugin extends JavaPlugin {
         var closingFireball = fireball; fireball = null;
         var closingFrostShard = frostShard; frostShard = null;
         var closingFrostSettings = frostShardSettings; frostShardSettings = null;
+        var closingLongbow = longbow; longbow = null;
+        var closingLongbowSettings = longbowSettings; longbowSettings = null;
+        var closingQuickstep = quickstep; quickstep = null;
+        var closingQuickstepSettings = quickstepSettings; quickstepSettings = null;
         var closingGreatSword = greatSword; greatSword = null;
         var closingRevive = revive; revive = null;
         var closingRevivals = revivals; revivals = null;
@@ -251,16 +275,24 @@ public final class FantasyStickPlugin extends JavaPlugin {
         if (closingAdmin != null) cleanup("admin command", closingAdmin::close);
         if (closingSettings != null) cleanup("configuration", closingSettings::close);
         if (closingFrostSettings != null) cleanup("Frost Shard configuration", closingFrostSettings::close);
+        if (closingLongbowSettings != null) cleanup("Longbow configuration", closingLongbowSettings::close);
+        if (closingQuickstepSettings != null) cleanup("Quickstep configuration", closingQuickstepSettings::close);
         configurationDrain = java.util.concurrent.CompletableFuture.allOf(
             closingSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
                 : closingSettings.drained().toCompletableFuture(),
             closingFrostSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
-                : closingFrostSettings.drained().toCompletableFuture());
+                : closingFrostSettings.drained().toCompletableFuture(),
+            closingLongbowSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingLongbowSettings.drained().toCompletableFuture(),
+            closingQuickstepSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingQuickstepSettings.drained().toCompletableFuture());
         if (closingBooks != null) cleanup("character book", closingBooks::close);
         if (closingBasicAttack != null) cleanup("basic attack", closingBasicAttack::close);
         if (closingCombatExperience != null) cleanup("combat experience", closingCombatExperience::close);
         if (closingFireball != null) cleanup("Fireball", closingFireball::close);
         if (closingFrostShard != null) cleanup("Frost Shard", closingFrostShard::close);
+        if (closingLongbow != null) cleanup("Longbow", closingLongbow::close);
+        if (closingQuickstep != null) cleanup("Quickstep", closingQuickstep::close);
         if (closingGreatSword != null) cleanup("Great Sword", closingGreatSword::close);
         if (closingRevive != null) cleanup("Revive", closingRevive::close);
         if (closingAbilityEngine != null) cleanup("ability engine", closingAbilityEngine::close);
@@ -279,6 +311,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
         unregister(closingCombatExperience);
         unregister(closingFireball);
         unregister(closingFrostShard);
+        unregister(closingLongbow);
+        unregister(closingQuickstep);
         unregister(closingGreatSword);
         unregister(closingRevive);
         unregister(closingBasicAttack);
@@ -361,6 +395,26 @@ public final class FantasyStickPlugin extends JavaPlugin {
         return java.util.Map.copyOf(values);
     }
 
+    private java.util.Map<String, String> longbowConfiguration() {
+        var values = new java.util.LinkedHashMap<String, String>();
+        for (String key : games.dmg.fantasystick.persistence.LongbowSettings.keys()) {
+            values.put(key, getConfig().getString(key,
+                games.dmg.fantasystick.persistence.LongbowSettings.defaultValue(key)));
+        }
+        games.dmg.fantasystick.persistence.LongbowSettings.parse(values);
+        return java.util.Map.copyOf(values);
+    }
+
+    private java.util.Map<String, String> quickstepConfiguration() {
+        var values = new java.util.LinkedHashMap<String, String>();
+        for (String key : games.dmg.fantasystick.persistence.QuickstepSettings.keys()) {
+            values.put(key, getConfig().getString(key,
+                games.dmg.fantasystick.persistence.QuickstepSettings.defaultValue(key)));
+        }
+        games.dmg.fantasystick.persistence.QuickstepSettings.parse(values);
+        return java.util.Map.copyOf(values);
+    }
+
     private games.dmg.fantasystick.ability.GreatSword.Settings greatSwordSettings() {
         try {
             var base = new java.math.BigInteger(getConfig().getString("great-sword-base-damage", "7"));

src/main/java/games/dmg/fantasystick/ability/Longbow.java

@@ -0,0 +1,220 @@
+package games.dmg.fantasystick.ability;
+
+import games.dmg.fantasystick.progression.Stat;
+import games.dmg.fantasystick.session.ControlInput;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.math.MathContext;
+import java.time.Duration;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.damage.DamageSource;
+import org.bukkit.damage.DamageType;
+import org.bukkit.entity.AbstractArrow;
+import org.bukkit.entity.Arrow;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.ProjectileHitEvent;
+import org.bukkit.util.Vector;
+
+/** Longbow's ammunition-free native draw and bounded custom-arrow damage adapter. */
+public final class Longbow implements AbilityEffect, Listener, AutoCloseable {
+    private static final BigInteger MAX_NATIVE_BASE = BigDecimal.valueOf(Double.MAX_VALUE).toBigInteger();
+
+    public record Settings(BigInteger baseDamage, Duration recovery, int minimumDrawTicks, int fullDrawTicks,
+                           double range, Duration lifetime, double fullSpeedPerTick) {
+        public Settings {
+            Objects.requireNonNull(baseDamage); Objects.requireNonNull(recovery); Objects.requireNonNull(lifetime);
+            if (baseDamage.signum() < 0 || baseDamage.compareTo(MAX_NATIVE_BASE) > 0
+                    || recovery.compareTo(Duration.ofSeconds(1)) < 0
+                    || recovery.compareTo(Duration.ofDays(365)) > 0
+                    || minimumDrawTicks < 1 || minimumDrawTicks > 72_000
+                    || fullDrawTicks < minimumDrawTicks || fullDrawTicks > 72_000
+                    || !Double.isFinite(range) || range <= 0 || range > 1024
+                    || lifetime.isZero() || lifetime.isNegative() || lifetime.compareTo(Duration.ofSeconds(60)) > 0
+                    || !Double.isFinite(fullSpeedPerTick) || fullSpeedPerTick < 0.01 || fullSpeedPerTick > 64) {
+                throw new IllegalArgumentException("Invalid Longbow settings");
+            }
+        }
+        public static Settings defaults() {
+            return new Settings(BigInteger.valueOf(5), Duration.ofSeconds(1), 3, 20, 64,
+                Duration.ofSeconds(10), 3);
+        }
+    }
+
+    private final class State implements AutoCloseable {
+        final Arrow arrow;
+        final AbilityExecution execution;
+        final Location origin;
+        final Settings settings;
+        final BigDecimal damage;
+        LivingEntity target;
+        boolean accepted;
+        boolean finished;
+        State(Arrow arrow, AbilityExecution execution, Location origin, Settings settings, BigDecimal damage) {
+            this.arrow = arrow; this.execution = execution; this.origin = origin; this.settings = settings; this.damage = damage;
+        }
+        @Override public void close() {
+            if (finished) return;
+            finished = true; arrows.remove(arrow.getUniqueId(), this); arrow.remove();
+        }
+    }
+
+    private volatile Settings settings;
+    private final Map<UUID, State> arrows = new HashMap<>();
+    private State damaging;
+    private boolean closed;
+
+    public Longbow(Settings settings) { this.settings = Objects.requireNonNull(settings); }
+    public void configure(Settings settings) { this.settings = Objects.requireNonNull(settings); }
+
+    public AbilityDefinition definition() {
+        var current = settings;
+        return new AbilityDefinition("longbow", "Longbow", Material.BOW,
+            List.of("Draw and release an ammunition-free owned arrow.",
+                "A full draw deals " + current.baseDamage() + " + DEX modifier damage."),
+            "Draw by holding use; release after at least " + current.minimumDrawTicks() + " ticks.",
+            Map.of(Stat.DEX, BigInteger.valueOf(14)), BigInteger.ONE,
+            AbilityDefinition.Activation.PROJECTILE, ControlInput.Gesture.DRAW_RELEASE, current.recovery(),
+            Map.of("base-damage", new BigDecimal(current.baseDamage()),
+                "minimum-draw-ticks", BigDecimal.valueOf(current.minimumDrawTicks()),
+                "full-draw-ticks", BigDecimal.valueOf(current.fullDrawTicks()),
+                "range", BigDecimal.valueOf(current.range()).stripTrailingZeros(),
+                "lifetime", seconds(current.lifetime()),
+                "full-projectile-speed", BigDecimal.valueOf(current.fullSpeedPerTick()).stripTrailingZeros()),
+            AbilityDefinition.TargetPolicy.PROJECTILE_HOSTILE, this);
+    }
+
+    @Override public boolean accepts(ControlInput input) {
+        return input.gesture() == ControlInput.Gesture.DRAW_RELEASE && input.heldTicks() >= settings.minimumDrawTicks();
+    }
+
+    public static BigDecimal power(int heldTicks, int fullDrawTicks) {
+        if (heldTicks < 0 || fullDrawTicks < 1) throw new IllegalArgumentException("Invalid Longbow draw");
+        var x = BigDecimal.valueOf(heldTicks).divide(BigDecimal.valueOf(fullDrawTicks), MathContext.DECIMAL128);
+        var power = x.multiply(x, MathContext.DECIMAL128).add(x.multiply(BigDecimal.TWO), MathContext.DECIMAL128)
+            .divide(BigDecimal.valueOf(3), MathContext.DECIMAL128);
+        return power.min(BigDecimal.ONE);
+    }
+
+    public static BigInteger fullDamage(BigInteger dexterity) {
+        return fullDamage(BigInteger.valueOf(5), dexterity);
+    }
+
+    static BigInteger fullDamage(BigInteger base, BigInteger dexterity) {
+        Objects.requireNonNull(base); Objects.requireNonNull(dexterity);
+        if (base.signum() < 0 || dexterity.signum() < 0) throw new IllegalArgumentException("Invalid Longbow damage input");
+        BigInteger delta = dexterity.subtract(BigInteger.TEN);
+        BigInteger[] divided = delta.divideAndRemainder(BigInteger.TWO);
+        BigInteger modifier = divided[0];
+        if (delta.signum() < 0 && divided[1].signum() != 0) modifier = modifier.subtract(BigInteger.ONE);
+        return base.add(modifier);
+    }
+
+    @Override public void activate(AbilityExecution execution) {
+        if (closed || !execution.stillCurrent()) return;
+        Settings shot = from(execution.definition());
+        BigDecimal power = power(execution.input().heldTicks(), shot.fullDrawTicks());
+        var player = execution.input().player();
+        Location origin = player.getEyeLocation().clone();
+        Vector direction = origin.getDirection();
+        if (!Double.isFinite(direction.getX()) || !Double.isFinite(direction.getY()) || !Double.isFinite(direction.getZ())
+                || direction.lengthSquared() == 0) throw new IllegalStateException("Longbow direction is unavailable");
+        double speed = BigDecimal.valueOf(shot.fullSpeedPerTick()).multiply(power, MathContext.DECIMAL128).doubleValue();
+        var arrow = player.launchProjectile(Arrow.class, direction.normalize().multiply(speed));
+        arrow.setPickupStatus(AbstractArrow.PickupStatus.DISALLOWED);
+        arrow.setDamage(0); arrow.setKnockbackStrength(0); arrow.setPierceLevel(0); arrow.setCritical(false);
+        var damage = new BigDecimal(fullDamage(shot.baseDamage(), execution.character().stats().get(Stat.DEX)))
+            .multiply(power, MathContext.DECIMAL128);
+        var state = new State(arrow, execution, origin, shot, damage);
+        if (arrows.putIfAbsent(arrow.getUniqueId(), state) != null) {
+            arrow.remove(); throw new IllegalStateException("Duplicate Longbow arrow identity");
+        }
+        execution.own(state);
+        long rangeTicks = Math.max(1, (long) Math.ceil(shot.range() / speed));
+        execution.later(Duration.ofMillis(Math.multiplyExact(rangeTicks, 50)), () -> {
+            if (arrows.containsKey(arrow.getUniqueId())) execution.finish();
+        });
+        execution.later(shot.lifetime(), () -> {
+            if (arrows.containsKey(arrow.getUniqueId())) execution.finish();
+        });
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void containNativeDamage(EntityDamageByEntityEvent event) {
+        if (!(event.getDamager() instanceof Arrow arrow)) return;
+        var state = arrows.get(arrow.getUniqueId());
+        if (state != null && damaging != state) event.setCancelled(true);
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void hit(ProjectileHitEvent event) {
+        var state = arrows.remove(event.getEntity().getUniqueId());
+        if (state == null) return;
+        try {
+            if (closed || event.isCancelled() || !state.execution.stillCurrent()
+                    || !(event.getHitEntity() instanceof LivingEntity target)
+                    || !inRange(state, event.getEntity().getLocation())
+                    || state.execution.eligible(List.of(target), 1).isEmpty()) return;
+            double nativeDamage = state.damage.compareTo(BigDecimal.valueOf(Double.MAX_VALUE)) > 0
+                ? Double.MAX_VALUE : state.damage.doubleValue();
+            if (!Double.isFinite(nativeDamage) || nativeDamage <= 0) return;
+            var source = DamageSource.builder(DamageType.ARROW).withCausingEntity(state.execution.input().player())
+                .withDirectEntity(state.arrow).withDamageLocation(state.arrow.getLocation()).build();
+            state.target = target; damaging = state;
+            try { target.damage(nativeDamage, source); }
+            finally { if (damaging == state) damaging = null; }
+        } finally {
+            state.close(); state.execution.finish();
+        }
+    }
+
+    private static boolean inRange(State state, Location current) {
+        return current.getWorld() != null && state.origin.getWorld() != null
+            && current.getWorld().equals(state.origin.getWorld())
+            && current.distanceSquared(state.origin) <= state.settings.range() * state.settings.range();
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void acceptedDamage(EntityDamageEvent event) {
+        var state = damaging;
+        if (state == null || state.accepted || event.getEntity() != state.target || event.getFinalDamage() <= 0
+                || !Double.isFinite(event.getFinalDamage())) return;
+        var direct = event.getDamageSource().getDirectEntity();
+        if (direct != state.arrow && (!(event instanceof EntityDamageByEntityEvent byEntity)
+                || byEntity.getDamager() != state.arrow)) return;
+        state.accepted = true;
+        state.execution.report(AbilityReport.Type.DAMAGE, event.getEntity(), BigDecimal.valueOf(event.getFinalDamage()));
+    }
+
+    private static Settings from(AbilityDefinition definition) {
+        var p = definition.parameters();
+        return new Settings(p.get("base-damage").toBigIntegerExact(), definition.cooldown(),
+            p.get("minimum-draw-ticks").intValueExact(), p.get("full-draw-ticks").intValueExact(),
+            p.get("range").doubleValue(), duration(p.get("lifetime")),
+            p.get("full-projectile-speed").doubleValue());
+    }
+
+    private static Duration duration(BigDecimal seconds) {
+        return Duration.ofNanos(seconds.movePointRight(9).toBigIntegerExact().longValueExact());
+    }
+    private static BigDecimal seconds(Duration duration) {
+        return BigDecimal.valueOf(duration.getSeconds()).add(BigDecimal.valueOf(duration.getNano(), 9)).stripTrailingZeros();
+    }
+
+    @Override public void close() {
+        if (closed) return;
+        closed = true;
+        for (var state : List.copyOf(arrows.values())) state.execution.finish();
+        arrows.clear(); damaging = null;
+    }
+}

src/main/java/games/dmg/fantasystick/ability/Quickstep.java

@@ -0,0 +1,153 @@
+package games.dmg.fantasystick.ability;
+
+import games.dmg.fantasystick.progression.Stat;
+import games.dmg.fantasystick.session.ControlInput;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.time.Duration;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.function.Consumer;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.event.player.PlayerVelocityEvent;
+import org.bukkit.util.Vector;
+
+/** Quickstep's grounded, collision-respecting, owned horizontal velocity adapter. */
+public final class Quickstep implements AbilityEffect, Listener, AutoCloseable {
+    public record Settings(Duration cooldown, double distance, double speedPerTick) {
+        public Settings {
+            Objects.requireNonNull(cooldown);
+            if (cooldown.isNegative() || cooldown.compareTo(Duration.ofDays(365)) > 0
+                    || !Double.isFinite(distance) || distance <= 0 || distance > 64
+                    || !Double.isFinite(speedPerTick) || speedPerTick < 0.01 || speedPerTick > 8) {
+                throw new IllegalArgumentException("Invalid Quickstep settings");
+            }
+        }
+        public static Settings defaults() { return new Settings(Duration.ofSeconds(5), 4, 1); }
+    }
+
+    private final class State implements AutoCloseable {
+        final AbilityExecution execution;
+        final Player player;
+        final Location origin;
+        final Vector horizontal;
+        final Settings settings;
+        boolean owned = true;
+        boolean closed;
+        State(AbilityExecution execution, Player player, Location origin, Vector horizontal, Settings settings) {
+            this.execution = execution; this.player = player; this.origin = origin;
+            this.horizontal = horizontal; this.settings = settings;
+        }
+        boolean stillOwns(Vector current) {
+            var horizontalCurrent = new Vector(current.getX(), 0, current.getZ());
+            double magnitude = horizontalCurrent.length();
+            if (magnitude < 1.0e-6) return true;
+            return magnitude <= horizontal.length() * 1.05 + 1.0e-6
+                && horizontalCurrent.clone().normalize().dot(horizontal.clone().normalize()) >= 0.99;
+        }
+        @Override public void close() {
+            if (closed) return;
+            closed = true; dashes.remove(player.getUniqueId(), this);
+            if (!owned) return;
+            Vector current = player.getVelocity();
+            if (!stillOwns(current)) return;
+            player.setVelocity(new Vector(0, current.getY(), 0));
+        }
+    }
+
+    private volatile Settings settings;
+    private final Consumer<PlayerVelocityEvent> velocityEvents;
+    private final Map<UUID, State> dashes = new HashMap<>();
+    private boolean closed;
+
+    public Quickstep(Settings settings, Consumer<PlayerVelocityEvent> velocityEvents) {
+        this.settings = Objects.requireNonNull(settings); this.velocityEvents = Objects.requireNonNull(velocityEvents);
+    }
+    public void configure(Settings settings) { this.settings = Objects.requireNonNull(settings); }
+
+    public AbilityDefinition definition() {
+        var current = settings;
+        return new AbilityDefinition("quickstep", "Quickstep", Material.RABBIT_FOOT,
+            List.of("Dash forward with native horizontal movement.",
+                "Travel up to " + decimal(current.distance()) + " blocks while obstacles remain authoritative."),
+            "Use while grounded, on foot, and not flying or gliding.",
+            Map.of(Stat.DEX, BigInteger.valueOf(12)), BigInteger.ONE,
+            AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
+            Map.of("distance", BigDecimal.valueOf(current.distance()).stripTrailingZeros(),
+                "speed", BigDecimal.valueOf(current.speedPerTick()).stripTrailingZeros()),
+            AbilityDefinition.TargetPolicy.SELF, this);
+    }
+
+    @Override public boolean accepts(ControlInput input) {
+        var player = input.player();
+        if (!player.isOnGround() || player.isFlying() || player.isGliding() || player.isInsideVehicle()) return false;
+        Vector direction = player.getEyeLocation().getDirection(); direction.setY(0);
+        return finite(direction) && direction.lengthSquared() > 1.0e-12;
+    }
+
+    @Override public void activate(AbilityExecution execution) {
+        if (closed || !execution.stillCurrent()) return;
+        var current = from(execution.definition());
+        var player = execution.input().player();
+        if (!accepts(execution.input())) { execution.finish(); return; }
+        Vector direction = player.getEyeLocation().getDirection(); direction.setY(0).normalize();
+        Vector before = player.getVelocity();
+        Vector horizontal = direction.multiply(current.speedPerTick());
+        var proposed = new Vector(horizontal.getX(), before.getY(), horizontal.getZ());
+        var event = new PlayerVelocityEvent(player, proposed.clone());
+        velocityEvents.accept(event);
+        if (event.isCancelled() || !finite(event.getVelocity())) { execution.finish(); return; }
+        Vector accepted = event.getVelocity().clone(); accepted.setY(before.getY());
+        Vector acceptedHorizontal = new Vector(accepted.getX(), 0, accepted.getZ());
+        if (acceptedHorizontal.lengthSquared() < 1.0e-12) { execution.finish(); return; }
+        var state = new State(execution, player, player.getLocation().clone(), acceptedHorizontal, current);
+        var previous = dashes.put(player.getUniqueId(), state);
+        if (previous != null) previous.execution.finish();
+        execution.own(state);
+        player.setVelocity(accepted);
+        long ticks = Math.max(1, (long) Math.ceil(current.distance() / acceptedHorizontal.length()));
+        execution.later(Duration.ofMillis(Math.multiplyExact(ticks + 1, 50)), execution::finish);
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void moved(PlayerMoveEvent event) {
+        var state = dashes.get(event.getPlayer().getUniqueId());
+        if (state == null || state.player != event.getPlayer()) return;
+        var to = event.getTo();
+        if (to == null || !state.execution.stillCurrent()) { state.execution.finish(); return; }
+        Vector current = state.player.getVelocity();
+        if (!state.stillOwns(current)) {
+            state.owned = false; state.execution.finish(); return;
+        }
+        double dx = to.getX() - state.origin.getX(); double dz = to.getZ() - state.origin.getZ();
+        if (dx * dx + dz * dz >= state.settings.distance() * state.settings.distance()
+                || new Vector(current.getX(), 0, current.getZ()).lengthSquared() < 1.0e-12) {
+            state.execution.finish();
+        }
+    }
+
+    private static boolean finite(Vector vector) {
+        return Double.isFinite(vector.getX()) && Double.isFinite(vector.getY()) && Double.isFinite(vector.getZ());
+    }
+    private static Settings from(AbilityDefinition definition) {
+        return new Settings(definition.cooldown(), definition.parameters().get("distance").doubleValue(),
+            definition.parameters().get("speed").doubleValue());
+    }
+    private static BigDecimal decimal(double value) { return BigDecimal.valueOf(value).stripTrailingZeros(); }
+
+    @Override public void close() {
+        if (closed) return;
+        closed = true;
+        for (var state : List.copyOf(dashes.values())) state.execution.finish();
+        dashes.clear();
+    }
+}

src/main/java/games/dmg/fantasystick/persistence/LongbowSettings.java

@@ -0,0 +1,201 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.ability.Longbow;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Serialized durable Longbow settings; publication remains a server-thread caller decision. */
+public final class LongbowSettings implements AutoCloseable {
+    private static final int MAX_BYTES = 1_048_576;
+    public static final String BASE_DAMAGE = "longbow-base-damage";
+    public static final String RECOVERY = "longbow-recovery-seconds";
+    public static final String MINIMUM_DRAW = "longbow-minimum-draw-ticks";
+    public static final String FULL_DRAW = "longbow-full-draw-ticks";
+    public static final String RANGE = "longbow-range-blocks";
+    public static final String LIFETIME = "longbow-lifetime-seconds";
+    public static final String FULL_SPEED = "longbow-full-projectile-speed-blocks-per-tick";
+    private static final List<String> KEYS = List.of(BASE_DAMAGE, RECOVERY, MINIMUM_DRAW, FULL_DRAW, RANGE,
+        LIFETIME, FULL_SPEED);
+    private static final Map<String, String> DEFAULTS = Map.of(BASE_DAMAGE, "5", RECOVERY, "1",
+        MINIMUM_DRAW, "3", FULL_DRAW, "20", RANGE, "64", LIFETIME, "10", FULL_SPEED, "3");
+
+    @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
+    public record Update(String key, String value, Longbow.Settings settings,
+                         Map<String, String> values, long sequence) {
+        public Update { values = Map.copyOf(values); }
+    }
+
+    private final Path directory;
+    private final Replacement replacement;
+    private final java.util.concurrent.ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-longbow-configuration"));
+    private volatile Map<String, String> effectiveValues;
+    private Map<String, String> persistedValues;
+    private long persistedSequence;
+    private long publishedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public LongbowSettings(Path directory, Map<String, String> initial) {
+        this(directory, initial, (from, to) -> Files.move(from, to,
+            StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    LongbowSettings(Path directory, Map<String, String> initial, Replacement replacement) {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath();
+        this.replacement = Objects.requireNonNull(replacement);
+        var copy = new LinkedHashMap<String, String>();
+        for (String key : KEYS) copy.put(key, Objects.requireNonNull(initial.get(key)));
+        parse(copy);
+        effectiveValues = Map.copyOf(copy); persistedValues = Map.copyOf(copy);
+    }
+
+    public static List<String> keys() { return KEYS; }
+    public static String defaultValue(String key) { return DEFAULTS.get(key); }
+    public String value(String key) { return effectiveValues.get(key); }
+    public Longbow.Settings settings() { return parse(effectiveValues); }
+
+    /** Publish only after the caller returns the durable acknowledgment to the server thread. */
+    public synchronized void publish(Update update) {
+        Objects.requireNonNull(update);
+        if (update.sequence() <= publishedSequence) return;
+        parse(update.values());
+        effectiveValues = update.values(); publishedSequence = update.sequence();
+    }
+
+    public CompletionStage<Update> set(String key, String value) {
+        Objects.requireNonNull(key); Objects.requireNonNull(value);
+        if (!KEYS.contains(key)) return CompletableFuture.failedStage(new IllegalArgumentException("Unknown setting"));
+        String accepted = canonical(key, value);
+        var preview = new LinkedHashMap<>(effectiveValues); preview.put(key, accepted);
+        parse(preview); // Fail malformed/out-of-range command input before queueing accepted persistence.
+        synchronized (this) {
+            if (closed) return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+            pending++;
+        }
+        try {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    var next = new LinkedHashMap<>(persistedValues);
+                    next.put(key, accepted);
+                    var parsed = parse(next);
+                    save(key, accepted);
+                    persistedValues = Map.copyOf(next);
+                    return new Update(key, accepted, parsed, persistedValues, ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new java.util.concurrent.CompletionException(failure instanceof IllegalArgumentException
+                        ? failure : new IOException("Longbow configuration save refused or failed; effective settings unchanged"));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished();
+            return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+        }
+    }
+
+    private static String canonical(String key, String raw) {
+        try {
+            if (key.equals(BASE_DAMAGE) || key.equals(MINIMUM_DRAW) || key.equals(FULL_DRAW)) {
+                return new java.math.BigInteger(raw).toString();
+            }
+            return new java.math.BigDecimal(raw).stripTrailingZeros().toPlainString();
+        } catch (NumberFormatException invalid) { throw new IllegalArgumentException("Invalid value", invalid); }
+    }
+
+    public static Longbow.Settings parse(Map<String, String> values) {
+        try {
+            var base = new java.math.BigInteger(values.get(BASE_DAMAGE));
+            var recovery = seconds(values.get(RECOVERY));
+            int minimumDraw = new java.math.BigInteger(values.get(MINIMUM_DRAW)).intValueExact();
+            int fullDraw = new java.math.BigInteger(values.get(FULL_DRAW)).intValueExact();
+            double range = finite(values.get(RANGE));
+            var lifetime = seconds(values.get(LIFETIME));
+            double speed = finite(values.get(FULL_SPEED));
+            return new Longbow.Settings(base, recovery, minimumDraw, fullDraw, range, lifetime, speed);
+        } catch (ArithmeticException | NumberFormatException | NullPointerException invalid) {
+            throw new IllegalArgumentException("Longbow settings must use supported numeric values", invalid);
+        }
+    }
+
+    private static Duration seconds(String value) {
+        var nanos = new java.math.BigDecimal(value).movePointRight(9).toBigIntegerExact().longValueExact();
+        return Duration.ofNanos(nanos);
+    }
+
+    private static double finite(String value) {
+        double result = new java.math.BigDecimal(value).doubleValue();
+        if (!Double.isFinite(result)) throw new IllegalArgumentException("Setting is not finite");
+        return result;
+    }
+
+    private void save(String key, String value) throws IOException {
+        Files.createDirectories(directory);
+        if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe directory");
+        var file = directory.resolve("config.yml");
+        var lockFile = directory.resolve(".config.lock");
+        if (Files.exists(lockFile, LinkOption.NOFOLLOW_LINKS)
+                && !Files.isRegularFile(lockFile, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe lock");
+        try (var channel = FileChannel.open(lockFile, StandardOpenOption.CREATE, StandardOpenOption.WRITE,
+                LinkOption.NOFOLLOW_LINKS); var lock = channel.tryLock()) {
+            if (lock == null) throw new IOException("Configuration busy");
+            var options = new LoaderOptions(); options.setAllowDuplicateKeys(false);
+            options.setMaxAliasesForCollections(20); options.setCodePointLimit(MAX_BYTES);
+            var yaml = new Yaml(new SafeConstructor(options));
+            Map<String, Object> document = new LinkedHashMap<>();
+            if (Files.exists(file, LinkOption.NOFOLLOW_LINKS)) {
+                if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe configuration");
+                byte[] bytes;
+                try (var input = Files.newInputStream(file, LinkOption.NOFOLLOW_LINKS)) { bytes = input.readNBytes(MAX_BYTES + 1); }
+                if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+                Object loaded = yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+                if (loaded != null) {
+                    if (!(loaded instanceof Map<?, ?> map)) throw new IOException("Invalid configuration root");
+                    for (var entry : map.entrySet()) {
+                        if (!(entry.getKey() instanceof String savedKey)) throw new IOException("Invalid configuration key");
+                        document.put(savedKey, entry.getValue());
+                    }
+                }
+            }
+            document.put(key, value);
+            byte[] bytes = yaml.dump(document).getBytes(StandardCharsets.UTF_8);
+            if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+            Path temporary = Files.createTempFile(directory, ".config-", ".tmp");
+            try {
+                try (var output = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                    var buffer = ByteBuffer.wrap(bytes); while (buffer.hasRemaining()) output.write(buffer); output.force(true);
+                }
+                replacement.move(temporary, file);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch (OverlappingFileLockException busy) { throw new IOException("Configuration busy"); }
+    }
+
+    private synchronized void finished() {
+        pending--;
+        if (closed && pending == 0) drained.complete(null);
+    }
+    public CompletionStage<Void> drained() { return drained.minimalCompletionStage(); }
+    @Override public synchronized void close() {
+        closed = true; worker.shutdown(); if (pending == 0) drained.complete(null);
+    }
+}

src/main/java/games/dmg/fantasystick/persistence/QuickstepSettings.java

@@ -0,0 +1,188 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.ability.Quickstep;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Serialized durable Quickstep settings; publication remains a server-thread caller decision. */
+public final class QuickstepSettings implements AutoCloseable {
+    private static final int MAX_BYTES = 1_048_576;
+    public static final String COOLDOWN = "quickstep-cooldown-seconds";
+    public static final String DISTANCE = "quickstep-distance-blocks";
+    public static final String SPEED = "quickstep-speed-blocks-per-tick";
+    private static final List<String> KEYS = List.of(COOLDOWN, DISTANCE, SPEED);
+    private static final Map<String, String> DEFAULTS = Map.of(COOLDOWN, "5", DISTANCE, "4", SPEED, "1");
+
+    @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
+    public record Update(String key, String value, Quickstep.Settings settings,
+                         Map<String, String> values, long sequence) {
+        public Update { values = Map.copyOf(values); }
+    }
+
+    private final Path directory;
+    private final Replacement replacement;
+    private final java.util.concurrent.ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-quickstep-configuration"));
+    private volatile Map<String, String> effectiveValues;
+    private Map<String, String> persistedValues;
+    private long persistedSequence;
+    private long publishedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public QuickstepSettings(Path directory, Map<String, String> initial) {
+        this(directory, initial, (from, to) -> Files.move(from, to,
+            StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    QuickstepSettings(Path directory, Map<String, String> initial, Replacement replacement) {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath();
+        this.replacement = Objects.requireNonNull(replacement);
+        var copy = new LinkedHashMap<String, String>();
+        for (String key : KEYS) copy.put(key, Objects.requireNonNull(initial.get(key)));
+        parse(copy);
+        effectiveValues = Map.copyOf(copy); persistedValues = Map.copyOf(copy);
+    }
+
+    public static List<String> keys() { return KEYS; }
+    public static String defaultValue(String key) { return DEFAULTS.get(key); }
+    public String value(String key) { return effectiveValues.get(key); }
+    public Quickstep.Settings settings() { return parse(effectiveValues); }
+
+    /** Publish only after the caller returns the durable acknowledgment to the server thread. */
+    public synchronized void publish(Update update) {
+        Objects.requireNonNull(update);
+        if (update.sequence() <= publishedSequence) return;
+        parse(update.values());
+        effectiveValues = update.values(); publishedSequence = update.sequence();
+    }
+
+    public CompletionStage<Update> set(String key, String value) {
+        Objects.requireNonNull(key); Objects.requireNonNull(value);
+        if (!KEYS.contains(key)) return CompletableFuture.failedStage(new IllegalArgumentException("Unknown setting"));
+        String accepted = canonical(key, value);
+        var preview = new LinkedHashMap<>(effectiveValues); preview.put(key, accepted);
+        parse(preview); // Fail malformed/out-of-range command input before queueing accepted persistence.
+        synchronized (this) {
+            if (closed) return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+            pending++;
+        }
+        try {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    var next = new LinkedHashMap<>(persistedValues);
+                    next.put(key, accepted);
+                    var parsed = parse(next);
+                    save(key, accepted);
+                    persistedValues = Map.copyOf(next);
+                    return new Update(key, accepted, parsed, persistedValues, ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new java.util.concurrent.CompletionException(failure instanceof IllegalArgumentException
+                        ? failure : new IOException("Quickstep configuration save refused or failed; effective settings unchanged"));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished();
+            return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+        }
+    }
+
+    private static String canonical(String key, String raw) {
+        try {
+            return new java.math.BigDecimal(raw).stripTrailingZeros().toPlainString();
+        } catch (NumberFormatException invalid) { throw new IllegalArgumentException("Invalid value", invalid); }
+    }
+
+    public static Quickstep.Settings parse(Map<String, String> values) {
+        try {
+            var cooldown = seconds(values.get(COOLDOWN));
+            double distance = finite(values.get(DISTANCE));
+            double speed = finite(values.get(SPEED));
+            return new Quickstep.Settings(cooldown, distance, speed);
+        } catch (ArithmeticException | NumberFormatException | NullPointerException invalid) {
+            throw new IllegalArgumentException("Quickstep settings must use supported numeric values", invalid);
+        }
+    }
+
+    private static Duration seconds(String value) {
+        var nanos = new java.math.BigDecimal(value).movePointRight(9).toBigIntegerExact().longValueExact();
+        return Duration.ofNanos(nanos);
+    }
+
+    private static double finite(String value) {
+        double result = new java.math.BigDecimal(value).doubleValue();
+        if (!Double.isFinite(result)) throw new IllegalArgumentException("Setting is not finite");
+        return result;
+    }
+
+    private void save(String key, String value) throws IOException {
+        Files.createDirectories(directory);
+        if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe directory");
+        var file = directory.resolve("config.yml");
+        var lockFile = directory.resolve(".config.lock");
+        if (Files.exists(lockFile, LinkOption.NOFOLLOW_LINKS)
+                && !Files.isRegularFile(lockFile, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe lock");
+        try (var channel = FileChannel.open(lockFile, StandardOpenOption.CREATE, StandardOpenOption.WRITE,
+                LinkOption.NOFOLLOW_LINKS); var lock = channel.tryLock()) {
+            if (lock == null) throw new IOException("Configuration busy");
+            var options = new LoaderOptions(); options.setAllowDuplicateKeys(false);
+            options.setMaxAliasesForCollections(20); options.setCodePointLimit(MAX_BYTES);
+            var yaml = new Yaml(new SafeConstructor(options));
+            Map<String, Object> document = new LinkedHashMap<>();
+            if (Files.exists(file, LinkOption.NOFOLLOW_LINKS)) {
+                if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe configuration");
+                byte[] bytes;
+                try (var input = Files.newInputStream(file, LinkOption.NOFOLLOW_LINKS)) { bytes = input.readNBytes(MAX_BYTES + 1); }
+                if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+                Object loaded = yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+                if (loaded != null) {
+                    if (!(loaded instanceof Map<?, ?> map)) throw new IOException("Invalid configuration root");
+                    for (var entry : map.entrySet()) {
+                        if (!(entry.getKey() instanceof String savedKey)) throw new IOException("Invalid configuration key");
+                        document.put(savedKey, entry.getValue());
+                    }
+                }
+            }
+            document.put(key, value);
+            byte[] bytes = yaml.dump(document).getBytes(StandardCharsets.UTF_8);
+            if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+            Path temporary = Files.createTempFile(directory, ".config-", ".tmp");
+            try {
+                try (var output = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                    var buffer = ByteBuffer.wrap(bytes); while (buffer.hasRemaining()) output.write(buffer); output.force(true);
+                }
+                replacement.move(temporary, file);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch (OverlappingFileLockException busy) { throw new IOException("Configuration busy"); }
+    }
+
+    private synchronized void finished() {
+        pending--;
+        if (closed && pending == 0) drained.complete(null);
+    }
+    public CompletionStage<Void> drained() { return drained.minimalCompletionStage(); }
+    @Override public synchronized void close() {
+        closed = true; worker.shutdown(); if (pending == 0) drained.complete(null);
+    }
+}

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

@@ -24,6 +24,10 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     private games.dmg.fantasystick.persistence.FrostShardSettings frostSettings;
     private games.dmg.fantasystick.ability.FrostShard frostShard;
     private games.dmg.fantasystick.ability.AbilityRegistry abilities;
+    private games.dmg.fantasystick.persistence.LongbowSettings longbowSettings;
+    private games.dmg.fantasystick.ability.Longbow longbow;
+    private games.dmg.fantasystick.persistence.QuickstepSettings quickstepSettings;
+    private games.dmg.fantasystick.ability.Quickstep quickstep;
 
     public EquipmentAdminCommand(EquipmentSessionStore receipts, EquipmentSessions sessions, Server server,
                                  Consumer<Runnable> nextTick, Consumer<Failure> diagnostics) {
@@ -53,6 +57,35 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         this.abilities = Objects.requireNonNull(abilities);
     }
 
+    public EquipmentAdminCommand(EquipmentSessionStore receipts, EquipmentSessions sessions, Server server,
+                                 Consumer<Runnable> nextTick, Consumer<Failure> diagnostics,
+                                 games.dmg.fantasystick.persistence.AdventureSettings settings,
+                                 games.dmg.fantasystick.persistence.FrostShardSettings frostSettings,
+                                 games.dmg.fantasystick.ability.FrostShard frostShard,
+                                 games.dmg.fantasystick.persistence.LongbowSettings longbowSettings,
+                                 games.dmg.fantasystick.ability.Longbow longbow,
+                                 games.dmg.fantasystick.ability.AbilityRegistry abilities) {
+        this(receipts, sessions, server, nextTick, diagnostics, settings, frostSettings, frostShard, abilities);
+        this.longbowSettings = Objects.requireNonNull(longbowSettings);
+        this.longbow = Objects.requireNonNull(longbow);
+    }
+
+    public EquipmentAdminCommand(EquipmentSessionStore receipts, EquipmentSessions sessions, Server server,
+                                 Consumer<Runnable> nextTick, Consumer<Failure> diagnostics,
+                                 games.dmg.fantasystick.persistence.AdventureSettings settings,
+                                 games.dmg.fantasystick.persistence.FrostShardSettings frostSettings,
+                                 games.dmg.fantasystick.ability.FrostShard frostShard,
+                                 games.dmg.fantasystick.persistence.LongbowSettings longbowSettings,
+                                 games.dmg.fantasystick.ability.Longbow longbow,
+                                 games.dmg.fantasystick.persistence.QuickstepSettings quickstepSettings,
+                                 games.dmg.fantasystick.ability.Quickstep quickstep,
+                                 games.dmg.fantasystick.ability.AbilityRegistry abilities) {
+        this(receipts, sessions, server, nextTick, diagnostics, settings, frostSettings, frostShard,
+            longbowSettings, longbow, abilities);
+        this.quickstepSettings = Objects.requireNonNull(quickstepSettings);
+        this.quickstep = Objects.requireNonNull(quickstep);
+    }
+
     @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         if (closed) return true;
         if (!sender.hasPermission(PERMISSION)) {
@@ -126,6 +159,12 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     private void configuration(CommandSender sender, String[] args) {
         if (args.length < 2 || args.length > 3) { configurationUsage(sender); return; }
         if (args[1].equals("adventure-mode")) { adventureConfiguration(sender, args); return; }
+        if (longbowSettings != null && games.dmg.fantasystick.persistence.LongbowSettings.keys().contains(args[1])) {
+            longbowConfiguration(sender, args); return;
+        }
+        if (quickstepSettings != null && games.dmg.fantasystick.persistence.QuickstepSettings.keys().contains(args[1])) {
+            quickstepConfiguration(sender, args); return;
+        }
         if (frostSettings == null || !games.dmg.fantasystick.persistence.FrostShardSettings.keys().contains(args[1])) {
             configurationUsage(sender); return;
         }
@@ -160,6 +199,69 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         });
     }
 
+    private void longbowConfiguration(CommandSender sender, String[] args) {
+        String key = args[1];
+        if (args.length == 2) {
+            sender.sendMessage(key + "=" + longbowSettings.value(key) + " (applies to future Longbow shots only)");
+            return;
+        }
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.LongbowSettings.Update> operation;
+        try { operation = longbowSettings.set(key, args[2]); }
+        catch (IllegalArgumentException invalid) {
+            sender.sendMessage("Longbow setting is invalid; the effective value is unchanged."); return;
+        }
+        operation.whenComplete((saved, failure) -> {
+            if (failure != null) report(null, "config-" + key, failure);
+            if (closed) return;
+            try {
+                nextTick.accept(() -> {
+                    if (closed) return;
+                    if (failure == null) {
+                        longbow.configure(saved.settings());
+                        abilities.replace(longbow.definition());
+                        longbowSettings.publish(saved);
+                    }
+                    if (!sender.hasPermission(PERMISSION)
+                            || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+                    sender.sendMessage(failure == null
+                        ? "Saved " + key + "=" + saved.value() + " for future Longbow shots; active shots and deadlines are unchanged."
+                        : "Longbow configuration save failed; the effective setting is unchanged.");
+                });
+            } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
+        });
+    }
+
+    private void quickstepConfiguration(CommandSender sender, String[] args) {
+        String key = args[1];
+        if (args.length == 2) {
+            sender.sendMessage(key + "=" + quickstepSettings.value(key) + " (applies to future Quickstep dashes only)");
+            return;
+        }
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.QuickstepSettings.Update> operation;
+        try { operation = quickstepSettings.set(key, args[2]); }
+        catch (IllegalArgumentException invalid) {
+            sender.sendMessage("Quickstep setting is invalid; the effective value is unchanged."); return;
+        }
+        operation.whenComplete((saved, failure) -> {
+            if (failure != null) report(null, "config-" + key, failure);
+            if (closed) return;
+            try {
+                nextTick.accept(() -> {
+                    if (closed) return;
+                    if (failure == null) {
+                        quickstep.configure(saved.settings()); abilities.replace(quickstep.definition());
+                        quickstepSettings.publish(saved);
+                    }
+                    if (!sender.hasPermission(PERMISSION)
+                            || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+                    sender.sendMessage(failure == null
+                        ? "Saved " + key + "=" + saved.value() + " for future Quickstep dashes; active movement and deadlines are unchanged."
+                        : "Quickstep configuration save failed; the effective setting is unchanged.");
+                });
+            } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
+        });
+    }
+
     private void adventureConfiguration(CommandSender sender, String[] args) {
         if (args.length == 3 && !args[2].equals("true") && !args[2].equals("false")) {
             sender.sendMessage("Usage: /fantasystick config adventure-mode [true|false]"); return;
@@ -199,6 +301,8 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         if (args.length == 2 && args[0].equals("config")) {
             var keys = new java.util.ArrayList<String>(); keys.add("adventure-mode");
             keys.addAll(games.dmg.fantasystick.persistence.FrostShardSettings.keys());
+            keys.addAll(games.dmg.fantasystick.persistence.LongbowSettings.keys());
+            keys.addAll(games.dmg.fantasystick.persistence.QuickstepSettings.keys());
             return matching(keys, args[1]);
         }
         if (args.length == 3 && args[0].equals("config")) {
@@ -208,6 +312,16 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
                 String defaults = games.dmg.fantasystick.persistence.FrostShardSettings.defaultValue(args[1]);
                 return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
             }
+            if (longbowSettings != null && games.dmg.fantasystick.persistence.LongbowSettings.keys().contains(args[1])) {
+                String current = longbowSettings.value(args[1]);
+                String defaults = games.dmg.fantasystick.persistence.LongbowSettings.defaultValue(args[1]);
+                return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
+            }
+            if (quickstepSettings != null && games.dmg.fantasystick.persistence.QuickstepSettings.keys().contains(args[1])) {
+                String current = quickstepSettings.value(args[1]);
+                String defaults = games.dmg.fantasystick.persistence.QuickstepSettings.defaultValue(args[1]);
+                return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
+            }
         }
         return List.of();
     }

src/main/resources/config.yml

@@ -35,3 +35,19 @@ frost-shard-lifetime-seconds: 5
 frost-shard-projectile-speed-blocks-per-tick: 1
 frost-shard-slowness-amplifier: 0
 frost-shard-slowness-duration-seconds: 2
+
+# Longbow defaults from the reviewed remaining-development packet.
+# Admin command: /fantasystick config <key> [value]
+longbow-base-damage: 5
+longbow-recovery-seconds: 1
+longbow-minimum-draw-ticks: 3
+longbow-full-draw-ticks: 20
+longbow-range-blocks: 64
+longbow-lifetime-seconds: 10
+longbow-full-projectile-speed-blocks-per-tick: 3
+
+# Quickstep defaults from the reviewed remaining-development packet.
+# Admin command: /fantasystick config <key> [value]
+quickstep-cooldown-seconds: 5
+quickstep-distance-blocks: 4
+quickstep-speed-blocks-per-tick: 1

src/main/resources/plugin.yml

@@ -7,7 +7,7 @@ description: Transferable characters, native fantasy health, recoverable equipme
 author: dmg.games
 commands:
   fantasystick:
-    description: Inspect/recover equipment sessions or configure fantasy mode.
+    description: Inspect/recover equipment sessions or configure Fantasy Stick.
     usage: /fantasystick <inspect|recover> <player-uuid> | config <setting> [value]
     permission: fantasystick.admin
 permissions:

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

@@ -0,0 +1,479 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.progression.Stat;
+import java.math.BigInteger;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.List;
+import net.minecraft.network.chat.ClickEvent;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.damage.DamageSource;
+import org.bukkit.entity.AbstractArrow;
+import org.bukkit.entity.Arrow;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityDeathEvent;
+import org.bukkit.event.entity.ProjectileHitEvent;
+import org.bukkit.event.entity.ProjectileLaunchEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.util.Vector;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.mockito.ArgumentCaptor;
+
+class LongbowNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void bookAcquisitionNativeDrawFullShotDamageAttributionAndPersistentRecovery() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withStats(data, a, 0, 14);
+            f.players.put(a.core.id, a.player); f.activate(a);
+            a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
+            String text = PartyBookNativeTest.text(a).replaceAll("\\s+", "");
+            assertTrue(text.contains("Longbow")); assertTrue(text.contains("DEX14"));
+            assertTrue(text.contains("Cost:1"), text); assertTrue(text.contains("Draw"), text);
+            assertTrue(text.contains("1s"), text);
+            PartyBookNativeTest.click(f, a, abilityButton(a, "[Learn]", "longbow"));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            PartyBookNativeTest.click(f, a, abilityButton(a, "[3]", "longbow"));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            var learned = storage.find(a.core.record.id()).get().orElseThrow();
+            assertTrue(learned.learned().contains("longbow")); assertEquals("longbow", learned.loadout().getFirst());
+            assertEquals(BigInteger.valueOf(39), learned.unspentPoints());
+
+            when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());
+            var arrow = arrow(a, new Location(a.world, 6, 65.6, 0));
+            doAnswer(call -> { f.dispatcher.accept(new ProjectileLaunchEvent(arrow)); return arrow; })
+                .when(a.player).launchProjectile(eq(Arrow.class), any(Vector.class));
+            var target = mock(LivingEntity.class); when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            when(target.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            when(target.getLocation()).thenReturn(new Location(a.world, 6, 65.6, 0)); when(target.getWorld()).thenReturn(a.world);
+            var damages = new ArrayList<EntityDamageByEntityEvent>();
+            doAnswer(call -> {
+                var source = call.getArgument(1, DamageSource.class);
+                var event = new EntityDamageByEntityEvent(arrow, target, EntityDamageEvent.DamageCause.PROJECTILE,
+                    source, (Double) call.getArgument(0)); damages.add(event); f.dispatcher.accept(event); return null;
+            }).when(target).damage(anyDouble(), any(DamageSource.class));
+            a.core.inventory.setItem(20, new ItemStack(Material.ARROW, 32));
+            drawAndRelease(f, a, 20); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var velocity = ArgumentCaptor.forClass(Vector.class);
+            verify(a.player).launchProjectile(eq(Arrow.class), velocity.capture());
+            assertEquals(3.0, velocity.getValue().length(), 1.0e-9);
+            verify(arrow).setPickupStatus(AbstractArrow.PickupStatus.DISALLOWED);
+            verify(arrow).setDamage(0);
+            assertEquals(32, a.core.inventory.getItem(20).getAmount(), "Ordinary ammunition must remain untouched");
+            f.dispatcher.accept(new ProjectileHitEvent(arrow, target));
+            assertEquals(1, damages.size()); assertEquals(7.0, damages.getFirst().getFinalDamage(), 1.0e-9);
+            f.dispatcher.accept(new EntityDeathEvent(target, damages.getFirst().getDamageSource(), new ArrayList<>(), 0));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var saved = storage.find(a.core.record.id()).get().orElseThrow();
+            assertEquals(BigInteger.TEN, saved.experience()); assertNotNull(saved.cooldowns().get("longbow"));
+            f.dispatcher.accept(new ProjectileHitEvent(arrow, target)); assertEquals(1, damages.size());
+        }
+    }
+
+    @Test void partialDrawUsesReviewedCurveWhileTooShortDrawRefusesBeforeCooldown() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withLongbow(data, a, 14);
+            f.players.put(a.core.id, a.player); f.activate(a); when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());
+            var arrow = arrow(a, new Location(a.world, 6, 65.6, 0));
+            doAnswer(call -> { f.dispatcher.accept(new ProjectileLaunchEvent(arrow)); return arrow; })
+                .when(a.player).launchProjectile(eq(Arrow.class), any(Vector.class));
+            drawAndRelease(f, a, 2);
+            verify(a.player, never()).launchProjectile(eq(Arrow.class), any(Vector.class));
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            assertFalse(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().containsKey("longbow"));
+            assertTrue(a.messages.stream().anyMatch(message -> message.contains("not eligible")));
+
+            var target = mock(LivingEntity.class); when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            when(target.getLocation()).thenReturn(new Location(a.world, 6, 65.6, 0));
+            var amount = new double[1];
+            doAnswer(call -> {
+                amount[0] = call.getArgument(0); var source = call.getArgument(1, DamageSource.class);
+                f.dispatcher.accept(new EntityDamageByEntityEvent(arrow, target, EntityDamageEvent.DamageCause.PROJECTILE,
+                    source, amount[0])); return null;
+            }).when(target).damage(anyDouble(), any(DamageSource.class));
+            drawAndRelease(f, a, 10); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            f.dispatcher.accept(new ProjectileHitEvent(arrow, target));
+            assertEquals(7.0 * (0.25 + 1.0) / 3.0, amount[0], 1.0e-9);
+        }
+    }
+
+    @Test void nativeDamagePartyTargetsAndCancelledCustomDamageProduceNoAcceptedHit() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); var b = new FantasyStickLifecycleNativeTest.Actor(data);
+            withLongbow(data, a, 14); f.players.put(a.core.id, a.player); f.players.put(b.core.id, b.player);
+            f.activate(a); f.activate(b); when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());
+            var party = PartyLifecycleNativeTest.parties(f).create(a.core.id).orElseThrow();
+            assertTrue(PartyLifecycleNativeTest.parties(f).accept(b.core.id,
+                PartyLifecycleNativeTest.parties(f).invite(a.core.id, party.id(), b.core.id).orElseThrow().id()));
+            var arrow = arrow(a, new Location(a.world, 4, 65.6, 0));
+            doAnswer(call -> { f.dispatcher.accept(new ProjectileLaunchEvent(arrow)); return arrow; })
+                .when(a.player).launchProjectile(eq(Arrow.class), any(Vector.class));
+            drawAndRelease(f, a, 20); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var ordinaryTarget = mock(LivingEntity.class); when(ordinaryTarget.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            var nativeDamage = new EntityDamageByEntityEvent(arrow, ordinaryTarget,
+                EntityDamageEvent.DamageCause.PROJECTILE, 7.0);
+            f.dispatcher.accept(nativeDamage); assertTrue(nativeDamage.isCancelled(), "Owned arrows cannot add vanilla damage");
+            f.dispatcher.accept(new ProjectileHitEvent(arrow, b.player));
+            verify(b.player, never()).damage(anyDouble(), any(DamageSource.class));
+
+            var c = new FantasyStickLifecycleNativeTest.Actor(data); withLongbow(data, c, 14);
+            f.players.put(c.core.id, c.player); f.activate(c); when(c.world.getUID()).thenReturn(java.util.UUID.randomUUID());
+            var arrow2 = arrow(c, new Location(c.world, 4, 65.6, 0));
+            doAnswer(call -> { f.dispatcher.accept(new ProjectileLaunchEvent(arrow2)); return arrow2; })
+                .when(c.player).launchProjectile(eq(Arrow.class), any(Vector.class));
+            var hostile = mock(LivingEntity.class); when(hostile.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            when(hostile.getLocation()).thenReturn(new Location(c.world, 4, 65.6, 0));
+            doAnswer(call -> {
+                var source = call.getArgument(1, DamageSource.class);
+                var event = new EntityDamageByEntityEvent(arrow2, hostile, EntityDamageEvent.DamageCause.PROJECTILE,
+                    source, (Double) call.getArgument(0)); event.setCancelled(true); f.dispatcher.accept(event); return null;
+            }).when(hostile).damage(anyDouble(), any(DamageSource.class));
+            drawAndRelease(f, c, 20); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            f.dispatcher.accept(new ProjectileHitEvent(arrow2, hostile));
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            assertEquals(BigInteger.ZERO, storage.find(c.core.record.id()).get().orElseThrow().experience());
+            assertNotNull(storage.find(c.core.record.id()).get().orElseThrow().cooldowns().get("longbow"));
+        }
+    }
+
+    @Test void rangeLifetimeAndSessionEndRemoveOwnedArrowsWithoutLateDamage() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var target = mock(LivingEntity.class); when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            for (int route = 0; route < 3; route++) {
+                var a = new FantasyStickLifecycleNativeTest.Actor(data); withLongbow(data, a, 14);
+                f.players.put(a.core.id, a.player); f.activate(a); when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());
+                var location = new Location(a.world, route == 0 ? 64.01 : 2, 65.6, 0);
+                var arrow = arrow(a, location);
+                doAnswer(call -> { f.dispatcher.accept(new ProjectileLaunchEvent(arrow)); return arrow; })
+                    .when(a.player).launchProjectile(eq(Arrow.class), any(Vector.class));
+                drawAndRelease(f, a, 20); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+                if (route == 0) {
+                    f.dispatcher.accept(new ProjectileHitEvent(arrow, target));
+                    verify(target, never()).damage(anyDouble(), any(DamageSource.class));
+                } else if (route == 1) {
+                    f.delayed.getLast().run();
+                    f.dispatcher.accept(new ProjectileHitEvent(arrow, target));
+                    verify(target, never()).damage(anyDouble(), any(DamageSource.class));
+                } else {
+                    a.core.inventory.setItemInOffHand(null); f.changed(a); PartyBookNativeTest.drain(f); f.awaitCharacterAndReceipt(a);
+                    ((games.dmg.fantasystick.ability.AbilityEngine) FantasyStickLifecycleNativeTest.Fixture.field(
+                        f.plugin, "abilityEngine")).sweep();
+                }
+                verify(arrow, atLeastOnce()).remove();
+            }
+        }
+    }
+
+    @Test void unlearnRelearnAndTransferRetainRecoveryAndRemoveTheOwnedArrow() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withLongbow(data, a, 14);
+            f.players.put(a.core.id, a.player); f.activate(a); when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());
+            var arrow = arrow(a, new Location(a.world, 2, 65.6, 0));
+            doAnswer(call -> { f.dispatcher.accept(new ProjectileLaunchEvent(arrow)); return arrow; })
+                .when(a.player).launchProjectile(eq(Arrow.class), any(Vector.class));
+            drawAndRelease(f, a, 20); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            var deadline = storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("longbow");
+            assertNotNull(deadline);
+            a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
+            var unlearn = abilityButton(a, "[Unlearn]", "longbow");
+            PartyBookNativeTest.click(f, a, unlearn); PartyBookNativeTest.click(f, a, unlearn);
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var refunded = storage.find(a.core.record.id()).get().orElseThrow();
+            assertEquals(BigInteger.valueOf(40), refunded.unspentPoints());
+            assertFalse(refunded.learned().contains("longbow")); assertEquals(deadline, refunded.cooldowns().get("longbow"));
+            verify(arrow, atLeastOnce()).remove();
+            learnAndAssign(f, a); drawAndRelease(f, a, 20);
+            verify(a.player, times(1)).launchProjectile(eq(Arrow.class), any(Vector.class));
+            assertTrue(a.messages.stream().anyMatch(message -> message.contains("ready in")));
+            var sheet = a.core.inventory.getItemInOffHand().clone();
+            a.core.inventory.setItemInOffHand(null); f.changed(a); PartyBookNativeTest.drain(f); f.awaitCharacterAndReceipt(a);
+            var b = new FantasyStickLifecycleNativeTest.Actor(data); b.core.inventory.setItemInOffHand(sheet);
+            f.players.put(b.core.id, b.player); f.activate(b); drawAndRelease(f, b, 20);
+            verify(b.player, never()).launchProjectile(eq(Arrow.class), any(Vector.class));
+            assertTrue(b.messages.stream().anyMatch(message -> message.contains("ready in")));
+        }
+    }
+
+    @Test void failedRecoveryPersistenceLaunchesNoArrow() {
+        var storage = mock(CharacterStorage.class);
+        var sessions = mock(games.dmg.fantasystick.session.EquipmentSessions.class);
+        var parties = new games.dmg.fantasystick.party.PartyRoster(java.time.Clock.systemUTC(), ignored -> true);
+        var registry = new games.dmg.fantasystick.ability.AbilityRegistry();
+        var longbow = new games.dmg.fantasystick.ability.Longbow(
+            games.dmg.fantasystick.ability.Longbow.Settings.defaults()); registry.register(longbow.definition());
+        var base = new games.dmg.fantasystick.crafting.CharacterFactory().create(
+            games.dmg.fantasystick.progression.ProgressionRules.defaults());
+        var stats = new EnumMap<>(base.stats()); stats.put(Stat.DEX, BigInteger.valueOf(14));
+        var record = new CharacterRecord(base.id(), base.name(), base.revision(), stats, base.level(), base.experience(),
+            base.unspentPoints(), base.health(), java.util.Set.of("longbow"),
+            List.of("longbow", "", "", "", "", "", ""), base.cooldowns(), base.restrictedKills(), false, null, null);
+        var active = new games.dmg.fantasystick.session.EquipmentSessions.Active(java.util.UUID.randomUUID(),
+            java.util.UUID.randomUUID(), record.id());
+        var player = mock(org.bukkit.entity.Player.class);
+        when(sessions.current(active)).thenReturn(true); when(sessions.currentRecord(active)).thenReturn(java.util.Optional.of(record));
+        var failed = new java.util.concurrent.CompletableFuture<CharacterStorage.AbilityMutation>();
+        failed.completeExceptionally(new java.io.IOException("simulated Longbow recovery failure"));
+        when(storage.commitAbilityCooldown(eq(record.id()), eq(record.revision()), eq("longbow"), any())).thenReturn(failed);
+        var failures = new ArrayList<games.dmg.fantasystick.ability.AbilityEngine.Failure>();
+        var engine = new games.dmg.fantasystick.ability.AbilityEngine(registry, storage, sessions, parties,
+            java.time.Clock.systemUTC(), Runnable::run, (delay, action) -> () -> {}, ignored -> {}, failures::add);
+        engine.accept(new games.dmg.fantasystick.session.ControlInput(player, active, 2, "longbow",
+            games.dmg.fantasystick.session.ControlInput.Kind.ABILITY,
+            games.dmg.fantasystick.session.ControlInput.Gesture.DRAW_RELEASE, null, 20, 0, () -> true));
+        verify(player, never()).launchProjectile(eq(Arrow.class), any(Vector.class));
+        assertEquals(1, failures.size()); engine.close(); longbow.close(); parties.close();
+    }
+
+    @Test void acknowledgedConfigurationChangesOnlyFutureShotSnapshots() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withLongbow(data, a, 14);
+            f.players.put(a.core.id, a.player); f.activate(a); when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());
+            var oldArrow = arrow(a, new Location(a.world, 3, 65.6, 0));
+            doAnswer(call -> { f.dispatcher.accept(new ProjectileLaunchEvent(oldArrow)); return oldArrow; })
+                .when(a.player).launchProjectile(eq(Arrow.class), any(Vector.class));
+            drawAndRelease(f, a, 20); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "longbow-base-damage", "9"});
+            var response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response); response.run();
+
+            var oldTarget = targetRecordingDamage(f, a, oldArrow); f.dispatcher.accept(new ProjectileHitEvent(oldArrow, oldTarget.entity()));
+            assertEquals(7.0, oldTarget.amount()[0], 1.0e-9);
+            var b = new FantasyStickLifecycleNativeTest.Actor(data); withLongbow(data, b, 14);
+            f.players.put(b.core.id, b.player); f.activate(b); when(b.world.getUID()).thenReturn(java.util.UUID.randomUUID());
+            var newArrow = arrow(b, new Location(b.world, 3, 65.6, 0));
+            doAnswer(call -> { f.dispatcher.accept(new ProjectileLaunchEvent(newArrow)); return newArrow; })
+                .when(b.player).launchProjectile(eq(Arrow.class), any(Vector.class));
+            var newTarget = targetRecordingDamage(f, b, newArrow);
+            drawAndRelease(f, b, 20); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            f.dispatcher.accept(new ProjectileHitEvent(newArrow, newTarget.entity()));
+            assertEquals(11.0, newTarget.amount()[0], 1.0e-9);
+        }
+    }
+
+    @Test void failedAdminWriteKeepsLongbowDefinitionAndExternalFileUnchanged() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var outside = data.resolveSibling(data.getFileName() + "-longbow-outside");
+            java.nio.file.Files.writeString(outside, "untouched\n");
+            java.nio.file.Files.createSymbolicLink(data.resolve("config.yml"), outside);
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "longbow-base-damage", "9"});
+            var response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response); response.run();
+            assertTrue(sender.messages.getLast().contains("save failed"));
+            var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
+            assertEquals(new java.math.BigDecimal("5"), registry.find("longbow").orElseThrow()
+                .parameters().get("base-damage"));
+            assertEquals("untouched\n", java.nio.file.Files.readString(outside));
+            java.nio.file.Files.delete(data.resolve("config.yml")); java.nio.file.Files.delete(outside);
+        }
+    }
+
+    @Test void reenableDrainsAcceptedLongbowConfigurationBeforeGameplayRegistration() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var settings = FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "longbowSettings");
+            var worker = (java.util.concurrent.ExecutorService) FantasyStickLifecycleNativeTest.Fixture.field(settings, "worker");
+            var entered = new java.util.concurrent.CountDownLatch(1); var release = new java.util.concurrent.CountDownLatch(1);
+            worker.execute(() -> {
+                entered.countDown();
+                try { release.await(5, java.util.concurrent.TimeUnit.SECONDS); }
+                catch (InterruptedException failure) { Thread.currentThread().interrupt(); }
+            });
+            try {
+                assertTrue(entered.await(5, java.util.concurrent.TimeUnit.SECONDS));
+                var sender = new EquipmentAdminCommandNativeTest.Sender();
+                f.command.execute(sender.port, "fantasystick", new String[]{"config", "longbow-base-damage", "9"});
+                f.plugin.setEnabled(false); f.plugin.setEnabled(true);
+                assertNull(FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "sessions"));
+                release.countDown(); f.tick();
+                var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
+                    FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
+                assertEquals(new java.math.BigDecimal("9"), registry.find("longbow").orElseThrow()
+                    .parameters().get("base-damage"));
+            } finally { release.countDown(); }
+        }
+    }
+
+    @Test void configuredDefinitionFormulaValidationAndAdminRoutesCoverEverySetting() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),
+            "longbow-base-damage: 8\nlongbow-recovery-seconds: 2\nlongbow-minimum-draw-ticks: 4\n"
+                + "longbow-full-draw-ticks: 30\nlongbow-range-blocks: 70\nlongbow-lifetime-seconds: 11\n"
+                + "longbow-full-projectile-speed-blocks-per-tick: 4\n");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
+            var definition = registry.find("longbow").orElseThrow();
+            assertEquals(java.time.Duration.ofSeconds(2), definition.cooldown());
+            assertEquals(new java.math.BigDecimal("8"), definition.parameters().get("base-damage"));
+            assertEquals(new java.math.BigDecimal("4"), definition.parameters().get("minimum-draw-ticks"));
+            assertEquals(new java.math.BigDecimal("30"), definition.parameters().get("full-draw-ticks"));
+            assertEquals(0, new java.math.BigDecimal("70").compareTo(definition.parameters().get("range")));
+            assertEquals(0, new java.math.BigDecimal("11").compareTo(definition.parameters().get("lifetime")));
+            assertEquals(0, new java.math.BigDecimal("4").compareTo(definition.parameters().get("full-projectile-speed")));
+            assertEquals(java.math.BigDecimal.ONE, games.dmg.fantasystick.ability.Longbow.power(30, 30));
+            assertEquals(0, games.dmg.fantasystick.ability.Longbow.power(15, 30)
+                .compareTo(new java.math.BigDecimal("0.4166666666666666666666666666666667")));
+            assertEquals(BigInteger.valueOf(7), games.dmg.fantasystick.ability.Longbow.fullDamage(BigInteger.valueOf(14)));
+            assertEquals(BigInteger.TEN.pow(500).subtract(BigInteger.TEN).divide(BigInteger.TWO).add(BigInteger.valueOf(5)),
+                games.dmg.fantasystick.ability.Longbow.fullDamage(BigInteger.TEN.pow(500)));
+            var unavailable = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(unavailable.core.id, unavailable.player); f.activate(unavailable);
+            unavailable.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, unavailable);
+            assertTrue(PartyBookNativeTest.text(unavailable).replaceAll("\\s+", "").contains("Unavailable:requirements"));
+            assertThrows(AssertionError.class, () -> abilityButton(unavailable, "[Learn]", "longbow"));
+
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            assertEquals(java.util.List.of("config", "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());
+            assertEquals(java.util.List.of("longbow-base-damage"),
+                f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "longbow-b"}));
+            assertEquals(7, f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "longbow-"}).size());
+            assertEquals(java.util.List.of("5", "8"), f.command.tabComplete(sender.port, "fantasystick",
+                new String[]{"config", "longbow-base-damage", ""}));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "longbow-base-damage"});
+            assertTrue(sender.messages.getLast().contains("longbow-base-damage=8"));
+            sender.allowed = false;
+            assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "longbow"}).isEmpty());
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "longbow-base-damage", "9"});
+            assertTrue(sender.messages.getLast().contains("Permission denied"), sender.messages.toString()); sender.allowed = true;
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "longbow-base-damage", "9"});
+            var response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response); response.run();
+            assertEquals(new java.math.BigDecimal("9"), registry.find("longbow").orElseThrow()
+                .parameters().get("base-damage"));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "longbow-base-damage", "-1"});
+            assertTrue(sender.messages.getLast().contains("invalid"));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "longbow-base-damage", "9", "extra"});
+            assertTrue(sender.messages.getLast().contains("Usage"));
+            f.plugin.setEnabled(false); f.plugin.setEnabled(true);
+            var reloaded = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
+            assertEquals(new java.math.BigDecimal("9"), reloaded.find("longbow").orElseThrow()
+                .parameters().get("base-damage"));
+        }
+
+        for (String invalid : List.of("longbow-base-damage: -1\n", "longbow-recovery-seconds: 0.5\n",
+                "longbow-minimum-draw-ticks: 0\n", "longbow-full-draw-ticks: 2\n",
+                "longbow-range-blocks: 0\n", "longbow-lifetime-seconds: 0\n",
+                "longbow-full-projectile-speed-blocks-per-tick: 0\n")) {
+            var directory = data.resolve(Integer.toHexString(invalid.hashCode()));
+            java.nio.file.Files.createDirectories(directory); java.nio.file.Files.writeString(directory.resolve("config.yml"), invalid);
+            try (var f = new FantasyStickLifecycleNativeTest.Fixture(directory)) {
+                assertThrows(IllegalArgumentException.class, () -> f.plugin.setEnabled(true));
+                assertTrue(f.order.isEmpty()); assertTrue(f.recipes.isEmpty());
+            }
+        }
+    }
+
+    private record DamageTarget(LivingEntity entity, double[] amount) { }
+
+    private static DamageTarget targetRecordingDamage(FantasyStickLifecycleNativeTest.Fixture fixture,
+                                                       FantasyStickLifecycleNativeTest.Actor actor, Arrow arrow) {
+        var target = mock(LivingEntity.class); when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+        when(target.getLocation()).thenReturn(new Location(actor.world, 3, 65.6, 0));
+        var amount = new double[1];
+        doAnswer(call -> {
+            amount[0] = call.getArgument(0); var source = call.getArgument(1, DamageSource.class);
+            fixture.dispatcher.accept(new EntityDamageByEntityEvent(arrow, target,
+                EntityDamageEvent.DamageCause.PROJECTILE, source, amount[0])); return null;
+        }).when(target).damage(anyDouble(), any(DamageSource.class));
+        return new DamageTarget(target, amount);
+    }
+
+    private static void learnAndAssign(FantasyStickLifecycleNativeTest.Fixture fixture,
+                                       FantasyStickLifecycleNativeTest.Actor actor) throws Exception {
+        actor.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, actor);
+        PartyBookNativeTest.click(fixture, actor, abilityButton(actor, "[Learn]", "longbow"));
+        PartyBookNativeTest.drain(fixture); PartyBookNativeTest.drain(fixture);
+        PartyBookNativeTest.click(fixture, actor, abilityButton(actor, "[3]", "longbow"));
+        PartyBookNativeTest.drain(fixture); PartyBookNativeTest.drain(fixture);
+    }
+
+    private static void drawAndRelease(FantasyStickLifecycleNativeTest.Fixture fixture,
+                                       FantasyStickLifecycleNativeTest.Actor actor, int ticks) {
+        actor.core.inventory.getInventory().setSelectedSlot(2);
+        var eye = new Location(actor.world, 0, 65.6, 0); eye.setDirection(new Vector(1, 0, 0));
+        doReturn(eye).when(actor.player).getEyeLocation();
+        var bow = actor.core.inventory.getItem(2).clone();
+        fixture.dispatcher.accept(new PlayerInteractEvent(actor.player, org.bukkit.event.block.Action.RIGHT_CLICK_AIR,
+            bow, null, org.bukkit.block.BlockFace.SELF, EquipmentSlot.HAND));
+        fixture.dispatcher.accept(new io.papermc.paper.event.player.PlayerStopUsingItemEvent(actor.player, bow, ticks));
+    }
+
+    private static Arrow arrow(FantasyStickLifecycleNativeTest.Actor actor, Location location) {
+        var arrow = PartyCombatNativeTest.entity(Arrow.class);
+        when(arrow.getShooter()).thenReturn(actor.player); when(arrow.getLocation()).thenReturn(location);
+        when(arrow.getWorld()).thenReturn(actor.world); return arrow;
+    }
+
+    private static ClickEvent.Custom abilityButton(FantasyStickLifecycleNativeTest.Actor actor, String label, String ability) {
+        var book = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(actor.books.getLast())
+            .get(net.minecraft.core.component.DataComponents.WRITTEN_BOOK_CONTENT);
+        assertNotNull(book);
+        for (var page : book.pages()) {
+            var found = abilityButton(page.raw(), label, ability);
+            if (found != null) return found;
+        }
+        throw new AssertionError("Missing " + label + " action for " + ability);
+    }
+
+    private static ClickEvent.Custom abilityButton(net.minecraft.network.chat.Component component,
+                                                    String label, String ability) {
+        if (component.getString().equals(label)
+                && component.getStyle().getClickEvent() instanceof ClickEvent.Custom custom
+                && custom.payload().orElse(null) instanceof net.minecraft.nbt.StringTag payload
+                && payload.value().contains(":" + ability)) return custom;
+        for (var child : component.getSiblings()) {
+            var found = abilityButton(child, label, ability);
+            if (found != null) return found;
+        }
+        return null;
+    }
+
+    private static void withStats(Path data, FantasyStickLifecycleNativeTest.Actor actor,
+                                  int intelligence, int dexterity) throws Exception {
+        var repository = new games.dmg.fantasystick.persistence.YamlCharacterRepository(data);
+        var old = repository.load(actor.core.record.id()).orElseThrow();
+        var stats = new EnumMap<>(old.stats()); stats.put(Stat.INT, BigInteger.valueOf(intelligence));
+        stats.put(Stat.DEX, BigInteger.valueOf(dexterity));
+        repository.replace(new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), stats,
+            old.level(), old.experience(), BigInteger.valueOf(40), old.health(), old.learned(), old.loadout(),
+            old.cooldowns(), old.restrictedKills(), false, null, null), old.revision());
+    }
+
+    private static void withLongbow(Path data, FantasyStickLifecycleNativeTest.Actor actor, int dexterity) throws Exception {
+        withStats(data, actor, 0, dexterity);
+        var repository = new games.dmg.fantasystick.persistence.YamlCharacterRepository(data);
+        var old = repository.load(actor.core.record.id()).orElseThrow();
+        repository.replace(new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), old.stats(),
+            old.level(), old.experience(), old.unspentPoints().subtract(BigInteger.ONE), old.health(),
+            java.util.Set.of("longbow"), List.of("longbow", "", "", "", "", "", ""), old.cooldowns(),
+            old.restrictedKills(), false, null, null), old.revision());
+    }
+}

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

@@ -0,0 +1,308 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.progression.Stat;
+import java.math.BigInteger;
+import java.nio.file.Path;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+import net.minecraft.network.chat.ClickEvent;
+import org.bukkit.Location;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.util.Vector;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class QuickstepNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void bookAcquisitionEquippedUseAppliesAndStopsOwnedHorizontalVelocityAtFourBlocks() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withStats(data, a, 12, false);
+            f.players.put(a.core.id, a.player); f.activate(a);
+            a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
+            String text = PartyBookNativeTest.text(a).replaceAll("\\s+", "");
+            assertTrue(text.contains("Quickstep")); assertTrue(text.contains("DEX12"));
+            assertTrue(text.contains("Cost:1")); assertTrue(text.contains("4")); assertTrue(text.contains("5s"));
+            PartyBookNativeTest.click(f, a, abilityButton(a, "[Learn]", "quickstep"));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            PartyBookNativeTest.click(f, a, abilityButton(a, "[3]", "quickstep"));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            assertEquals(BigInteger.valueOf(39), storage.find(a.core.record.id()).get().orElseThrow().unspentPoints());
+
+            var velocity = prepareMovement(a, new Vector(0, 0.25, 0));
+            use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            assertEquals(new Vector(1, 0.25, 0), velocity.get());
+            verify(a.player, never()).setFallDistance(anyFloat());
+            assertNotNull(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("quickstep"));
+            var from = new Location(a.world, 0, 64, 0); var to = new Location(a.world, 4, 64, 0);
+            f.dispatcher.accept(new PlayerMoveEvent(a.player, from, to));
+            assertEquals(new Vector(0, 0.25, 0), velocity.get(), "Only remaining owned horizontal motion is removed");
+        }
+    }
+
+    @Test void airborneFlyingGlidingOrMountedUseRefusesBeforeCooldownAndMovement() throws Exception {
+        for (int route = 0; route < 4; route++) try (var f = new FantasyStickLifecycleNativeTest.Fixture(data.resolve(Integer.toString(route)))) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data.resolve(Integer.toString(route)));
+            withStats(data.resolve(Integer.toString(route)), a, 12, true);
+            f.players.put(a.core.id, a.player); f.activate(a);
+            var velocity = prepareMovement(a, new Vector(0.3, 0.4, 0.5));
+            doReturn(route != 0).when(a.player).isOnGround();
+            doReturn(route == 1).when(a.player).isFlying();
+            doReturn(route == 2).when(a.player).isGliding();
+            doReturn(route == 3).when(a.player).isInsideVehicle();
+            use(f, a);
+            assertEquals(new Vector(0.3, 0.4, 0.5), velocity.get());
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            assertFalse(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().containsKey("quickstep"));
+            assertTrue(a.messages.stream().anyMatch(message -> message.contains("not eligible")));
+        }
+    }
+
+    @Test void velocityCancellationObstacleAndUnrelatedReplacementAreAuthoritative() throws Exception {
+        for (int route = 0; route < 3; route++) try (var f = new FantasyStickLifecycleNativeTest.Fixture(data.resolve("motion-" + route))) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data.resolve("motion-" + route));
+            withStats(data.resolve("motion-" + route), a, 12, true);
+            f.players.put(a.core.id, a.player); f.activate(a);
+            var velocity = prepareMovement(a, new Vector(0, 0.3, 0));
+            if (route == 0) {
+                class Veto implements org.bukkit.event.Listener {
+                    @org.bukkit.event.EventHandler public void velocity(org.bukkit.event.player.PlayerVelocityEvent event) {
+                        if (event.getPlayer() == a.player) event.setCancelled(true);
+                    }
+                }
+                f.dispatcher.register(new Veto(), f.plugin);
+            }
+            use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            assertNotNull(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("quickstep"));
+            if (route == 0) {
+                assertEquals(new Vector(0, 0.3, 0), velocity.get(), "Cancelled velocity applies no movement");
+            } else if (route == 1) {
+                velocity.set(new Vector(0, 0.3, 0));
+                f.dispatcher.accept(new PlayerMoveEvent(a.player, new Location(a.world, 0, 64, 0),
+                    new Location(a.world, 0.2, 64, 0)));
+                assertEquals(new Vector(0, 0.3, 0), velocity.get(), "Native collision stops movement early");
+            } else {
+                velocity.set(new Vector(0, 0.6, 2));
+                f.dispatcher.accept(new PlayerMoveEvent(a.player, new Location(a.world, 0, 64, 0),
+                    new Location(a.world, 0.2, 64, 0)));
+                assertEquals(new Vector(0, 0.6, 2), velocity.get(), "Replacement movement relinquishes ownership");
+            }
+            verify(a.player, never()).setFallDistance(anyFloat());
+        }
+    }
+
+    @Test void unlearnRelearnAndTransferRetainCooldownAndClearOnlyOwnedHorizontalMotion() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withStats(data, a, 12, true);
+            f.players.put(a.core.id, a.player); f.activate(a); var velocity = prepareMovement(a, new Vector(0, 0.4, 0));
+            use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            var deadline = storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("quickstep"); assertNotNull(deadline);
+            a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
+            var unlearn = abilityButton(a, "[Unlearn]", "quickstep");
+            PartyBookNativeTest.click(f, a, unlearn); PartyBookNativeTest.click(f, a, unlearn);
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var refunded = storage.find(a.core.record.id()).get().orElseThrow();
+            assertEquals(BigInteger.valueOf(40), refunded.unspentPoints()); assertEquals(deadline, refunded.cooldowns().get("quickstep"));
+            assertEquals(new Vector(0, 0.4, 0), velocity.get());
+            learnAndAssign(f, a); use(f, a);
+            assertTrue(a.messages.stream().anyMatch(message -> message.contains("ready in")));
+            assertEquals(new Vector(0, 0.4, 0), velocity.get());
+            var sheet = a.core.inventory.getItemInOffHand().clone();
+            a.core.inventory.setItemInOffHand(null); f.changed(a); PartyBookNativeTest.drain(f); f.awaitCharacterAndReceipt(a);
+            var b = new FantasyStickLifecycleNativeTest.Actor(data); b.core.inventory.setItemInOffHand(sheet);
+            f.players.put(b.core.id, b.player); f.activate(b); prepareMovement(b, new Vector(0.2, 0.3, 0.4)); use(f, b);
+            assertTrue(b.messages.stream().anyMatch(message -> message.contains("ready in")));
+        }
+    }
+
+    @Test void failedCooldownPersistenceAppliesNoVelocity() {
+        var storage = mock(CharacterStorage.class);
+        var sessions = mock(games.dmg.fantasystick.session.EquipmentSessions.class);
+        var parties = new games.dmg.fantasystick.party.PartyRoster(java.time.Clock.systemUTC(), ignored -> true);
+        var registry = new games.dmg.fantasystick.ability.AbilityRegistry();
+        var quickstep = new games.dmg.fantasystick.ability.Quickstep(
+            games.dmg.fantasystick.ability.Quickstep.Settings.defaults(), ignored -> {});
+        registry.register(quickstep.definition());
+        var base = new games.dmg.fantasystick.crafting.CharacterFactory().create(
+            games.dmg.fantasystick.progression.ProgressionRules.defaults());
+        var stats = new EnumMap<>(base.stats()); stats.put(Stat.DEX, BigInteger.valueOf(12));
+        var record = new CharacterRecord(base.id(), base.name(), base.revision(), stats, base.level(), base.experience(),
+            base.unspentPoints(), base.health(), java.util.Set.of("quickstep"),
+            List.of("quickstep", "", "", "", "", "", ""), base.cooldowns(), base.restrictedKills(), false, null, null);
+        var active = new games.dmg.fantasystick.session.EquipmentSessions.Active(java.util.UUID.randomUUID(),
+            java.util.UUID.randomUUID(), record.id());
+        var player = mock(org.bukkit.entity.Player.class);
+        when(sessions.current(active)).thenReturn(true); when(sessions.currentRecord(active)).thenReturn(java.util.Optional.of(record));
+        doReturn(true).when(player).isOnGround(); doReturn(false).when(player).isFlying();
+        doReturn(false).when(player).isGliding(); doReturn(false).when(player).isInsideVehicle();
+        var eye = new Location(mock(org.bukkit.World.class), 0, 0, 0); eye.setDirection(new Vector(1, 0, 0));
+        doReturn(eye).when(player).getEyeLocation();
+        var failed = new java.util.concurrent.CompletableFuture<CharacterStorage.AbilityMutation>();
+        failed.completeExceptionally(new java.io.IOException("simulated Quickstep cooldown failure"));
+        when(storage.commitAbilityCooldown(eq(record.id()), eq(record.revision()), eq("quickstep"), any())).thenReturn(failed);
+        var failures = new java.util.ArrayList<games.dmg.fantasystick.ability.AbilityEngine.Failure>();
+        var engine = new games.dmg.fantasystick.ability.AbilityEngine(registry, storage, sessions, parties,
+            java.time.Clock.systemUTC(), Runnable::run, (delay, action) -> () -> {}, ignored -> {}, failures::add);
+        engine.accept(new games.dmg.fantasystick.session.ControlInput(player, active, 2, "quickstep",
+            games.dmg.fantasystick.session.ControlInput.Kind.ABILITY,
+            games.dmg.fantasystick.session.ControlInput.Gesture.USE, null, 0, 0, () -> true));
+        verify(player, never()).setVelocity(any(Vector.class)); assertEquals(1, failures.size());
+        engine.close(); quickstep.close(); parties.close();
+    }
+
+    @Test void acknowledgedUpdatesAffectFutureDashesWhileActiveDashKeepsCapturedBounds() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withStats(data, a, 12, true);
+            f.players.put(a.core.id, a.player); f.activate(a); var oldVelocity = prepareMovement(a, new Vector(0, 0.2, 0));
+            use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "quickstep-distance-blocks", "7"});
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "quickstep-speed-blocks-per-tick", "2"});
+            for (int i = 0; i < 2; i++) {
+                var response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response); response.run();
+            }
+            f.dispatcher.accept(new PlayerMoveEvent(a.player, new Location(a.world, 0, 64, 0),
+                new Location(a.world, 4, 64, 0)));
+            assertEquals(new Vector(0, 0.2, 0), oldVelocity.get(), "Active dash retains its four-block snapshot");
+            var b = new FantasyStickLifecycleNativeTest.Actor(data); withStats(data, b, 12, true);
+            f.players.put(b.core.id, b.player); f.activate(b); var newVelocity = prepareMovement(b, new Vector(0, 0.3, 0));
+            use(f, b); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            assertEquals(new Vector(2, 0.3, 0), newVelocity.get(), "Future dash uses acknowledged speed");
+        }
+    }
+
+    @Test void configuredDefinitionAdminRoutesAndStartupValidationCoverEveryQuickstepSetting() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),
+            "quickstep-cooldown-seconds: 2\nquickstep-distance-blocks: 6\nquickstep-speed-blocks-per-tick: 1.5\n");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
+            var definition = registry.find("quickstep").orElseThrow();
+            assertEquals(java.time.Duration.ofSeconds(2), definition.cooldown());
+            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", "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());
+            sender.allowed = false;
+            assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "quickstep"}).isEmpty());
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "quickstep-distance-blocks", "7"});
+            assertTrue(sender.messages.getLast().contains("Permission denied")); sender.allowed = true;
+            assertEquals(List.of("quickstep-cooldown-seconds", "quickstep-distance-blocks", "quickstep-speed-blocks-per-tick"),
+                f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "quickstep-"}));
+            assertEquals(List.of("4", "6"), f.command.tabComplete(sender.port, "fantasystick",
+                new String[]{"config", "quickstep-distance-blocks", ""}));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "quickstep-distance-blocks"});
+            assertTrue(sender.messages.getLast().contains("=6"));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "quickstep-distance-blocks", "7"});
+            var response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response); response.run();
+            assertEquals(0, new java.math.BigDecimal("7").compareTo(registry.find("quickstep").orElseThrow()
+                .parameters().get("distance")));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "quickstep-distance-blocks", "0"});
+            assertTrue(sender.messages.getLast().contains("invalid"));
+            f.command.execute(sender.port, "fantasystick",
+                new String[]{"config", "quickstep-distance-blocks", "7", "extra"});
+            assertTrue(sender.messages.getLast().contains("Usage"));
+            f.plugin.setEnabled(false); f.plugin.setEnabled(true);
+            var reloaded = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
+            assertEquals(0, new java.math.BigDecimal("7").compareTo(reloaded.find("quickstep").orElseThrow()
+                .parameters().get("distance")));
+        }
+        for (String invalid : List.of("quickstep-cooldown-seconds: -1\n", "quickstep-distance-blocks: 0\n",
+                "quickstep-speed-blocks-per-tick: 0\n")) {
+            var directory = data.resolve(Integer.toHexString(invalid.hashCode()));
+            java.nio.file.Files.createDirectories(directory); java.nio.file.Files.writeString(directory.resolve("config.yml"), invalid);
+            try (var f = new FantasyStickLifecycleNativeTest.Fixture(directory)) {
+                assertThrows(IllegalArgumentException.class, () -> f.plugin.setEnabled(true));
+                assertTrue(f.order.isEmpty()); assertTrue(f.recipes.isEmpty());
+            }
+        }
+    }
+
+    private static void learnAndAssign(FantasyStickLifecycleNativeTest.Fixture fixture,
+                                       FantasyStickLifecycleNativeTest.Actor actor) throws Exception {
+        actor.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, actor);
+        PartyBookNativeTest.click(fixture, actor, abilityButton(actor, "[Learn]", "quickstep"));
+        PartyBookNativeTest.drain(fixture); PartyBookNativeTest.drain(fixture);
+        PartyBookNativeTest.click(fixture, actor, abilityButton(actor, "[3]", "quickstep"));
+        PartyBookNativeTest.drain(fixture); PartyBookNativeTest.drain(fixture);
+    }
+
+    private static AtomicReference<Vector> prepareMovement(FantasyStickLifecycleNativeTest.Actor actor, Vector initial) {
+        var velocity = new AtomicReference<>(initial.clone());
+        doReturn(true).when(actor.player).isOnGround(); doReturn(false).when(actor.player).isFlying();
+        doReturn(false).when(actor.player).isGliding(); doReturn(false).when(actor.player).isInsideVehicle();
+        doAnswer(ignored -> velocity.get().clone()).when(actor.player).getVelocity();
+        doAnswer(call -> { velocity.set(call.getArgument(0, Vector.class).clone()); return null; }).when(actor.player).setVelocity(any(Vector.class));
+        var eye = new Location(actor.world, 0, 65.6, 0); eye.setDirection(new Vector(1, 0, 0));
+        doReturn(eye).when(actor.player).getEyeLocation();
+        return velocity;
+    }
+
+    private static void use(FantasyStickLifecycleNativeTest.Fixture fixture,
+                            FantasyStickLifecycleNativeTest.Actor actor) {
+        actor.core.inventory.getInventory().setSelectedSlot(2);
+        fixture.dispatcher.accept(new PlayerInteractEvent(actor.player, org.bukkit.event.block.Action.RIGHT_CLICK_AIR,
+            actor.core.inventory.getItem(2), null, org.bukkit.block.BlockFace.SELF, EquipmentSlot.HAND));
+    }
+
+    private static ClickEvent.Custom abilityButton(FantasyStickLifecycleNativeTest.Actor actor, String label, String ability) {
+        var book = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(actor.books.getLast())
+            .get(net.minecraft.core.component.DataComponents.WRITTEN_BOOK_CONTENT);
+        assertNotNull(book);
+        for (var page : book.pages()) {
+            var found = abilityButton(page.raw(), label, ability);
+            if (found != null) return found;
+        }
+        throw new AssertionError("Missing " + label + " action for " + ability);
+    }
+
+    private static ClickEvent.Custom abilityButton(net.minecraft.network.chat.Component component,
+                                                    String label, String ability) {
+        if (component.getString().equals(label)
+                && component.getStyle().getClickEvent() instanceof ClickEvent.Custom custom
+                && custom.payload().orElse(null) instanceof net.minecraft.nbt.StringTag payload
+                && payload.value().contains(":" + ability)) return custom;
+        for (var child : component.getSiblings()) {
+            var found = abilityButton(child, label, ability);
+            if (found != null) return found;
+        }
+        return null;
+    }
+
+    private static void withStats(Path data, FantasyStickLifecycleNativeTest.Actor actor,
+                                  int dexterity, boolean learned) throws Exception {
+        java.nio.file.Files.createDirectories(data);
+        var repository = new games.dmg.fantasystick.persistence.YamlCharacterRepository(data);
+        var old = repository.load(actor.core.record.id()).orElseThrow();
+        var stats = new EnumMap<>(old.stats()); stats.put(Stat.DEX, BigInteger.valueOf(dexterity));
+        repository.replace(new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), stats,
+            old.level(), old.experience(), BigInteger.valueOf(learned ? 39 : 40), old.health(),
+            learned ? java.util.Set.of("quickstep") : old.learned(),
+            learned ? List.of("quickstep", "", "", "", "", "", "") : old.loadout(),
+            old.cooldowns(), old.restrictedKills(), false, null, null), old.revision());
+    }
+}

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

@@ -50,6 +50,16 @@ class DistributionTest {
                     "frost-shard-slowness-amplifier: 0", "frost-shard-slowness-duration-seconds: 2")) {
                 assertTrue(defaults.contains(setting), "Missing packaged Frost Shard default: " + setting);
             }
+            for (String setting : java.util.List.of("longbow-base-damage: 5", "longbow-recovery-seconds: 1",
+                    "longbow-minimum-draw-ticks: 3", "longbow-full-draw-ticks: 20",
+                    "longbow-range-blocks: 64", "longbow-lifetime-seconds: 10",
+                    "longbow-full-projectile-speed-blocks-per-tick: 3")) {
+                assertTrue(defaults.contains(setting), "Missing packaged Longbow default: " + setting);
+            }
+            for (String setting : java.util.List.of("quickstep-cooldown-seconds: 5",
+                    "quickstep-distance-blocks: 4", "quickstep-speed-blocks-per-tick: 1")) {
+                assertTrue(defaults.contains(setting), "Missing packaged Quickstep default: " + setting);
+            }
             assertTrue(JavaPlugin.class.isAssignableFrom(FantasyStickPlugin.class));
             var entrypoint = jar.getJarEntry(metadata.getMain().replace('.', '/') + ".class");
             assertNotNull(entrypoint);

src/test/java/games/dmg/fantasystick/persistence/LongbowSettingsTest.java

@@ -0,0 +1,101 @@
+package games.dmg.fantasystick.persistence;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class LongbowSettingsTest {
+    @TempDir Path data;
+
+    @Test void serializesConcurrentAcceptedKeysWithoutLosingUnrelatedConfiguration() throws Exception {
+        Files.writeString(data.resolve("config.yml"), "adventure-mode: true\nunrelated: retained\n");
+        try (var settings = new LongbowSettings(data, defaults())) {
+            var damage = settings.set(LongbowSettings.BASE_DAMAGE, "9").toCompletableFuture();
+            var range = settings.set(LongbowSettings.RANGE, "40.5").toCompletableFuture();
+            var savedDamage = damage.get(5, TimeUnit.SECONDS);
+            var savedRange = range.get(5, TimeUnit.SECONDS);
+            assertEquals("9", savedDamage.value()); assertEquals("40.5", savedRange.value());
+            assertEquals(new java.math.BigInteger("5"), settings.settings().baseDamage(),
+                "Durability acknowledgment alone must not publish runtime settings");
+            settings.publish(savedRange); settings.publish(savedDamage); // stale callback cannot roll back the newer snapshot.
+            assertEquals(new java.math.BigInteger("9"), settings.settings().baseDamage());
+            assertEquals(40.5, settings.settings().range());
+            var saved = (Map<?, ?>) new org.yaml.snakeyaml.Yaml().load(Files.readString(data.resolve("config.yml")));
+            assertEquals(Boolean.TRUE, saved.get("adventure-mode"));
+            assertEquals("retained", saved.get("unrelated"));
+            assertEquals("9", String.valueOf(saved.get(LongbowSettings.BASE_DAMAGE)));
+            assertEquals("40.5", String.valueOf(saved.get(LongbowSettings.RANGE)));
+        }
+    }
+
+    @Test void rejectsMalformedAndOutOfRangeValuesBeforeQueueingOrChangingEffectiveState() {
+        try (var settings = new LongbowSettings(data, defaults())) {
+            for (var entry : Map.of(
+                    LongbowSettings.BASE_DAMAGE, "-1",
+                    LongbowSettings.RECOVERY, "0.999",
+                    LongbowSettings.MINIMUM_DRAW, "0",
+                    LongbowSettings.FULL_DRAW, "2",
+                    LongbowSettings.RANGE, "0",
+                    LongbowSettings.LIFETIME, "0",
+                    LongbowSettings.FULL_SPEED, "Infinity").entrySet()) {
+                assertThrows(IllegalArgumentException.class, () -> settings.set(entry.getKey(), entry.getValue()));
+            }
+            assertThrows(IllegalArgumentException.class, () -> settings.set(LongbowSettings.BASE_DAMAGE, "1.5"));
+            assertThrows(IllegalArgumentException.class, () -> settings.set(LongbowSettings.BASE_DAMAGE, "1" + "0".repeat(309)));
+            assertThrows(IllegalArgumentException.class, () -> settings.set(LongbowSettings.RECOVERY, "1.0000000001"));
+            assertEquals("5", settings.value(LongbowSettings.BASE_DAMAGE));
+            assertFalse(Files.exists(data.resolve("config.yml")));
+        }
+    }
+
+    @Test void failedAtomicReplacementRetainsEffectiveAndFileStateAndAllowsOneExplicitRetry() throws Exception {
+        Files.writeString(data.resolve("config.yml"), "longbow-base-damage: 5\n");
+        var fail = new java.util.concurrent.atomic.AtomicBoolean(true);
+        try (var settings = new LongbowSettings(data, defaults(), (from, to) -> {
+            if (fail.getAndSet(false)) throw new java.io.IOException("simulated replacement failure");
+            Files.move(from, to, StandardCopyOption.REPLACE_EXISTING);
+        })) {
+            assertThrows(java.util.concurrent.ExecutionException.class, () ->
+                settings.set(LongbowSettings.BASE_DAMAGE, "9").toCompletableFuture().get(5, TimeUnit.SECONDS));
+            assertEquals("5", settings.value(LongbowSettings.BASE_DAMAGE));
+            assertTrue(Files.readString(data.resolve("config.yml")).contains("5"));
+            var retry = settings.set(LongbowSettings.BASE_DAMAGE, "9").toCompletableFuture()
+                .get(5, TimeUnit.SECONDS);
+            assertEquals("9", retry.value());
+            assertEquals("5", settings.value(LongbowSettings.BASE_DAMAGE));
+            settings.publish(retry);
+            assertEquals("9", settings.value(LongbowSettings.BASE_DAMAGE));
+        }
+    }
+
+    @Test void rejectsUnsafeConfigurationAndLockFilesAndPostCloseWrites() throws Exception {
+        if (!System.getProperty("os.name", "").toLowerCase().contains("win")) {
+            var external = data.resolveSibling(data.getFileName() + "-outside");
+            Files.writeString(external, "safe\n");
+            Files.createSymbolicLink(data.resolve("config.yml"), external);
+            try (var settings = new LongbowSettings(data, defaults())) {
+                assertThrows(java.util.concurrent.ExecutionException.class, () ->
+                    settings.set(LongbowSettings.BASE_DAMAGE, "9").toCompletableFuture().get(5, TimeUnit.SECONDS));
+                assertEquals("safe\n", Files.readString(external));
+            }
+            Files.delete(data.resolve("config.yml")); Files.deleteIfExists(external);
+        }
+        var settings = new LongbowSettings(data, defaults()); settings.close();
+        assertThrows(java.util.concurrent.ExecutionException.class, () ->
+            settings.set(LongbowSettings.BASE_DAMAGE, "9").toCompletableFuture().get(5, TimeUnit.SECONDS));
+        settings.drained().toCompletableFuture().get(5, TimeUnit.SECONDS);
+    }
+
+    private static Map<String, String> defaults() {
+        var result = new LinkedHashMap<String, String>();
+        for (String key : LongbowSettings.keys()) result.put(key, LongbowSettings.defaultValue(key));
+        return result;
+    }
+}

src/test/java/games/dmg/fantasystick/persistence/QuickstepSettingsTest.java

@@ -0,0 +1,82 @@
+package games.dmg.fantasystick.persistence;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class QuickstepSettingsTest {
+    @TempDir Path data;
+
+    @Test void serializesConcurrentKeysPreservesUnrelatedAndPublishesOnlyAcknowledgedSnapshots() throws Exception {
+        Files.writeString(data.resolve("config.yml"), "adventure-mode: true\nunrelated: retained\n");
+        try (var settings = new QuickstepSettings(data, defaults())) {
+            var distance = settings.set(QuickstepSettings.DISTANCE, "6").toCompletableFuture();
+            var speed = settings.set(QuickstepSettings.SPEED, "1.5").toCompletableFuture();
+            var savedDistance = distance.get(5, TimeUnit.SECONDS); var savedSpeed = speed.get(5, TimeUnit.SECONDS);
+            assertEquals(4, settings.settings().distance(), 0);
+            settings.publish(savedSpeed); settings.publish(savedDistance);
+            assertEquals(6, settings.settings().distance(), 0); assertEquals(1.5, settings.settings().speedPerTick(), 0);
+            var saved = (Map<?, ?>) new org.yaml.snakeyaml.Yaml().load(Files.readString(data.resolve("config.yml")));
+            assertEquals(Boolean.TRUE, saved.get("adventure-mode")); assertEquals("retained", saved.get("unrelated"));
+            assertEquals("6", String.valueOf(saved.get(QuickstepSettings.DISTANCE)));
+            assertEquals("1.5", String.valueOf(saved.get(QuickstepSettings.SPEED)));
+        }
+    }
+
+    @Test void rejectsMalformedOrOutOfRangeValuesBeforeQueueing() {
+        try (var settings = new QuickstepSettings(data, defaults())) {
+            for (var entry : Map.of(QuickstepSettings.COOLDOWN, "-1", QuickstepSettings.DISTANCE, "0",
+                    QuickstepSettings.SPEED, "Infinity").entrySet()) {
+                assertThrows(IllegalArgumentException.class, () -> settings.set(entry.getKey(), entry.getValue()));
+            }
+            assertThrows(IllegalArgumentException.class, () -> settings.set(QuickstepSettings.COOLDOWN, "0.0000000001"));
+            assertEquals("4", settings.value(QuickstepSettings.DISTANCE));
+            assertFalse(Files.exists(data.resolve("config.yml")));
+        }
+    }
+
+    @Test void failedReplacementAndUnsafeFilesRetainEffectiveStateAndAllowRetry() throws Exception {
+        Files.writeString(data.resolve("config.yml"), "quickstep-distance-blocks: 4\n");
+        var fail = new java.util.concurrent.atomic.AtomicBoolean(true);
+        try (var settings = new QuickstepSettings(data, defaults(), (from, to) -> {
+            if (fail.getAndSet(false)) throw new java.io.IOException("simulated failure");
+            Files.move(from, to, StandardCopyOption.REPLACE_EXISTING);
+        })) {
+            assertThrows(java.util.concurrent.ExecutionException.class, () ->
+                settings.set(QuickstepSettings.DISTANCE, "6").toCompletableFuture().get(5, TimeUnit.SECONDS));
+            assertEquals("4", settings.value(QuickstepSettings.DISTANCE));
+            var retry = settings.set(QuickstepSettings.DISTANCE, "6").toCompletableFuture().get(5, TimeUnit.SECONDS);
+            assertEquals("4", settings.value(QuickstepSettings.DISTANCE)); settings.publish(retry);
+            assertEquals("6", settings.value(QuickstepSettings.DISTANCE));
+        }
+        if (!System.getProperty("os.name", "").toLowerCase().contains("win")) {
+            var external = data.resolveSibling(data.getFileName() + "-outside"); Files.writeString(external, "safe\n");
+            Files.delete(data.resolve("config.yml")); Files.createSymbolicLink(data.resolve("config.yml"), external);
+            try (var settings = new QuickstepSettings(data, defaults())) {
+                assertThrows(java.util.concurrent.ExecutionException.class, () ->
+                    settings.set(QuickstepSettings.DISTANCE, "7").toCompletableFuture().get(5, TimeUnit.SECONDS));
+                assertEquals("safe\n", Files.readString(external));
+            }
+        }
+    }
+
+    @Test void closeRejectsNewWritesAndCompletesDrain() throws Exception {
+        var settings = new QuickstepSettings(data, defaults()); settings.close();
+        assertThrows(java.util.concurrent.ExecutionException.class, () ->
+            settings.set(QuickstepSettings.DISTANCE, "6").toCompletableFuture().get(5, TimeUnit.SECONDS));
+        settings.drained().toCompletableFuture().get(5, TimeUnit.SECONDS);
+    }
+
+    private static Map<String, String> defaults() {
+        var result = new LinkedHashMap<String, String>();
+        for (String key : QuickstepSettings.keys()) result.put(key, QuickstepSettings.defaultValue(key));
+        return result;
+    }
+}