feat(heights): discover stature potion recipes

feat(heights): adopt Purpur distribution naming
BREAKING CHANGE: New release assets use purpur-heights-<version>.jar. Runtime SpigotHeights identity, saved player data, permissions and potion keys remain unchanged. Replace the old JAR instead of loading both distributions.
2026-09-20 14:30:46 -04:00 · 2026-09-12 13:13:44 -04:00 · 2026-09-12 08:35:29 -04:00
28 changed files with 1887 additions and 238 deletions
@@ -35,6 +35,6 @@ jobs:
      - name: Upload development artifact
        uses: actions/upload-artifact@v3
        with:
-          name: spigot-heights-${{ github.sha }}
+          name: purpur-heights-${{ github.sha }}
          path: build/libs/*.jar
          if-no-files-found: error
@@ -86,8 +86,8 @@ jobs:
        if: steps.release.outputs.created == 'true'
        uses: actions/upload-artifact@v3
        with:
-          name: spigot-heights-${{ steps.release.outputs.version }}
-          path: build/libs/spigot-heights-${{ steps.release.outputs.version }}.jar
+          name: purpur-heights-${{ steps.release.outputs.version }}
+          path: build/libs/purpur-heights-${{ steps.release.outputs.version }}.jar
          if-no-files-found: error

      - name: Create Gitea release and upload plugin
@@ -101,7 +101,7 @@ jobs:
          PREVIOUS_TAG: ${{ steps.previous_tag.outputs.value }}
        run: |
          api_url="${GITEA_SERVER_URL}/api/v1"
-          jar="build/libs/spigot-heights-${VERSION}.jar"
+          jar="build/libs/purpur-heights-${VERSION}.jar"
          export RELEASE_BODY
          if [ -n "$PREVIOUS_TAG" ]; then
            RELEASE_BODY=$(git log --pretty='format:- %s (%h)' "${PREVIOUS_TAG}..HEAD")
@@ -138,4 +138,4 @@ jobs:
            -H "Authorization: token ${GITEA_TOKEN}" \
            -H "Content-Type: application/octet-stream" \
            --data-binary "@${jar}" \
-            "${api_url}/repos/${REPOSITORY}/releases/${release_id}/assets?name=spigot-heights-${VERSION}.jar"
+            "${api_url}/repos/${REPOSITORY}/releases/${release_id}/assets?name=purpur-heights-${VERSION}.jar"
@@ -1,9 +1,9 @@
-# spigot-heights agent entrypoint
+# purpur-heights agent entrypoint

 The canonical stories, engineering guidance, and **all process documents** are in the private [SoMC OKF wiki](https://git.garvis.dev/dmg/somc-okf/src/branch/main/index.md).

-Before work, read the sibling `../somc-okf/index.md`, `../somc-okf/processes/index.md`, `../somc-okf/projects/spigot-heights/index.md`, `engineering.md` in that project section, and relevant `../somc-okf/user-stories/spigot-heights/` stories. Also follow the parent workspace `AGENTS.md` when present.
+Before work, read the sibling `../somc-okf/index.md`, `../somc-okf/processes/index.md`, `../somc-okf/projects/purpur-heights/index.md`, `engineering.md` in that project section, and relevant `../somc-okf/user-stories/purpur-heights/` stories. Also follow the parent workspace `AGENTS.md` when present.

-For standalone checkouts, start at the [project page](https://git.garvis.dev/dmg/somc-okf/src/branch/main/projects/spigot-heights/index.md) and [shared process](https://git.garvis.dev/dmg/somc-okf/src/branch/main/processes/development.md). Obtain wiki access before feature work; do not recreate a local knowledge bundle. Source builds do not require private wiki access.
+For standalone checkouts, start at the [project page](https://git.garvis.dev/dmg/somc-okf/src/branch/main/projects/purpur-heights/index.md) and [shared process](https://git.garvis.dev/dmg/somc-okf/src/branch/main/processes/development.md). Obtain wiki access before feature work; do not recreate a local knowledge bundle. Source builds do not require private wiki access.

 Development follows [Development cycle](https://git.garvis.dev/dmg/somc-okf/src/branch/main/runbooks/development-cycle.md): approved stories, failing tests, passing implementation, verification, then source/wiki commit and push. GitOps updates are committed locally **without pushing**; only [Do release](https://git.garvis.dev/dmg/somc-okf/src/branch/main/runbooks/do-release.md) authorizes a reviewed GitOps push.
@@ -1,8 +1,10 @@
-# Spigot Heights
+# Purpur Heights

 A Purpur 26.2 plugin adding craftable player-scaling potions and dispenser launch tubes for tiny players.

-Approved behavior is specified in the [SoMC OKF wiki](https://git.garvis.dev/dmg/somc-okf/src/branch/main/projects/spigot-heights/index.md).
+Approved behavior is specified in the [SoMC OKF wiki](https://git.garvis.dev/dmg/somc-okf/src/branch/main/projects/purpur-heights/index.md).
+
+New releases use the `purpur-heights` repository and `purpur-heights-<version>.jar` distribution name. Runtime `SpigotHeights`, its existing data folder, Java entrypoint/packages, permissions and stature-potion/recipe keys remain unchanged. Replace the old JAR instead of installing both distributions. Historical tags and `spigot-heights-*` assets are retained; the previous v1.5.0 download was checked for identical bytes after the rename.

 ## Requirements

@@ -59,27 +61,43 @@ Heights corrects Purpur 2618's no-op conversion of custom potions without a vani

 **Verification:** `nativeBrewingTest` executes real Purpur 2618 brewing cycles with native inventories, recipes, metadata and Paper event dispatch. It covers all four splash/lingering conversions, ingredient safety and cancellation, mixed/ordinary potions, and output compatibility with the stature adapters. World and entity boundaries are test doubles; these checks do not claim native projectile/cloud spawning, client appearance, or live logout/restart gameplay. Those remain supplementary live checks.

-## Consensual carrying (US-010; live acceptance pending)
+## Ride larger players (US-010)

-Sneak-right-click another player with your main hand to request a ride or pickup. The larger player is always the carrier, regardless of who asks. The other player has **30 seconds** to explicitly accept:
+Right-click a larger player with your **main hand** to mount immediately. Sneaking and consent are
+not required. Only the smaller rider may initiate: larger players cannot force pickup of smaller
+players. Either participant can end the ride, without administrator permission or rider approval:

 ```text
-/heights carry accept
-/heights carry decline
 /heights carry stop
 ```

-These commands require **no administrator permission**; settings and player-height commands still require `spigotheights.admin`. Console cannot carry players. One outstanding request per participant prevents replacement/ambiguous consent. Either participant can withdraw a pending request with `stop`; `decline` rejects an incoming request. Requests and carry tracking are not persisted.
+There are no consent requests, expiry timers, or accept/decline commands. Settings and player-height
+commands still require `spigotheights.admin`; console cannot carry players. Ride tracking is not
+persisted. There is no remount cooldown or opt-out: a smaller player can mount again after ejection.

-Both players must be available and within **4 blocks**, in the same world, when requesting and accepting. Their **effective** scale difference must be at least **three current adjustment steps** (normally `0.3`), including other plugins' attribute modifiers. Neither may already have a vehicle or passengers. Heights permits only one rider per carrier, and blocks additional/nested mounts involving an active pair.
+Both players must be available and within **4 blocks**, in the same world. Their **effective** scale
+difference, including attribute modifiers, must meet `carry.minimum-scale-gap` (default **0.1**,
+independent of potion adjustment sizes). Zero still requires a strictly larger carrier. Neither
+may already have a vehicle or passengers. Heights permits only one rider per carrier and blocks
+additional/nested mounts involving an active pair. Ineligible player clicks remain uncancelled for
+other plugins; only eligible carry attempts and their same-tick duplicates are consumed.

-Either player can stop with **normal Minecraft dismounting**. Heights calls the rider's native `leaveVehicle()` and allows ordinary sneak-dismounts, leaving placement, falling, damage, and environmental hazards to Minecraft. There is no safe-ground requirement or search, rescue teleport, saved-position/spawn fallback, motion/fall-distance reset, invulnerability, or recovery system. Getting off above a drop is a gameplay risk.
+The rider can **sneak-dismount normally**; either participant can use the stop command. Heights calls only the rider's native `leaveVehicle()` when commanded, leaving placement, falling, damage, and environmental hazards to Minecraft. There is no safe-ground requirement or search, rescue teleport, saved-position/spawn fallback, motion/fall-distance reset, invulnerability, or recovery system. Getting off above a drop is a gameplay risk.

 Eligibility is rechecked every five ticks, including temporary potion application/expiry, administrator edits and external scale modifiers. Death, disconnect, plugin disable and loss of eligibility attempt native cleanup. For observed teleport events, Heights detaches the pair and lets the original teleport continue, without replaying or redirecting it. Native carrier teleports that refuse passengers before emitting an event may still require `/heights carry stop` first.

 Server/plugin cancellation remains authoritative: a refused dismount leaves accurate tracking and is reported, not bypassed or called successful. A cancelled voluntary stop can be retried by either player; automatic eligibility cleanup continues checking and reports refusal once per ride rather than spamming. Lifecycle/disable refusals are logged. Native dismount events are reconciled after dispatch so a later cancellation is honored. An unrelated vehicle is never ejected during stale-pair cleanup.

-**Verification:** automated domain and constructed Bukkit-event tests are not live-server evidence. Purpur 26.2 build 2618 still needs checks for scaled rider positioning and movement, ordinary dismount placement/falling, cancellation interoperability, both-role death/disconnect, portal/cross-world teleports, plugin disable and eligibility changes. No throwing or added launch force, player items, storage, or changes to throwable-potion opt-in behavior are included.
+**Verification:** API/domain tests preserve native cleanup and reject rescue/motion-reset calls.
+`NativeCarryRoutingTest` registers the production listener through Purpur 2618's actual Paper
+plugin manager and dispatches both `PlayerInteractEntityEvent` and `PlayerInteractAtEntityEvent`.
+Same-tick duplicate rider/target interactions are coalesced, including refused mounts; a fresh
+interaction next tick can retry without a gameplay cooldown. Registered mount/dismount cancellation
+and nonadmin stop routing are also covered. Server/player boundaries are doubled; this is not
+client-packet generation or live-server evidence. Supplementary Purpur checks remain for empty/occupied
+hands, scaled rider positioning and movement, native placement/falling, cancellation interoperability,
+both-role death/disconnect, portal/cross-world teleports, disable and potion/admin/expiry eligibility
+changes. No throwing, added launch force, player items, storage, opt-out or rescue behavior is included.

 ## Tiny-player launchers

@@ -94,12 +112,19 @@ height:
  minimum: 0.4
  maximum: 2.0
  adjustment-step: 0.1
+carry:
+  minimum-scale-gap: 0.1
 launcher:
  maximum-player-scale-exclusive: 0.5
  speed: 1.5
  cooldown-ticks: 20
 ```

+`carry.minimum-scale-gap` is independent of potion `height.adjustment-step` and defaults to `0.1`,
+including existing files without the key. It must be a finite, nonnegative number; invalid values
+prevent plugin enable. Zero permits any strictly positive scale difference, **not equal-size riding**.
+Edit this setting in the file and restart; min/max commands preserve it.
+
 Player scales are stored by UUID in `plugins/SpigotHeights/state.yml`.

 ## Commands
@@ -136,7 +161,7 @@ Player names must match an online player exactly (case-insensitive); partial nam

 The plugin JAR is written to `build/libs/`.

-`check` includes `nativeBrewingTest`. It downloads the exact Purpur 26.2 build 2618 launcher (SHA-256 verified) and prepares its runtime dependencies with Paperclip's **patch-only** mode under `build/brewing-runtime/`. It does not start a server, open ports, create a world or accept the EULA. Initial/clean builds need network access; the native test JVM permits up to 1 GiB heap. No runtime implementation classes or test dependencies are packaged in the plugin. Run `./gradlew test` for the fast API/domain suite alone, or `./gradlew nativeBrewingTest` for the native brewing suite. Full verification remains `./gradlew clean check jar`.
+`check` includes `nativeBrewingTest`. It downloads the exact Purpur 26.2 build 2618 launcher (SHA-256 verified) and prepares its runtime dependencies with Paperclip's **patch-only** mode under `build/brewing-runtime/`. It does not start a server, open ports, create a world or accept the EULA. Initial/clean builds need network access; the native test JVM permits up to 1 GiB heap. No runtime implementation classes or test dependencies are packaged in the plugin. Run `./gradlew test` for the fast API/domain suite alone, or `./gradlew nativeBrewingTest` for native brewing and registered carry-event routing tests. Full verification remains `./gradlew clean check jar`.

 ## Releases

@@ -34,6 +34,9 @@ dependencies {

 tasks.test {
    useJUnitPlatform()
+    dependsOn(tasks.jar)
+    systemProperty("distribution.jar", tasks.jar.get().archiveFile.get().asFile.absolutePath)
+    systemProperty("distribution.version", project.version.toString())
 }

 // Exercise the declared runtime's native brewing engine, not a recipe-registry double.
@@ -2,4 +2,4 @@ plugins {
    id("org.gradle.toolchains.foojay-resolver-convention") version "1.0.0"
 }

-rootProject.name = "spigot-heights"
+rootProject.name = "purpur-heights"
@@ -15,7 +15,7 @@ import org.bukkit.event.player.PlayerInteractAtEntityEvent;
 import org.bukkit.event.player.PlayerInteractEntityEvent;
 import org.bukkit.inventory.EquipmentSlot;

-/** Bukkit boundary for the consent state machine. All methods run on the server thread. */
+/** Bukkit boundary for rider-initiated carrying. All methods run on the server thread. */
 public final class BukkitCarry implements Listener, CarryService.Port, AutoCloseable {
    private final Function<UUID, Player> players;
    private final Consumer<Runnable> nextTick;
@@ -24,6 +24,8 @@ public final class BukkitCarry implements Listener, CarryService.Port, AutoClose
    private final CarryService service;
    private final java.util.Set<UUID> dismounting = new java.util.HashSet<>();
    private final java.util.Set<UUID> queuedStops = new java.util.HashSet<>();
+    private record Interaction(UUID rider, UUID carrier) {}
+    private final java.util.Set<Interaction> interactions = new java.util.HashSet<>();
    private UUID mountingCarrier, mountingRider;
    private boolean closed;

@@ -31,36 +33,40 @@ public final class BukkitCarry implements Listener, CarryService.Port, AutoClose
        this(server::getPlayer, settings, nextTick, logger, player -> {
            AttributeInstance attribute = player.getAttribute(Attribute.SCALE);
            return attribute == null ? Double.NaN : attribute.getValue();
-        }, () -> System.nanoTime() / 1_000_000);
+        });
    }
    BukkitCarry(Function<UUID, Player> players, Supplier<HeightSettings> settings,
-            Consumer<Runnable> nextTick, Logger logger, ToDoubleFunction<Player> scales, LongSupplier clock) {
+            Consumer<Runnable> nextTick, Logger logger, ToDoubleFunction<Player> scales) {
        this.players = players; this.nextTick = nextTick; this.logger = logger;
        this.scales = scales;
-        service = new CarryService(this, () -> settings.get().adjustmentStep(), clock);
+        service = new CarryService(this, () -> settings.get().carryMinimumScaleGap());
    }

    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
    public void interact(PlayerInteractEntityEvent event) {
-        if (event.isCancelled() || event instanceof PlayerInteractAtEntityEvent
-                || event.getHand() != EquipmentSlot.HAND || !event.getPlayer().isSneaking()
+        if (closed || event.isCancelled() || event.getHand() != EquipmentSlot.HAND
                || !(event.getRightClicked() instanceof Player target)) { return; }
-        event.setCancelled(true);
        Player sender = event.getPlayer();
-        String result = service.request(sender.getUniqueId(), target.getUniqueId());
-        sender.sendMessage(result);
-        if (result.equals("Carry request sent.")) {
-            target.sendMessage(sender.getName() + (scales.applyAsDouble(sender) > scales.applyAsDouble(target)
-                    ? " wants to carry you." : " wants to ride with you."));
-        }
+        Interaction interaction = new Interaction(sender.getUniqueId(), target.getUniqueId());
+        // Consume duplicates of a handled attempt, even if that attempt was refused or mounted.
+        if (interactions.contains(interaction)) { event.setCancelled(true); return; }
+        // Do not suppress other plugins' interaction handlers when this is not a valid carry attempt.
+        if (!service.canAttemptRide(interaction.rider(), interaction.carrier())) { return; }
+        event.setCancelled(true);
+        // A client interaction can dispatch AtEntity and then Entity in the same tick.
+        // Coalesce that pair even on native refusal; this is not a remount cooldown.
+        interactions.add(interaction);
+        nextTick.accept(() -> interactions.remove(interaction));
+        sender.sendMessage(service.ride(interaction.rider(), interaction.carrier()));
    }
+    // AtEntity has its own HandlerList; registering only the superclass method misses it.
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void interactAt(PlayerInteractAtEntityEvent event) { interact(event); }
    public void command(Player player, String action) {
        UUID id = player.getUniqueId();
        player.sendMessage(switch (action) {
-            case "accept" -> service.accept(id);
-            case "decline" -> service.decline(id);
            case "stop" -> service.stop(id);
-            default -> "Usage: /heights carry accept|decline|stop";
+            default -> "Usage: /heights carry stop";
        });
    }
    @Override public CarryService.State state(UUID id) {
@@ -169,6 +175,7 @@ public final class BukkitCarry implements Listener, CarryService.Port, AutoClose
    public void tick() { if (!closed) { service.tick(); } }
    @Override public void close() {
        closed = true;
+        interactions.clear();
        int unresolved = service.close();
        if (unresolved != 0) { logger.severe("Heights disable: " + unresolved
                + " native dismount(s) were refused by the server; no cancellation was bypassed."); }
@@ -4,13 +4,12 @@ package games.dmg.spigotheights;
 public final class CarryPolicy {
    private CarryPolicy() {}

-    public static boolean eligible(double carrier, double rider, double step) {
-        if (!Double.isFinite(carrier) || !Double.isFinite(rider) || !Double.isFinite(step)
-                || carrier <= 0 || rider <= 0 || step <= 0 || carrier <= rider) {
+    public static boolean eligible(double carrier, double rider, double gap) {
+        if (!Double.isFinite(carrier) || !Double.isFinite(rider) || !Double.isFinite(gap)
+                || carrier <= 0 || rider <= 0 || gap < 0 || carrier <= rider) {
            return false;
        }
-        double required = 3 * step;
        double tolerance = 4 * Math.ulp(Math.max(carrier, rider));
-        return Double.isFinite(required) && carrier - rider + tolerance >= required;
+        return carrier - rider + tolerance >= gap;
    }
 }
@@ -4,7 +4,6 @@ import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
 import java.util.function.DoubleSupplier;
-import java.util.function.LongSupplier;

 /** Tick-thread state machine; ports must not perform blocking I/O. */
 public final class CarryService {
@@ -18,53 +17,44 @@ public final class CarryService {
        boolean dismount(UUID carrier, UUID rider);
        void message(UUID player, String message);
    }
-    private record Request(UUID sender, UUID recipient, UUID carrier, UUID rider, long sentAt) {}
    private record Ride(UUID carrier, UUID rider) {}
    private final Port port;
-    private final DoubleSupplier step;
-    private final LongSupplier clock;
-    private final Map<UUID, Request> requests = new HashMap<>();
+    private final DoubleSupplier gap;
    private final Map<UUID, Ride> rides = new HashMap<>();
+    private final java.util.Set<UUID> mounting = new java.util.HashSet<>();
    private final java.util.Set<UUID> reportedRefusals = new java.util.HashSet<>();
    private boolean closed;

-    public CarryService(Port port, DoubleSupplier step, LongSupplier clock) {
-        this.port = port; this.step = step; this.clock = clock;
+    public CarryService(Port port, DoubleSupplier gap) {
+        this.port = port; this.gap = gap;
    }

-    public String request(UUID sender, UUID recipient) {
+    /** Whether this interaction belongs to Heights; does not mutate or notify either player. */
+    public boolean canAttemptRide(UUID rider, UUID carrier) {
+        return !closed && !involved(rider) && !involved(carrier)
+                && !mounting.contains(rider) && !mounting.contains(carrier)
+                && !rider.equals(carrier) && eligible(carrier, rider, true) && port.nearby(rider, carrier);
+    }
+
+    /** Only the smaller rider may initiate; the target can never force a pickup. */
+    public String ride(UUID rider, UUID carrier) {
        if (closed) { return "Carrying is shutting down."; }
-        expireRequests();
-        if (busy(sender) || busy(recipient)) { return "A player already has a carry request or ride."; }
-        State a = port.state(sender), b = port.state(recipient);
-        if (sender.equals(recipient) || a == null || b == null) { return "Players are unavailable."; }
-        UUID carrier = a.scale() > b.scale() ? sender : recipient;
-        UUID rider = carrier.equals(sender) ? recipient : sender;
-        if (!eligible(carrier, rider, true) || !port.nearby(sender, recipient)) {
-            return "Carry requires nearby, available players differing by at least three adjustment steps.";
+        if (involved(rider) || involved(carrier) || mounting.contains(rider) || mounting.contains(carrier)) {
+            return "A player already has a ride.";
        }
-        Request request = new Request(sender, recipient, carrier, rider, clock.getAsLong());
-        requests.put(recipient, request);
-        port.message(recipient, "Carry request: /heights carry accept or /heights carry decline within 30 seconds.");
-        return "Carry request sent.";
-    }
-
-    public String accept(UUID recipient) {
-        Request request = requests.remove(recipient);
-        if (request == null) { return "No pending request."; }
-        if (clock.getAsLong() - request.sentAt() >= 30_000
-                || involved(request.carrier()) || involved(request.rider())
-                || !eligible(request.carrier(), request.rider(), true)
-                || !port.nearby(request.carrier(), request.rider())) {
-            return "Carry request expired or players are no longer eligible/nearby.";
+        if (rider.equals(carrier) || !eligible(carrier, rider, true) || !port.nearby(rider, carrier)) {
+            return "Right-click an available larger player within 4 blocks; the configured scale gap is required.";
        }
-        boolean mounted = port.mount(request.carrier(), request.rider());
-        if (!mounted && !port.linked(request.carrier(), request.rider())) { return "The server refused the ride."; }
-        Ride ride = new Ride(request.carrier(), request.rider());
+        boolean mounted;
+        mounting.add(carrier); mounting.add(rider);
+        try { mounted = port.mount(carrier, rider); }
+        finally { mounting.remove(carrier); mounting.remove(rider); }
+        if (!mounted && !port.linked(carrier, rider)) { return "The server refused the ride."; }
+        Ride ride = new Ride(carrier, rider);
        rides.put(ride.carrier(), ride); rides.put(ride.rider(), ride);
-        if (!mounted) {
+        if (!mounted || closed) {
            String stopped = stop(ride.rider());
-            String message = "The server produced an invalid ride. " + stopped;
+            String message = (closed ? "Carrying is shutting down. " : "The server produced an invalid ride. ") + stopped;
            if (involved(ride.rider())) { notify(ride, message); }
            return message;
        }
@@ -76,35 +66,10 @@ public final class CarryService {
        State a = port.state(carrier), b = port.state(rider);
        return a != null && b != null && a.available() && b.available()
                && (!free || (a.free() && b.free()))
-                && CarryPolicy.eligible(a.scale(), b.scale(), step.getAsDouble());
+                && CarryPolicy.eligible(a.scale(), b.scale(), gap.getAsDouble());
    }

-    private boolean busy(UUID player) {
-        return involved(player) || requests.values().stream()
-                .anyMatch(request -> request.sender().equals(player) || request.recipient().equals(player));
-    }
-
-    private void expireRequests() {
-        requests.values().removeIf(request -> clock.getAsLong() - request.sentAt() >= 30_000);
-    }
-
-    public String decline(UUID recipient) {
-        Request request = requests.remove(recipient);
-        if (request == null) { return "No pending request."; }
-        port.message(request.sender(), "Carry request declined.");
-        return "Carry request declined.";
-    }
    public String stop(UUID player) {
-        var pending = requests.values().iterator();
-        while (pending.hasNext()) {
-            Request request = pending.next();
-            if (request.sender().equals(player) || request.recipient().equals(player)) {
-                pending.remove();
-                port.message(request.sender().equals(player) ? request.recipient() : request.sender(),
-                        "Carry request cancelled.");
-                return "Carry request cancelled.";
-            }
-        }
        Ride ride = rides.get(player);
        if (ride == null) { return "No active ride."; }
        if (!port.dismount(ride.carrier(), ride.rider())) {
@@ -119,7 +84,6 @@ public final class CarryService {
        port.message(ride.carrier(), message); port.message(ride.rider(), message);
    }
    public void tick() {
-        expireRequests();
        for (Ride ride : java.util.Set.copyOf(rides.values())) {
            if (!eligible(ride.carrier(), ride.rider(), false)
                    || !port.attached(ride.carrier(), ride.rider())) {
@@ -131,14 +95,12 @@ public final class CarryService {
        }
    }
    public boolean cleanup(UUID player) {
-        requests.values().removeIf(request -> request.sender().equals(player) || request.recipient().equals(player));
        stop(player);
        return !involved(player);
    }
    /** Returns server-refused dismounts; never bypasses cancellation or claims false detachment. */
    public int close() {
        closed = true;
-        requests.clear();
        for (Ride ride : java.util.Set.copyOf(rides.values())) { stop(ride.rider()); }
        return rides.size() / 2;
    }
@@ -6,9 +6,21 @@ public record HeightSettings(
        double adjustmentStep,
        double launcherThreshold,
        double launcherSpeed,
-        int launcherCooldownTicks) {
+        int launcherCooldownTicks,
+        double carryMinimumScaleGap) {
+
+    public static final double DEFAULT_CARRY_MINIMUM_SCALE_GAP = 0.1;
+
+    public HeightSettings(double minimum, double maximum, double adjustmentStep,
+            double launcherThreshold, double launcherSpeed, int launcherCooldownTicks) {
+        this(minimum, maximum, adjustmentStep, launcherThreshold, launcherSpeed, launcherCooldownTicks,
+                DEFAULT_CARRY_MINIMUM_SCALE_GAP);
+    }

    public HeightSettings {
+        if (!Double.isFinite(carryMinimumScaleGap) || carryMinimumScaleGap < 0) {
+            throw new IllegalArgumentException("carry.minimum-scale-gap must be a finite nonnegative number");
+        }
        requirePositiveFinite("height.minimum", minimum);
        requirePositiveFinite("height.maximum", maximum);
        requirePositiveFinite("height.adjustment-step", adjustmentStep);
@@ -18,8 +18,8 @@ public final class HeightsCommand implements TabExecutor {
    private final PlayerHeights players;
    private final HeightSetter heightSetter;
    private final java.util.function.BiConsumer<org.bukkit.entity.Player, String> carry;
-    private static final String CARRY_USAGE = "Usage: /heights carry accept|decline|stop";
-    private static final List<String> CARRY_ACTIONS = List.of("accept", "decline", "stop");
+    private static final String CARRY_USAGE = "Usage: /heights carry stop";
+    private static final List<String> CARRY_ACTIONS = List.of("stop");

    @FunctionalInterface
    public interface HeightSetter {
@@ -31,7 +31,7 @@ public final class LiveHeightSettings implements Supplier<HeightSettings> {
                bound.equals("min") ? value : current.minimum(),
                bound.equals("max") ? value : current.maximum(),
                current.adjustmentStep(), current.launcherThreshold(),
-                current.launcherSpeed(), current.launcherCooldownTicks());
+                current.launcherSpeed(), current.launcherCooldownTicks(), current.carryMinimumScaleGap());
    }

    public void setBound(String bound, double value) throws IOException {
@@ -1,6 +1,10 @@
 package games.dmg.spigotheights;

+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
 import java.util.Locale;
+import java.util.Set;
 import java.util.function.Function;
 import io.papermc.paper.potion.PotionMix;
 import net.kyori.adventure.text.Component;
@@ -13,6 +17,7 @@ import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.RecipeChoice;
 import org.bukkit.inventory.ShapedRecipe;
 import org.bukkit.inventory.meta.PotionMeta;
+import org.bukkit.inventory.recipe.CraftingBookCategory;
 import org.bukkit.persistence.PersistentDataType;
 import org.bukkit.plugin.java.JavaPlugin;
 import org.bukkit.potion.PotionType;
@@ -26,6 +31,8 @@ public final class PotionRecipes {
    private final Server server;
    private final NamespacedKey potionKindKey;
    private final Function<Material, ItemStack> items;
+    private final List<NamespacedKey> ownedRecipeKeys = new ArrayList<>();
+    private final Set<NamespacedKey> ownedMixKeys = new LinkedHashSet<>();

    public PotionRecipes(JavaPlugin plugin) {
        this(plugin.getServer(), new NamespacedKey(plugin, "stature_potion"), ItemStack::new);
@@ -41,12 +48,42 @@ public final class PotionRecipes {
        return new NamespacedKey(potionKindKey.getNamespace(), value);
    }

-    public void register() {
-        registerShifting();
-        registerGrowth();
-        registerDiminution();
-        registerRestoration();
+    public boolean register() {
+        boolean complete = registerCrafting();
        registerBrewing(server.getPotionBrewer());
+        return complete;
+    }
+
+    private boolean registerCrafting() {
+        for (ShapedRecipe recipe : List.of(shiftingRecipe(), growthRecipe(), diminutionRecipe(), restorationRecipe())) {
+            NamespacedKey recipeKey = recipe.getKey();
+            if (server.getRecipe(recipeKey) != null) {
+                rollbackCrafting();
+                return false;
+            }
+            try {
+                if (!server.addRecipe(recipe)) {
+                    rollbackCrafting();
+                    return false;
+                }
+            } catch (RuntimeException exception) {
+                try {
+                    if (server.getRecipe(recipeKey) != null) {
+                        ownedRecipeKeys.add(recipeKey);
+                    }
+                } catch (RuntimeException inspectionFailure) {
+                    exception.addSuppressed(inspectionFailure);
+                }
+                throw exception;
+            }
+            ownedRecipeKeys.add(recipeKey);
+        }
+        return true;
+    }
+
+    private void rollbackCrafting() {
+        ownedRecipeKeys.forEach(server::removeRecipe);
+        ownedRecipeKeys.clear();
    }

    public void registerBrewing(org.bukkit.potion.PotionBrewer brewer) {
@@ -64,13 +101,22 @@ public final class PotionRecipes {
                PotionMix.createPredicateChoice(item -> item != null && item.getType() == source
                        && identify(item) == kind),
                PotionMix.createPredicateChoice(item -> item != null && item.getType() == ingredient)));
+        ownedMixKeys.add(mixKey);
+    }
+
+    public void unregister() {
+        ownedRecipeKeys.forEach(server::removeRecipe);
+        ownedRecipeKeys.clear();
+        unregisterBrewing();
    }

    public void unregisterBrewing() {
-        for (StaturePotion kind : StaturePotion.values()) {
-            server.getPotionBrewer().removePotionMix(mixKey(kind, Material.SPLASH_POTION));
-            server.getPotionBrewer().removePotionMix(mixKey(kind, Material.LINGERING_POTION));
+        if (ownedMixKeys.isEmpty()) {
+            return;
        }
+        org.bukkit.potion.PotionBrewer brewer = server.getPotionBrewer();
+        ownedMixKeys.forEach(brewer::removePotionMix);
+        ownedMixKeys.clear();
    }

    private NamespacedKey mixKey(StaturePotion kind, Material target) {
@@ -123,26 +169,36 @@ public final class PotionRecipes {
        return key("shifting_stature");
    }

-    private void registerShifting() {
+    public List<NamespacedKey> recipeKeys() {
+        return List.of(shiftingKey(), key("growth"), key("diminution"), key("restoration"));
+    }
+
+    private ShapedRecipe shiftingRecipe() {
        ShapedRecipe recipe = new ShapedRecipe(shiftingKey(), create(StaturePotion.SHIFTING));
        recipe.shape(SHIFTING_SHAPE);
        recipe.setIngredient('A', Material.AMETHYST_SHARD);
        recipe.setIngredient('C', Material.CHORUS_FRUIT);
-        recipe.setIngredient('W', Material.POTION);
-        server.addRecipe(recipe);
+        ItemStack awkward = items.apply(Material.POTION);
+        PotionMeta awkwardMeta = (PotionMeta) awkward.getItemMeta();
+        awkwardMeta.setBasePotionType(PotionType.AWKWARD);
+        awkward.setItemMeta(awkwardMeta);
+        recipe.setIngredient('W', new RecipeChoice.ExactChoice(awkward));
+        recipe.setCategory(CraftingBookCategory.MISC);
+        return recipe;
    }

-    private void registerGrowth() {
+    private ShapedRecipe growthRecipe() {
        ShapedRecipe recipe = new ShapedRecipe(key("growth"), create(StaturePotion.GROWTH));
        recipe.shape(GROWTH_SHAPE);
        recipe.setIngredient('G', Material.GOLD_INGOT);
        recipe.setIngredient('A', Material.AMETHYST_SHARD);
        recipe.setIngredient('S', new RecipeChoice.ExactChoice(create(StaturePotion.SHIFTING)));
        recipe.setIngredient('R', Material.RABBIT_FOOT);
-        server.addRecipe(recipe);
+        recipe.setCategory(CraftingBookCategory.MISC);
+        return recipe;
    }

-    private void registerDiminution() {
+    private ShapedRecipe diminutionRecipe() {
        ShapedRecipe recipe = new ShapedRecipe(key("diminution"),
                create(StaturePotion.DIMINUTION));
        recipe.shape(DIMINUTION_SHAPE);
@@ -150,10 +206,11 @@ public final class PotionRecipes {
        recipe.setIngredient('A', Material.AMETHYST_SHARD);
        recipe.setIngredient('S', new RecipeChoice.ExactChoice(create(StaturePotion.SHIFTING)));
        recipe.setIngredient('F', Material.FERMENTED_SPIDER_EYE);
-        server.addRecipe(recipe);
+        recipe.setCategory(CraftingBookCategory.MISC);
+        return recipe;
    }

-    private void registerRestoration() {
+    private ShapedRecipe restorationRecipe() {
        ShapedRecipe recipe = new ShapedRecipe(key("restoration"),
                create(StaturePotion.RESTORATION));
        recipe.shape(RESTORATION_SHAPE);
@@ -161,7 +218,8 @@ public final class PotionRecipes {
        recipe.setIngredient('A', Material.AMETHYST_SHARD);
        recipe.setIngredient('S', new RecipeChoice.ExactChoice(create(StaturePotion.SHIFTING)));
        recipe.setIngredient('U', Material.SUGAR);
-        server.addRecipe(recipe);
+        recipe.setCategory(CraftingBookCategory.MISC);
+        return recipe;
    }

    private static Color color(StaturePotion kind) {
@@ -0,0 +1,50 @@
+package games.dmg.spigotheights;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+public final class RecipeDiscovery implements Listener {
+    private final List<NamespacedKey> recipeKeys;
+    private final Logger logger;
+
+    public RecipeDiscovery(List<NamespacedKey> recipeKeys, Logger logger) {
+        this.recipeKeys = List.copyOf(recipeKeys);
+        this.logger = Objects.requireNonNull(logger, "logger");
+    }
+
+    public void discoverAll(Iterable<? extends Player> players) {
+        players.forEach(this::discover);
+    }
+
+    @EventHandler
+    public void onJoin(PlayerJoinEvent event) {
+        discover(event.getPlayer());
+    }
+
+    public void discover(Player player) {
+        try {
+            List<NamespacedKey> unknown = recipeKeys.stream()
+                    .filter(key -> !player.hasDiscoveredRecipe(key))
+                    .toList();
+            if (unknown.isEmpty()) {
+                return;
+            }
+            player.discoverRecipes(unknown);
+            List<NamespacedKey> stillUnknown = unknown.stream()
+                    .filter(key -> !player.hasDiscoveredRecipe(key))
+                    .toList();
+            if (!stillUnknown.isEmpty()) {
+                logger.warning("Could not discover stature recipes for " + player.getName() + ": " + stillUnknown);
+            }
+        } catch (RuntimeException exception) {
+            logger.log(Level.WARNING, "Could not discover stature recipes for " + player.getName(), exception);
+        }
+    }
+}
@@ -0,0 +1,64 @@
+package games.dmg.spigotheights;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.bukkit.plugin.Plugin;
+
+public final class RecipeLifecycle {
+    private final Server server;
+    private final Plugin plugin;
+    private final PotionRecipes recipes;
+    private final Logger logger;
+    private RecipeDiscovery discovery;
+
+    public RecipeLifecycle(Server server, Plugin plugin, PotionRecipes recipes, Logger logger) {
+        this.server = Objects.requireNonNull(server, "server");
+        this.plugin = Objects.requireNonNull(plugin, "plugin");
+        this.recipes = Objects.requireNonNull(recipes, "recipes");
+        this.logger = Objects.requireNonNull(logger, "logger");
+    }
+
+    public boolean enable() {
+        if (discovery != null) {
+            return true;
+        }
+        try {
+            if (!recipes.register()) {
+                logger.severe("Stature recipes were not registered as a complete group; discovery is disabled.");
+                return false;
+            }
+            List<? extends Player> onlinePlayers = List.copyOf(server.getOnlinePlayers());
+            discovery = new RecipeDiscovery(recipes.recipeKeys(), logger);
+            server.getPluginManager().registerEvents(discovery, plugin);
+            discovery.discoverAll(onlinePlayers);
+            return true;
+        } catch (RuntimeException exception) {
+            unregisterDiscovery();
+            try {
+                recipes.unregister();
+            } catch (RuntimeException cleanupFailure) {
+                exception.addSuppressed(cleanupFailure);
+            }
+            logger.log(Level.SEVERE,
+                    "Stature recipes were not registered as a complete group; discovery is disabled.", exception);
+            return false;
+        }
+    }
+
+    public void disable() {
+        unregisterDiscovery();
+        recipes.unregister();
+    }
+
+    private void unregisterDiscovery() {
+        if (discovery != null) {
+            HandlerList.unregisterAll(discovery);
+            discovery = null;
+        }
+    }
+}
@@ -8,6 +8,7 @@ import org.bukkit.plugin.java.JavaPlugin;
 public final class SpigotHeightsPlugin extends JavaPlugin {
    private BukkitStatureService stature;
    private PotionRecipes potions;
+    private RecipeLifecycle recipeLifecycle;
    private BukkitCarry carry;
    @Override
    public void onEnable() {
@@ -42,7 +43,8 @@ public final class SpigotHeightsPlugin extends JavaPlugin {
        command.setTabCompleter(executor);

        potions = new PotionRecipes(this);
-        potions.register();
+        recipeLifecycle = new RecipeLifecycle(getServer(), this, potions, getLogger());
+        recipeLifecycle.enable();
        getServer().getPluginManager().registerEvents(new StatureBrewing(potions), this);
        getServer().getPluginManager().registerEvents(
                new StatureListener(potions, stature::drink, stature::resume,
@@ -67,18 +69,22 @@ public final class SpigotHeightsPlugin extends JavaPlugin {
        if (stature != null) {
            stature.close();
        }
-        if (potions != null) {
-            potions.unregisterBrewing();
+        if (recipeLifecycle != null) {
+            recipeLifecycle.disable();
        }
    }

    static HeightSettings loadSettings(FileConfiguration config) {
+        Object configuredGap = config.get("carry.minimum-scale-gap", HeightSettings.DEFAULT_CARRY_MINIMUM_SCALE_GAP);
+        if (!(configuredGap instanceof Number gap)) {
+            throw new IllegalArgumentException("carry.minimum-scale-gap must be a finite nonnegative number");
+        }
        return new HeightSettings(
                config.getDouble("height.minimum"),
                config.getDouble("height.maximum"),
                config.getDouble("height.adjustment-step"),
                config.getDouble("launcher.maximum-player-scale-exclusive"),
                config.getDouble("launcher.speed"),
-                config.getInt("launcher.cooldown-ticks"));
+                config.getInt("launcher.cooldown-ticks"), gap.doubleValue());
    }
 }
@@ -3,6 +3,10 @@ height:
  maximum: 2.0
  adjustment-step: 0.1

+# Independent of potion adjustment-step. Zero still requires a strictly larger carrier.
+carry:
+  minimum-scale-gap: 0.1
+
 launcher:
  maximum-player-scale-exclusive: 0.5
  speed: 1.5
@@ -6,8 +6,8 @@ description: Craftable player stature potions and tiny-player dispenser launcher
 author: dmg.games
 commands:
  heights:
-    description: Request consensual carrying or administer stature settings and player heights.
-    usage: /heights carry accept|decline|stop | /heights settings | /heights set min|max <value> | /heights player <name> [scale]
+    description: Stop a ride or administer stature settings and player heights.
+    usage: /heights carry stop | /heights settings | /heights set min|max <value> | /heights player <name> [scale]
 permissions:
  spigotheights.admin:
    description: View and change Spigot Heights settings and player heights.
@@ -0,0 +1,242 @@
+package games.dmg.spigotheights;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import io.papermc.paper.plugin.manager.PaperPluginManagerImpl;
+import java.util.*;
+import java.util.logging.Logger;
+import org.bukkit.*;
+import org.bukkit.command.SimpleCommandMap;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerInteractAtEntityEvent;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.PluginDescriptionFile;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.util.Vector;
+import org.junit.jupiter.api.*;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+/** Actual Purpur 2618 listener discovery, distinct handler lists and Paper event dispatch.
+ * Only server/player boundaries are doubled; no listening server or client packets. */
+class NativeCarryRoutingTest {
+    private static Server previousServer;
+    private PluginManager events;
+    private Plugin plugin;
+    private BukkitCarry carry;
+    private final List<Runnable> scheduled = new ArrayList<>();
+    private final Player small = mock(Player.class), large = mock(Player.class);
+    private final List<String> replies = new ArrayList<>();
+    private boolean attached, mountAllowed = true;
+    private int mounts;
+    private double smallScale = 0.9, largeScale = 1.0;
+
+    @BeforeAll
+    static void rememberServer() { previousServer = Bukkit.getServer(); }
+
+    @AfterAll
+    static void restoreServer() throws Exception { setServer(previousServer); }
+
+    private static void setServer(Server server) throws Exception {
+        // Bukkit's global is restored so the separate existing native brewing suite is untouched.
+        var field = Bukkit.class.getDeclaredField("server");
+        field.setAccessible(true);
+        field.set(null, server);
+    }
+
+    @BeforeEach
+    void registerProductionListener() throws Exception {
+        HandlerList.unregisterAll();
+        Server server = mock(Server.class);
+        when(server.isPrimaryThread()).thenReturn(true);
+        when(server.getLogger()).thenReturn(Logger.getLogger("NativeCarryRoutingTest"));
+        setServer(server);
+        events = new PaperPluginManagerImpl(server, new SimpleCommandMap(server, new HashMap<>()), null);
+        when(server.getPluginManager()).thenReturn(events);
+        plugin = mock(Plugin.class);
+        when(plugin.isEnabled()).thenReturn(true);
+        when(plugin.getName()).thenReturn("SpigotHeights");
+        when(plugin.getLogger()).thenReturn(Logger.getLogger("NativeCarryRoutingTest"));
+        var description = new PluginDescriptionFile("SpigotHeights", "test", "unused.Main");
+        when(plugin.getDescription()).thenReturn(description);
+        when(plugin.getPluginMeta()).thenReturn(description);
+        World world = mock(World.class);
+        when(world.getUID()).thenReturn(UUID.randomUUID());
+        for (Player p : List.of(small, large)) {
+            when(p.getUniqueId()).thenReturn(UUID.randomUUID());
+            when(p.getWorld()).thenReturn(world);
+            when(p.getLocation()).thenReturn(new Location(world, 0, 64, 0));
+            when(p.isOnline()).thenReturn(true);
+            when(p.isValid()).thenReturn(true);
+            when(p.getGameMode()).thenReturn(GameMode.SURVIVAL);
+            doAnswer(invocation -> { replies.add(invocation.getArgument(0, String.class)); return null; })
+                    .when(p).sendMessage(anyString());
+        }
+        when(small.getVehicle()).thenAnswer(invocation -> attached ? large : null);
+        when(small.isInsideVehicle()).thenAnswer(invocation -> attached);
+        when(large.getPassengers()).thenAnswer(invocation -> attached ? List.of(small) : List.of());
+        when(large.addPassenger(small)).thenAnswer(invocation -> {
+            mounts++;
+            var event = new org.bukkit.event.entity.EntityMountEvent(small, large);
+            events.callEvent(event);
+            attached = mountAllowed && !event.isCancelled();
+            return attached;
+        });
+        when(small.leaveVehicle()).thenAnswer(invocation -> {
+            var event = new org.bukkit.event.entity.EntityDismountEvent(small, large, true);
+            events.callEvent(event);
+            if (!event.isCancelled()) { attached = false; }
+            return true; // Intentionally unreliable: production code must inspect attachment.
+        });
+        carry = new BukkitCarry(id -> id.equals(small.getUniqueId()) ? small : large,
+                () -> new HeightSettings(0.4, 2, 0.25, 0.5, 1.5, 20), scheduled::add,
+                server.getLogger(), p -> p == small ? smallScale : largeScale);
+        events.registerEvents(carry, plugin);
+    }
+
+    private PlayerInteractEntityEvent click(boolean at, Player sender, Player target, EquipmentSlot hand) {
+        return at ? new PlayerInteractAtEntityEvent(sender, target, new Vector(), hand)
+                : new PlayerInteractEntityEvent(sender, target, hand);
+    }
+
+    private void drain() {
+        var tasks = List.copyOf(scheduled);
+        scheduled.clear();
+        tasks.forEach(Runnable::run);
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void duplicateEventTypesDoNotRepeatMountAttemptsOrMessagesEvenAfterRefusal(boolean atFirst) {
+        for (boolean allowed : new boolean[] {false, true}) {
+            mountAllowed = allowed;
+            int before = mounts;
+            var first = click(atFirst, small, large, EquipmentSlot.HAND);
+            events.callEvent(first);
+            assertTrue(first.isCancelled());
+            int messageCount = replies.size();
+            var duplicate = click(!atFirst, small, large, EquipmentSlot.HAND);
+            events.callEvent(duplicate);
+            assertTrue(duplicate.isCancelled(), "A duplicate of a handled interaction stays consumed");
+            events.callEvent(click(atFirst, small, large, EquipmentSlot.OFF_HAND));
+            assertEquals(before + 1, mounts, "One native attempt for the duplicate event pair, even on refusal");
+            assertEquals(messageCount, replies.size(), "Duplicate dispatch must not send another refusal/busy reply");
+            assertEquals(allowed, attached);
+            if (attached) { carry.command(large, "stop"); }
+            drain(); // A fresh interaction next tick may immediately remount: no gameplay cooldown.
+        }
+        events.callEvent(click(atFirst, small, large, EquipmentSlot.HAND));
+        assertTrue(attached);
+        assertEquals(3, mounts);
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void registeredRoutingHonorsCancellationAndOffhandWithoutSwallowingNextValidEvent(boolean at) {
+        var cancelled = click(at, small, large, EquipmentSlot.HAND);
+        cancelled.setCancelled(true);
+        events.callEvent(cancelled);
+        events.callEvent(click(at, small, large, EquipmentSlot.OFF_HAND));
+        assertEquals(0, mounts);
+        assertTrue(replies.isEmpty());
+        events.callEvent(click(!at, small, large, EquipmentSlot.HAND));
+        assertTrue(attached);
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"equal", "larger", "offline", "distant", "already-riding"})
+    void ineligibleInteractionsRemainAvailableToOtherPlugins(String reason) {
+        switch (reason) {
+            case "equal" -> smallScale = largeScale;
+            case "larger" -> smallScale = largeScale + 0.2;
+            case "offline" -> when(small.isOnline()).thenReturn(false);
+            case "distant" -> {
+                Location distant = new Location(small.getWorld(), 0, 64, 5);
+                when(small.getLocation()).thenReturn(distant);
+            }
+            case "already-riding" -> when(small.isInsideVehicle()).thenReturn(true);
+            default -> throw new AssertionError(reason);
+        }
+        for (boolean at : new boolean[] {true, false}) {
+            var interaction = click(at, small, large, EquipmentSlot.HAND);
+            events.callEvent(interaction);
+            assertFalse(interaction.isCancelled(), "Rejected carry must leave unrelated interaction handlers available");
+        }
+        assertEquals(0, mounts);
+        assertTrue(replies.isEmpty());
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void nativeMountCancellationIsRespectedAndFreshInteractionCanRetry(boolean at) {
+        Listener canceller = new Listener() {};
+        events.registerEvent(org.bukkit.event.entity.EntityMountEvent.class, canceller, EventPriority.HIGHEST,
+                (listener, event) -> ((org.bukkit.event.entity.EntityMountEvent) event).setCancelled(true), plugin);
+        events.callEvent(click(at, small, large, EquipmentSlot.HAND));
+        assertFalse(attached);
+        assertEquals(1, mounts);
+        assertTrue(replies.getLast().contains("refused"));
+        HandlerList.unregisterAll(canceller);
+        drain();
+        events.callEvent(click(at, small, large, EquipmentSlot.HAND));
+        assertTrue(attached);
+        assertEquals(2, mounts);
+    }
+
+    @Test
+    void nonadminCommandRoutingLetsEitherParticipantStopAndNativeSneakDismountClearsTracking() {
+        var settings = new LiveHeightSettings(new HeightSettings(0.4, 2, 0.1, 0.5, 1.5, 20), ignored -> {});
+        var command = new HeightsCommand(settings, null, plugin.getLogger(),
+                (name, value, reply) -> fail("Carry must not reach admin setter"), carry::command);
+        for (Player participant : List.of(small, large)) {
+            events.callEvent(click(true, small, large, EquipmentSlot.HAND));
+            assertTrue(attached);
+            assertFalse(participant.hasPermission("spigotheights.admin"));
+            command.onCommand(participant, null, "heights", new String[] {"carry", "stop"});
+            assertFalse(attached);
+            drain();
+        }
+        events.callEvent(click(false, small, large, EquipmentSlot.HAND));
+        assertTrue(attached);
+        small.leaveVehicle(); // Native sneak path: real registered MONITOR observer sees the event.
+        drain();
+        events.callEvent(click(true, small, large, EquipmentSlot.HAND));
+        assertTrue(attached, "Ordinary native detach must release Heights tracking");
+        assertEquals(4, mounts);
+    }
+
+    @Test
+    void registeredDismountLateCancellationRetainsRideUntilCarrierRetriesStop() {
+        events.callEvent(click(true, small, large, EquipmentSlot.HAND));
+        Listener canceller = new Listener() {};
+        events.registerEvent(org.bukkit.event.entity.EntityDismountEvent.class, canceller, EventPriority.MONITOR,
+                (listener, event) -> ((org.bukkit.event.entity.EntityDismountEvent) event).setCancelled(true), plugin);
+        small.leaveVehicle();
+        drain();
+        assertTrue(attached);
+        carry.command(large, "stop");
+        assertTrue(attached);
+        assertTrue(replies.getLast().contains("refused"));
+        HandlerList.unregisterAll(canceller);
+        carry.command(large, "stop");
+        assertFalse(attached);
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void registeredMainHandEventsImmediatelyMountOnlyTheSmallerInitiator(boolean at) {
+        events.callEvent(click(at, large, small, EquipmentSlot.HAND));
+        assertEquals(0, mounts, "Larger players cannot initiate pickup");
+        assertFalse(small.isSneaking());
+        events.callEvent(click(at, small, large, EquipmentSlot.HAND));
+        assertTrue(attached, "Registered handler must receive this event without sneaking or acceptance");
+        assertEquals(1, mounts);
+        assertTrue(replies.stream().noneMatch(reply -> reply.contains("request")));
+    }
+}
@@ -0,0 +1,864 @@
+package games.dmg.spigotheights;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
+
+import io.papermc.paper.plugin.manager.PaperPluginManagerImpl;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Handler;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.Server;
+import org.bukkit.command.SimpleCommandMap;
+import org.bukkit.craftbukkit.inventory.CraftItemFactory;
+import org.bukkit.craftbukkit.inventory.CraftItemStack;
+import org.bukkit.craftbukkit.inventory.CraftRecipe;
+import org.bukkit.craftbukkit.util.CraftMagicNumbers;
+import org.bukkit.Keyed;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.Recipe;
+import org.bukkit.inventory.RecipeChoice;
+import org.bukkit.inventory.ShapedRecipe;
+import org.bukkit.inventory.recipe.CraftingBookCategory;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.PluginDescriptionFile;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.potion.PotionBrewer;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/** Pinned Purpur book, codec, placement and result-slot behavior with server/player boundaries doubled.
+ * No listening server, client, CraftServer registry or CraftPlayer discovery bridge is started here. */
+class NativeRecipeBookTest {
+    private static Server previousServer;
+    private static Server serverUnderTest;
+
+    @BeforeAll
+    static void bootstrap() throws Exception {
+        NativeRuntime.bootstrap();
+        previousServer = Bukkit.getServer();
+        serverUnderTest = mock(Server.class);
+        setServer(serverUnderTest);
+    }
+
+    @BeforeEach
+    void configureServer() {
+        reset(serverUnderTest);
+        when(serverUnderTest.getItemFactory()).thenAnswer(invocation -> CraftItemFactory.instance());
+        when(serverUnderTest.getUnsafe()).thenReturn(CraftMagicNumbers.INSTANCE);
+        when(serverUnderTest.isPrimaryThread()).thenReturn(true);
+    }
+
+    @AfterAll
+    static void restoreServer() throws Exception {
+        setServer(previousServer);
+    }
+
+    private static void setServer(Server server) throws Exception {
+        var field = Bukkit.class.getDeclaredField("server");
+        field.setAccessible(true);
+        field.set(null, server);
+    }
+
+    @Test
+    void nativeRecipeBookAwardsKnownHighlightsAndNotificationOnlyOnce() {
+        Server server = Bukkit.getServer();
+        List<Recipe> registered = new ArrayList<>();
+        when(server.addRecipe(any(Recipe.class))).thenAnswer(invocation -> {
+            registered.add(invocation.getArgument(0));
+            return true;
+        });
+        when(server.getPotionBrewer()).thenReturn(mock(PotionBrewer.class));
+        List<org.bukkit.event.Event> events = new ArrayList<>();
+        PluginManager pluginManager = mock(PluginManager.class);
+        doAnswer(invocation -> {
+            events.add(invocation.getArgument(0));
+            return null;
+        }).when(pluginManager).callEvent(any());
+        when(server.getPluginManager()).thenReturn(pluginManager);
+        PotionRecipes recipes = new PotionRecipes(server,
+                new NamespacedKey("spigotheights", "stature_potion"), ItemStack::new);
+        assertTrue(recipes.register());
+
+        java.util.Map<net.minecraft.resources.ResourceKey<net.minecraft.world.item.crafting.Recipe<?>>,
+                net.minecraft.world.item.crafting.ShapedRecipe> nativeRecipes = new HashMap<>();
+        List<net.minecraft.world.item.crafting.RecipeHolder<?>> holders = new ArrayList<>();
+        for (Recipe recipe : registered) {
+            ShapedRecipe bukkit = (ShapedRecipe) recipe;
+            var key = nativeRecipeKey(bukkit.getKey());
+            var nativeRecipe = nativeRecipe(bukkit);
+            nativeRecipes.put(key, nativeRecipe);
+            holders.add(new net.minecraft.world.item.crafting.RecipeHolder<>(key, nativeRecipe));
+        }
+        AtomicInteger displayId = new AtomicInteger();
+        java.util.Map<net.minecraft.resources.ResourceKey<net.minecraft.world.item.crafting.Recipe<?>>,
+                Integer> displayIds = new HashMap<>();
+        nativeRecipes.keySet().forEach(key -> displayIds.put(key, displayId.getAndIncrement()));
+        TestServerRecipeBook book = new TestServerRecipeBook((key, consumer) -> {
+            net.minecraft.world.item.crafting.ShapedRecipe recipe = nativeRecipes.get(key);
+            consumer.accept(new net.minecraft.world.item.crafting.display.RecipeDisplayEntry(
+                    new net.minecraft.world.item.crafting.display.RecipeDisplayId(displayIds.get(key)),
+                    recipe.display().getFirst(), java.util.OptionalInt.empty(), recipe.recipeBookCategory(),
+                    java.util.Optional.of(recipe.placementInfo().ingredients())));
+        });
+        var nativePlayer = mock(net.minecraft.server.level.ServerPlayer.class);
+        when(nativePlayer.getBukkitEntity()).thenReturn(
+                mock(org.bukkit.craftbukkit.entity.CraftPlayer.class));
+        when(nativePlayer.getAdvancements()).thenReturn(mock(net.minecraft.server.PlayerAdvancements.class));
+
+        assertEquals(4, book.addRecipes(holders, nativePlayer));
+        assertEquals(0, book.addRecipes(holders, nativePlayer));
+
+        assertEquals(new LinkedHashSet<>(nativeRecipes.keySet()), book.known);
+        assertEquals(new LinkedHashSet<>(nativeRecipes.keySet()),
+                new LinkedHashSet<>(book.pack().highlight()));
+        assertEquals(4, events.size());
+        assertTrue(events.stream().allMatch(org.bukkit.event.player.PlayerRecipeDiscoverEvent.class::isInstance));
+        assertTrue(events.stream().map(org.bukkit.event.player.PlayerRecipeDiscoverEvent.class::cast)
+                .allMatch(org.bukkit.event.player.PlayerRecipeDiscoverEvent::shouldShowNotification));
+
+        net.minecraft.nbt.Tag serialized = net.minecraft.stats.ServerRecipeBook.Packed.CODEC
+                .encodeStart(net.minecraft.nbt.NbtOps.INSTANCE, book.pack()).getOrThrow();
+        net.minecraft.stats.ServerRecipeBook.Packed decoded = net.minecraft.stats.ServerRecipeBook.Packed.CODEC
+                .parse(net.minecraft.nbt.NbtOps.INSTANCE, serialized).getOrThrow();
+        TestServerRecipeBook restored = new TestServerRecipeBook();
+        restored.loadUntrusted(decoded, nativeRecipes::containsKey);
+        assertEquals(book.known, restored.known);
+        assertEquals(new LinkedHashSet<>(book.pack().highlight()),
+                new LinkedHashSet<>(restored.pack().highlight()));
+    }
+
+    @Test
+    void nativeRecipeBookSerializationPreservesKnownHighlightsAndVanillaStateAcrossReenable() {
+        List<net.minecraft.resources.ResourceKey<net.minecraft.world.item.crafting.Recipe<?>>> statureKeys =
+                List.of("shifting_stature", "growth", "diminution", "restoration").stream()
+                        .map(value -> nativeRecipeKey(new NamespacedKey("spigotheights", value)))
+                        .toList();
+        var vanillaKey = nativeRecipeKey(new NamespacedKey("minecraft", "stick"));
+        TestServerRecipeBook original = new TestServerRecipeBook();
+        original.setBookSetting(net.minecraft.world.inventory.RecipeBookType.CRAFTING, true, true);
+        original.add(vanillaKey);
+        original.highlight(vanillaKey);
+        statureKeys.forEach(key -> {
+            original.add(key);
+            original.highlight(key);
+        });
+
+        net.minecraft.nbt.Tag serialized = net.minecraft.stats.ServerRecipeBook.Packed.CODEC
+                .encodeStart(net.minecraft.nbt.NbtOps.INSTANCE, original.pack()).getOrThrow();
+        net.minecraft.stats.ServerRecipeBook.Packed decoded = net.minecraft.stats.ServerRecipeBook.Packed.CODEC
+                .parse(net.minecraft.nbt.NbtOps.INSTANCE, serialized).getOrThrow();
+        TestServerRecipeBook restored = new TestServerRecipeBook();
+        restored.loadUntrusted(decoded, key -> true);
+
+        assertTrue(restored.contains(vanillaKey));
+        statureKeys.forEach(key -> assertTrue(restored.contains(key)));
+        assertEquals(new LinkedHashSet<>(decoded.known()), restored.known);
+        assertEquals(new LinkedHashSet<>(decoded.highlight()), new LinkedHashSet<>(restored.pack().highlight()));
+        assertTrue(restored.isOpen(net.minecraft.world.inventory.RecipeBookType.CRAFTING));
+        assertTrue(restored.isFiltering(net.minecraft.world.inventory.RecipeBookType.CRAFTING));
+
+        int knownBeforeReenable = restored.known.size();
+        int highlightsBeforeReenable = restored.pack().highlight().size();
+        statureKeys.forEach(restored::add);
+        assertEquals(knownBeforeReenable, restored.known.size());
+        assertEquals(highlightsBeforeReenable, restored.pack().highlight().size(),
+                "Re-enable must not manufacture another first-time highlight");
+        assertTrue(restored.contains(vanillaKey));
+    }
+
+    private static final class TestServerRecipeBook extends net.minecraft.stats.ServerRecipeBook {
+        TestServerRecipeBook() {
+            this((key, consumer) -> { });
+        }
+
+        TestServerRecipeBook(net.minecraft.stats.ServerRecipeBook.DisplayResolver resolver) {
+            super(resolver);
+        }
+
+        void highlight(net.minecraft.resources.ResourceKey<net.minecraft.world.item.crafting.Recipe<?>> key) {
+            highlight.add(key);
+        }
+    }
+
+    @Test
+    void disableAndReenableReRegistersRecipesWithoutForgettingPlayerKnowledge() {
+        Server server = Bukkit.getServer();
+        Set<NamespacedKey> registry = new LinkedHashSet<>();
+        when(server.addRecipe(any(Recipe.class))).thenAnswer(invocation ->
+                registry.add(((Keyed) invocation.getArgument(0)).getKey()));
+        when(server.removeRecipe(any(NamespacedKey.class))).thenAnswer(invocation ->
+                registry.remove(invocation.getArgument(0)));
+        when(server.getPotionBrewer()).thenReturn(mock(PotionBrewer.class));
+        when(server.getPluginManager()).thenReturn(mock(PluginManager.class));
+        Set<NamespacedKey> known = new LinkedHashSet<>();
+        Player player = discoveryPlayer("Persistent", known);
+        doReturn(List.of(player)).when(server).getOnlinePlayers();
+        Plugin plugin = mock(Plugin.class);
+        Logger logger = Logger.getAnonymousLogger();
+        PotionRecipes firstRecipes = new PotionRecipes(server,
+                new NamespacedKey("spigotheights", "stature_potion"), ItemStack::new);
+        RecipeLifecycle first = new RecipeLifecycle(server, plugin, firstRecipes, logger);
+
+        assertTrue(first.enable());
+        first.disable();
+        assertTrue(registry.isEmpty());
+        assertEquals(new LinkedHashSet<>(firstRecipes.recipeKeys()), known);
+
+        PotionRecipes secondRecipes = new PotionRecipes(server,
+                new NamespacedKey("spigotheights", "stature_potion"), ItemStack::new);
+        assertTrue(new RecipeLifecycle(server, plugin, secondRecipes, logger).enable());
+        assertEquals(new LinkedHashSet<>(secondRecipes.recipeKeys()), registry);
+        verify(player, times(1)).discoverRecipes(any());
+        verify(player, never()).undiscoverRecipes(any());
+    }
+
+    @Test
+    void onlineEnumerationFailureDoesNotLeaveDiscoveryListenerActiveAfterCleanup() {
+        Server server = Bukkit.getServer();
+        when(server.addRecipe(any(Recipe.class))).thenReturn(true);
+        when(server.getPotionBrewer()).thenReturn(mock(PotionBrewer.class));
+        PluginManager events = new PaperPluginManagerImpl(server,
+                new SimpleCommandMap(server, new HashMap<>()), null);
+        when(server.getPluginManager()).thenReturn(events);
+        when(server.getOnlinePlayers()).thenThrow(new IllegalStateException("simulated lifecycle failure"));
+        Plugin plugin = mock(Plugin.class);
+        when(plugin.isEnabled()).thenReturn(true);
+        when(plugin.getName()).thenReturn("SpigotHeights");
+        when(plugin.getLogger()).thenReturn(Logger.getAnonymousLogger());
+        PluginDescriptionFile description = new PluginDescriptionFile("SpigotHeights", "test", "unused.Main");
+        when(plugin.getDescription()).thenReturn(description);
+        when(plugin.getPluginMeta()).thenReturn(description);
+        Set<NamespacedKey> joiningKnown = new LinkedHashSet<>();
+        Player joining = discoveryPlayer("Joining", joiningKnown);
+        PotionRecipes recipes = new PotionRecipes(server,
+                new NamespacedKey("spigotheights", "stature_potion"), ItemStack::new);
+        RecipeLifecycle lifecycle = new RecipeLifecycle(server, plugin, recipes, plugin.getLogger());
+
+        assertFalse(lifecycle.enable());
+        events.callEvent(new PlayerJoinEvent(joining, "joined"));
+
+        assertTrue(joiningKnown.isEmpty());
+    }
+
+    @Test
+    void listenerRegistrationExceptionRemovesPartiallyRegisteredDiscoveryListener() {
+        Server server = Bukkit.getServer();
+        when(server.addRecipe(any(Recipe.class))).thenReturn(true);
+        when(server.getPotionBrewer()).thenReturn(mock(PotionBrewer.class));
+        PluginManager registeredEvents = new PaperPluginManagerImpl(server,
+                new SimpleCommandMap(server, new HashMap<>()), null);
+        PluginManager throwingEvents = mock(PluginManager.class);
+        doAnswer(invocation -> {
+            registeredEvents.registerEvents(invocation.getArgument(0), invocation.getArgument(1));
+            throw new IllegalStateException("simulated post-registration failure");
+        }).when(throwingEvents).registerEvents(any(), any());
+        when(server.getPluginManager()).thenReturn(throwingEvents);
+        doReturn(List.of()).when(server).getOnlinePlayers();
+        Plugin plugin = enabledPlugin("ListenerFailure");
+        Set<NamespacedKey> joiningKnown = new LinkedHashSet<>();
+        Player joining = discoveryPlayer("Joining", joiningKnown);
+        PotionRecipes recipes = new PotionRecipes(server,
+                new NamespacedKey("spigotheights", "stature_potion"), ItemStack::new);
+        RecipeLifecycle lifecycle = new RecipeLifecycle(server, plugin, recipes, plugin.getLogger());
+
+        assertFalse(lifecycle.enable());
+        registeredEvents.callEvent(new PlayerJoinEvent(joining, "joined"));
+
+        assertTrue(joiningKnown.isEmpty(), "A failed lifecycle must not leave its listener active");
+        verify(server, times(4)).removeRecipe(any());
+    }
+
+    @Test
+    void lifecycleRegistrationExceptionCleansOwnedRecipesLogsAndAwardsNobody() {
+        Server server = Bukkit.getServer();
+        AtomicInteger attempts = new AtomicInteger();
+        List<NamespacedKey> removed = new ArrayList<>();
+        when(server.addRecipe(any(Recipe.class))).thenAnswer(invocation -> {
+            if (attempts.getAndIncrement() == 1) {
+                throw new IllegalStateException("simulated registry failure");
+            }
+            return true;
+        });
+        when(server.removeRecipe(any(NamespacedKey.class))).thenAnswer(invocation -> {
+            removed.add(invocation.getArgument(0));
+            return true;
+        });
+        PotionBrewer brewer = mock(PotionBrewer.class);
+        when(server.getPotionBrewer()).thenReturn(brewer);
+        PluginManager events = mock(PluginManager.class);
+        when(server.getPluginManager()).thenReturn(events);
+        Set<NamespacedKey> known = new LinkedHashSet<>();
+        doReturn(List.of(discoveryPlayer("Online", known))).when(server).getOnlinePlayers();
+        Plugin plugin = mock(Plugin.class);
+        Logger logger = Logger.getAnonymousLogger();
+        logger.setUseParentHandlers(false);
+        List<String> logs = new ArrayList<>();
+        logger.addHandler(new Handler() {
+            @Override public void publish(LogRecord record) { logs.add(record.getMessage()); }
+            @Override public void flush() {}
+            @Override public void close() {}
+        });
+        PotionRecipes recipes = new PotionRecipes(server,
+                new NamespacedKey("spigotheights", "stature_potion"), ItemStack::new);
+        RecipeLifecycle lifecycle = new RecipeLifecycle(server, plugin, recipes, logger);
+
+        boolean enabled = assertDoesNotThrow(lifecycle::enable);
+
+        assertFalse(enabled);
+        assertEquals(List.of(recipes.shiftingKey()), removed);
+        assertTrue(known.isEmpty());
+        assertEquals(1, logs.size());
+        verifyNoInteractions(events);
+        verifyNoInteractions(brewer);
+    }
+
+    @Test
+    void cleanupFailureIsLoggedWithoutEscapingOrActivatingDiscovery() {
+        Server server = Bukkit.getServer();
+        AtomicInteger attempts = new AtomicInteger();
+        when(server.addRecipe(any(Recipe.class))).thenAnswer(invocation -> {
+            if (attempts.incrementAndGet() == 2) {
+                throw new IllegalStateException("simulated registration failure");
+            }
+            return true;
+        });
+        when(server.removeRecipe(any(NamespacedKey.class)))
+                .thenThrow(new IllegalStateException("simulated cleanup failure"));
+        PotionBrewer brewer = mock(PotionBrewer.class);
+        when(server.getPotionBrewer()).thenReturn(brewer);
+        PluginManager events = mock(PluginManager.class);
+        when(server.getPluginManager()).thenReturn(events);
+        Logger logger = Logger.getAnonymousLogger();
+        logger.setUseParentHandlers(false);
+        List<LogRecord> logs = new ArrayList<>();
+        logger.addHandler(new Handler() {
+            @Override public void publish(LogRecord record) { logs.add(record); }
+            @Override public void flush() {}
+            @Override public void close() {}
+        });
+        PotionRecipes recipes = new PotionRecipes(server,
+                new NamespacedKey("spigotheights", "stature_potion"), ItemStack::new);
+        RecipeLifecycle lifecycle = new RecipeLifecycle(server, mock(Plugin.class), recipes, logger);
+
+        boolean enabled = assertDoesNotThrow(lifecycle::enable);
+
+        assertFalse(enabled);
+        assertEquals(1, logs.size());
+        assertEquals(1, logs.getFirst().getThrown().getSuppressed().length);
+        verifyNoInteractions(events, brewer);
+    }
+
+    @Test
+    void postInsertionRegistrationFailureRemovesEveryRecipeOwnedByThisLifecycle() {
+        Server server = Bukkit.getServer();
+        NamespacedKey unrelatedKey = new NamespacedKey("minecraft", "stick");
+        java.util.Map<NamespacedKey, Recipe> registry = new HashMap<>();
+        registry.put(unrelatedKey, mock(Recipe.class));
+        AtomicInteger attempts = new AtomicInteger();
+        when(server.getRecipe(any(NamespacedKey.class))).thenAnswer(invocation ->
+                registry.get(invocation.getArgument(0)));
+        when(server.addRecipe(any(Recipe.class))).thenAnswer(invocation -> {
+            Recipe recipe = invocation.getArgument(0);
+            registry.put(((Keyed) recipe).getKey(), recipe);
+            if (attempts.incrementAndGet() == 2) {
+                throw new IllegalStateException("simulated failure after native insertion");
+            }
+            return true;
+        });
+        when(server.removeRecipe(any(NamespacedKey.class))).thenAnswer(invocation ->
+                registry.remove(invocation.getArgument(0)) != null);
+        PotionBrewer brewer = mock(PotionBrewer.class);
+        when(server.getPotionBrewer()).thenReturn(brewer);
+        when(server.getPluginManager()).thenReturn(mock(PluginManager.class));
+        Plugin plugin = mock(Plugin.class);
+        Logger logger = Logger.getAnonymousLogger();
+        logger.setUseParentHandlers(false);
+        PotionRecipes recipes = new PotionRecipes(server,
+                new NamespacedKey("spigotheights", "stature_potion"), ItemStack::new);
+        RecipeLifecycle lifecycle = new RecipeLifecycle(server, plugin, recipes, logger);
+
+        assertFalse(lifecycle.enable());
+
+        assertEquals(Set.of(unrelatedKey), registry.keySet());
+        verifyNoInteractions(brewer);
+    }
+
+    @Test
+    void disableUnregistersTheCurrentLifecycleDiscoveryListener() {
+        Server server = Bukkit.getServer();
+        PluginManager events = new PaperPluginManagerImpl(server,
+                new SimpleCommandMap(server, new HashMap<>()), null);
+        when(server.getPluginManager()).thenReturn(events);
+        when(server.addRecipe(any(Recipe.class))).thenReturn(true);
+        when(server.getPotionBrewer()).thenReturn(mock(PotionBrewer.class));
+        doReturn(List.of()).when(server).getOnlinePlayers();
+        Plugin plugin = enabledPlugin("DisableListener");
+        Set<NamespacedKey> joiningKnown = new LinkedHashSet<>();
+        Player joining = discoveryPlayer("Joining", joiningKnown);
+        PotionRecipes recipes = new PotionRecipes(server,
+                new NamespacedKey("spigotheights", "stature_potion"), ItemStack::new);
+        RecipeLifecycle lifecycle = new RecipeLifecycle(server, plugin, recipes, plugin.getLogger());
+
+        assertTrue(lifecycle.enable());
+        lifecycle.disable();
+        events.callEvent(new PlayerJoinEvent(joining, "joined"));
+
+        assertTrue(joiningKnown.isEmpty());
+    }
+
+    @Test
+    void successfulLifecycleDiscoversForOnlineAndLaterJoiningPlayersThroughRegisteredListener() {
+        Server server = Bukkit.getServer();
+        PluginManager events = new PaperPluginManagerImpl(server,
+                new SimpleCommandMap(server, new HashMap<>()), null);
+        when(server.getPluginManager()).thenReturn(events);
+        when(server.addRecipe(any(Recipe.class))).thenReturn(true);
+        when(server.getPotionBrewer()).thenReturn(mock(PotionBrewer.class));
+        Plugin plugin = mock(Plugin.class);
+        when(plugin.isEnabled()).thenReturn(true);
+        when(plugin.getName()).thenReturn("SpigotHeights");
+        when(plugin.getLogger()).thenReturn(Logger.getLogger("NativeRecipeBookTest"));
+        PluginDescriptionFile description = new PluginDescriptionFile("SpigotHeights", "test", "unused.Main");
+        when(plugin.getDescription()).thenReturn(description);
+        when(plugin.getPluginMeta()).thenReturn(description);
+        Set<NamespacedKey> onlineKnown = new LinkedHashSet<>();
+        Set<NamespacedKey> joiningKnown = new LinkedHashSet<>();
+        Player online = discoveryPlayer("Online", onlineKnown);
+        Player joining = discoveryPlayer("Joining", joiningKnown);
+        doReturn(List.of(online)).when(server).getOnlinePlayers();
+        PotionRecipes recipes = new PotionRecipes(server,
+                new NamespacedKey("spigotheights", "stature_potion"), ItemStack::new);
+        RecipeLifecycle lifecycle = new RecipeLifecycle(server, plugin, recipes, plugin.getLogger());
+
+        assertTrue(lifecycle.enable());
+        events.callEvent(new PlayerJoinEvent(joining, "joined"));
+
+        assertEquals(new LinkedHashSet<>(recipes.recipeKeys()), onlineKnown);
+        assertEquals(new LinkedHashSet<>(recipes.recipeKeys()), joiningKnown);
+    }
+
+    private static Plugin enabledPlugin(String loggerName) {
+        Plugin plugin = mock(Plugin.class);
+        when(plugin.isEnabled()).thenReturn(true);
+        when(plugin.getName()).thenReturn("SpigotHeights");
+        when(plugin.getLogger()).thenReturn(Logger.getLogger(loggerName));
+        PluginDescriptionFile description = new PluginDescriptionFile("SpigotHeights", "test", "unused.Main");
+        when(plugin.getDescription()).thenReturn(description);
+        when(plugin.getPluginMeta()).thenReturn(description);
+        return plugin;
+    }
+
+    private static Player discoveryPlayer(String name, Set<NamespacedKey> known) {
+        Player player = mock(Player.class);
+        when(player.getName()).thenReturn(name);
+        when(player.hasDiscoveredRecipe(any(NamespacedKey.class)))
+                .thenAnswer(invocation -> known.contains(invocation.getArgument(0)));
+        when(player.discoverRecipes(any())).thenAnswer(invocation -> {
+            List<NamespacedKey> requested = ((Collection<?>) invocation.getArgument(0)).stream()
+                    .map(NamespacedKey.class::cast).toList();
+            known.addAll(requested);
+            return requested.size();
+        });
+        return player;
+    }
+
+    @Test
+    void incompleteRegistrationRollsBackOnlyRecipesAddedInThisAttempt() {
+        Server server = Bukkit.getServer();
+        List<NamespacedKey> added = new ArrayList<>();
+        List<NamespacedKey> removed = new ArrayList<>();
+        NamespacedKey conflict = new NamespacedKey("spigotheights", "diminution");
+        when(server.getRecipe(conflict)).thenReturn(mock(Recipe.class));
+        when(server.addRecipe(any(Recipe.class))).thenAnswer(invocation -> {
+            added.add(((Keyed) invocation.getArgument(0)).getKey());
+            return true;
+        });
+        when(server.removeRecipe(any(NamespacedKey.class))).thenAnswer(invocation -> {
+            removed.add(invocation.getArgument(0));
+            return true;
+        });
+        PotionBrewer brewer = mock(PotionBrewer.class);
+        when(server.getPotionBrewer()).thenReturn(brewer);
+        PotionRecipes recipes = new PotionRecipes(server,
+                new NamespacedKey("spigotheights", "stature_potion"), ItemStack::new);
+
+        assertFalse(recipes.register());
+
+        assertEquals(List.of(
+                new NamespacedKey("spigotheights", "shifting_stature"),
+                new NamespacedKey("spigotheights", "growth")), added);
+        assertEquals(added, removed);
+        assertFalse(removed.contains(conflict), "A pre-existing conflict is not owned by this lifecycle");
+        verify(brewer, times(8)).addPotionMix(any());
+    }
+
+    @Test
+    void disableRemovesOnlySuccessfulCurrentLifecycleRegistrations() {
+        Server server = Bukkit.getServer();
+        List<NamespacedKey> added = new ArrayList<>();
+        List<NamespacedKey> removed = new ArrayList<>();
+        when(server.addRecipe(any(Recipe.class))).thenAnswer(invocation -> {
+            added.add(((Keyed) invocation.getArgument(0)).getKey());
+            return true;
+        });
+        when(server.removeRecipe(any(NamespacedKey.class))).thenAnswer(invocation -> {
+            removed.add(invocation.getArgument(0));
+            return true;
+        });
+        when(server.getPotionBrewer()).thenReturn(mock(PotionBrewer.class));
+        PotionRecipes recipes = new PotionRecipes(server,
+                new NamespacedKey("spigotheights", "stature_potion"), ItemStack::new);
+
+        recipes.register();
+        recipes.unregister();
+
+        assertEquals(4, added.size());
+        assertEquals(added, removed);
+        assertFalse(removed.contains(new NamespacedKey("minecraft", "unrelated")));
+    }
+
+    @Test
+    void nativeRecipeBookAutofillPlacesExactInputsAndPreservesUnrelatedInventory() {
+        Server server = Bukkit.getServer();
+        List<Recipe> registered = new ArrayList<>();
+        when(server.addRecipe(any(Recipe.class))).thenAnswer(invocation -> {
+            registered.add(invocation.getArgument(0));
+            return true;
+        });
+        when(server.getPotionBrewer()).thenReturn(mock(PotionBrewer.class));
+        when(server.getPluginManager()).thenReturn(mock(PluginManager.class));
+        PotionRecipes recipes = new PotionRecipes(server,
+                new NamespacedKey("spigotheights", "stature_potion"), ItemStack::new);
+        assertTrue(recipes.register());
+
+        for (int index = 0; index < registered.size(); index++) {
+            ShapedRecipe bukkit = (ShapedRecipe) registered.get(index);
+            net.minecraft.world.item.crafting.ShapedRecipe nativeRecipe = nativeRecipe(bukkit);
+            var holder = new net.minecraft.world.item.crafting.RecipeHolder<>(
+                    nativeRecipeKey(bukkit.getKey()), nativeRecipe);
+            var nativePlayer = mock(net.minecraft.world.entity.player.Player.class);
+            when(nativePlayer.level()).thenReturn(mock(net.minecraft.world.level.Level.class));
+            when(nativePlayer.getBukkitEntity()).thenReturn(
+                    mock(org.bukkit.craftbukkit.entity.CraftPlayer.class));
+            var inventory = new net.minecraft.world.entity.player.Inventory(nativePlayer,
+                    new net.minecraft.world.entity.EntityEquipment());
+            when(nativePlayer.getInventory()).thenReturn(inventory);
+            List<ItemStack> expectedGrid = craftingGrid(recipes, index, null);
+            for (int slot = 0; slot < expectedGrid.size(); slot++) {
+                ItemStack ingredient = expectedGrid.get(slot);
+                if (!ingredient.isEmpty()) {
+                    inventory.setItem(slot, CraftItemStack.asNMSCopy(ingredient));
+                }
+            }
+            ItemStack unrelated = new ItemStack(Material.DIAMOND, 7);
+            inventory.setItem(20, CraftItemStack.asNMSCopy(unrelated));
+            var grid = new net.minecraft.world.inventory.TransientCraftingContainer(
+                    mock(net.minecraft.world.inventory.AbstractContainerMenu.class), 3, 3, nativePlayer);
+            ItemStack displaced = new ItemStack(Material.DIRT, 3);
+            grid.setItem(0, CraftItemStack.asNMSCopy(displaced));
+            List<net.minecraft.world.inventory.Slot> gridSlots = java.util.stream.IntStream.range(0, 9)
+                    .mapToObj(slot -> new net.minecraft.world.inventory.Slot(grid, slot, 0, 0))
+                    .toList();
+            var access = new net.minecraft.recipebook.ServerPlaceRecipe.CraftingMenuAccess<
+                    net.minecraft.world.item.crafting.ShapedRecipe>() {
+                @Override
+                public void fillCraftSlotsStackedContents(
+                        net.minecraft.world.entity.player.StackedItemContents contents) {
+                    grid.fillStackedContents(contents);
+                }
+
+                @Override
+                public void clearCraftingContent() {
+                    grid.clearContent();
+                }
+
+                @Override
+                public boolean recipeMatches(net.minecraft.world.item.crafting.RecipeHolder<
+                        net.minecraft.world.item.crafting.ShapedRecipe> candidate) {
+                    return candidate.value().matches(
+                            net.minecraft.world.item.crafting.CraftingInput.of(3, 3, grid.getItems()),
+                            mock(net.minecraft.world.level.Level.class));
+                }
+            };
+
+            var action = net.minecraft.recipebook.ServerPlaceRecipe.placeRecipe(access, 3, 3,
+                    gridSlots, gridSlots, inventory, holder, false, false);
+
+            assertEquals(net.minecraft.world.inventory.RecipeBookMenu.PostPlaceAction.NOTHING, action);
+            assertEquals(expectedGrid, grid.getItems().stream().map(CraftItemStack::asBukkitCopy).toList());
+            assertTrue(java.util.stream.IntStream.range(0, 9)
+                    .allMatch(slot -> inventory.getItem(slot).isEmpty()),
+                    "Autofill must relocate rather than duplicate or consume available ingredients");
+            assertEquals(unrelated, CraftItemStack.asBukkitCopy(inventory.getItem(20)));
+            assertEquals(3, inventory.getNonEquipmentItems().stream()
+                    .map(CraftItemStack::asBukkitCopy)
+                    .filter(item -> item.getType() == Material.DIRT)
+                    .mapToInt(ItemStack::getAmount)
+                    .sum(), "Autofill must return unrelated grid contents to inventory");
+            assertTrue(nativeRecipe.matches(nativeInput(grid.getItems().stream()
+                    .map(CraftItemStack::asBukkitCopy).toList()), mock(net.minecraft.world.level.Level.class)));
+            net.minecraft.world.item.ItemStack nativeResult = nativeRecipe.assemble(nativeInput(
+                    grid.getItems().stream().map(CraftItemStack::asBukkitCopy).toList()));
+            ItemStack result = CraftItemStack.asBukkitCopy(nativeResult);
+            assertEquals(StaturePotion.values()[index], recipes.identify(result));
+            assertEquals(1, result.getAmount());
+
+            grid.setCurrentRecipe(new net.minecraft.world.item.crafting.RecipeHolder<
+                    net.minecraft.world.item.crafting.CraftingRecipe>(holder.id(), holder.value()));
+            var resultContainer = new net.minecraft.world.inventory.ResultContainer();
+            resultContainer.setRecipeUsed(holder);
+            resultContainer.setItem(0, nativeResult);
+            var resultSlot = new net.minecraft.world.inventory.ResultSlot(nativePlayer, grid,
+                    resultContainer, 0, 0, 0);
+            net.minecraft.world.item.ItemStack taken = resultSlot.remove(1);
+            resultSlot.onTake(nativePlayer, taken);
+
+            assertEquals(StaturePotion.values()[index],
+                    recipes.identify(CraftItemStack.asBukkitCopy(taken)));
+            assertTrue(resultContainer.isEmpty(), "Completed crafting must yield exactly one result");
+            assertTrue(grid.isEmpty(), "Completed crafting must consume exactly the placed ingredients");
+            assertEquals(unrelated, CraftItemStack.asBukkitCopy(inventory.getItem(20)));
+            assertEquals(3, inventory.getNonEquipmentItems().stream()
+                    .map(CraftItemStack::asBukkitCopy)
+                    .filter(item -> item.getType() == Material.DIRT)
+                    .mapToInt(ItemStack::getAmount)
+                    .sum());
+        }
+    }
+
+    @Test
+    void nativeRecipeBookAutofillRejectsInvalidPotionSubstitutionsWithoutMovingInventory() {
+        Server server = Bukkit.getServer();
+        List<Recipe> registered = new ArrayList<>();
+        when(server.addRecipe(any(Recipe.class))).thenAnswer(invocation -> {
+            registered.add(invocation.getArgument(0));
+            return true;
+        });
+        when(server.getPotionBrewer()).thenReturn(mock(PotionBrewer.class));
+        PotionRecipes recipes = new PotionRecipes(server,
+                new NamespacedKey("spigotheights", "stature_potion"), ItemStack::new);
+        assertTrue(recipes.register());
+
+        for (int index = 0; index < registered.size(); index++) {
+            ShapedRecipe bukkit = (ShapedRecipe) registered.get(index);
+            for (ItemStack invalidPotion : invalidPotionInputs(recipes, index)) {
+                assertNativeAutofillRejected(recipes, index, bukkit, invalidPotion);
+            }
+        }
+    }
+
+    private static void assertNativeAutofillRejected(PotionRecipes recipes, int recipeIndex,
+            ShapedRecipe bukkit, ItemStack invalidPotion) {
+        net.minecraft.world.item.crafting.ShapedRecipe nativeRecipe = nativeRecipe(bukkit);
+        var holder = new net.minecraft.world.item.crafting.RecipeHolder<>(
+                nativeRecipeKey(bukkit.getKey()), nativeRecipe);
+        var nativePlayer = mock(net.minecraft.world.entity.player.Player.class);
+        var inventory = new net.minecraft.world.entity.player.Inventory(nativePlayer,
+                new net.minecraft.world.entity.EntityEquipment());
+        List<ItemStack> available = craftingGrid(recipes, recipeIndex, invalidPotion);
+        for (int slot = 0; slot < available.size(); slot++) {
+            if (!available.get(slot).isEmpty()) {
+                inventory.setItem(slot, CraftItemStack.asNMSCopy(available.get(slot)));
+            }
+        }
+        inventory.setItem(20, CraftItemStack.asNMSCopy(new ItemStack(Material.DIAMOND, 7)));
+        List<ItemStack> inventoryBefore = inventory.getNonEquipmentItems().stream()
+                .map(CraftItemStack::asBukkitCopy).toList();
+        var grid = new net.minecraft.world.SimpleContainer(9);
+        List<net.minecraft.world.inventory.Slot> gridSlots = java.util.stream.IntStream.range(0, 9)
+                .mapToObj(slot -> new net.minecraft.world.inventory.Slot(grid, slot, 0, 0))
+                .toList();
+        var access = new net.minecraft.recipebook.ServerPlaceRecipe.CraftingMenuAccess<
+                net.minecraft.world.item.crafting.ShapedRecipe>() {
+            @Override
+            public void fillCraftSlotsStackedContents(
+                    net.minecraft.world.entity.player.StackedItemContents contents) {
+                grid.fillStackedContents(contents);
+            }
+
+            @Override
+            public void clearCraftingContent() {
+                grid.clearContent();
+            }
+
+            @Override
+            public boolean recipeMatches(net.minecraft.world.item.crafting.RecipeHolder<
+                    net.minecraft.world.item.crafting.ShapedRecipe> candidate) {
+                return false;
+            }
+        };
+
+        var action = net.minecraft.recipebook.ServerPlaceRecipe.placeRecipe(access, 3, 3,
+                gridSlots, gridSlots, inventory, holder, false, false);
+
+        assertEquals(net.minecraft.world.inventory.RecipeBookMenu.PostPlaceAction.PLACE_GHOST_RECIPE,
+                action, invalidPotion::toString);
+        assertTrue(grid.isEmpty());
+        assertEquals(inventoryBefore, inventory.getNonEquipmentItems().stream()
+                .map(CraftItemStack::asBukkitCopy).toList());
+    }
+
+    private static net.minecraft.resources.ResourceKey<net.minecraft.world.item.crafting.Recipe<?>> nativeRecipeKey(
+            NamespacedKey key) {
+        return net.minecraft.resources.ResourceKey.create(net.minecraft.core.registries.Registries.RECIPE,
+                net.minecraft.resources.Identifier.fromNamespaceAndPath(key.getNamespace(), key.getKey()));
+    }
+
+    @Test
+    void nativeCraftingMatchesExactInputsAndProducesAllFourAuthenticatedResults() {
+        Server server = Bukkit.getServer();
+        List<Recipe> registered = new ArrayList<>();
+        when(server.addRecipe(any(Recipe.class))).thenAnswer(invocation -> {
+            registered.add(invocation.getArgument(0));
+            return true;
+        });
+        when(server.getPotionBrewer()).thenReturn(mock(PotionBrewer.class));
+        PotionRecipes recipes = new PotionRecipes(server,
+                new NamespacedKey("spigotheights", "stature_potion"), ItemStack::new);
+        assertTrue(recipes.register());
+
+        for (int index = 0; index < registered.size(); index++) {
+            ShapedRecipe bukkit = (ShapedRecipe) registered.get(index);
+            net.minecraft.world.item.crafting.ShapedRecipe nativeRecipe = nativeRecipe(bukkit);
+            assertTrue(nativeRecipe.getIngredients().get(4).orElseThrow().isExact(),
+                    "Pinned recipe placement must retain the component-sensitive potion choice");
+            List<ItemStack> valid = craftingGrid(recipes, index, null);
+            List<ItemStack> unchanged = valid.stream().map(ItemStack::clone).toList();
+            net.minecraft.world.item.crafting.CraftingInput input = nativeInput(valid);
+            assertTrue(nativeRecipe.matches(input, mock(net.minecraft.world.level.Level.class)));
+            ItemStack result = CraftItemStack.asBukkitCopy(nativeRecipe.assemble(input));
+            assertEquals(StaturePotion.values()[index], recipes.identify(result));
+            assertEquals(1, result.getAmount());
+            assertEquals(unchanged, valid, "Matching and preview assembly must not consume the grid");
+
+            for (ItemStack invalidPotion : invalidPotionInputs(recipes, index)) {
+                assertFalse(nativeRecipe.matches(nativeInput(craftingGrid(recipes, index, invalidPotion)),
+                        mock(net.minecraft.world.level.Level.class)));
+            }
+        }
+    }
+
+    private static net.minecraft.world.item.crafting.ShapedRecipe nativeRecipe(ShapedRecipe recipe) {
+        java.util.Map<Character, net.minecraft.world.item.crafting.Ingredient> ingredients = new HashMap<>();
+        recipe.getChoiceMap().forEach((symbol, choice) ->
+                ingredients.put(symbol, CraftRecipe.toIngredient(choice, false)));
+        var pattern = net.minecraft.world.item.crafting.ShapedRecipePattern.of(ingredients, recipe.getShape());
+        return new net.minecraft.world.item.crafting.ShapedRecipe(
+                new net.minecraft.world.item.crafting.Recipe.CommonInfo(true),
+                new net.minecraft.world.item.crafting.CraftingRecipe.CraftingBookInfo(
+                        CraftRecipe.getCategory(recipe.getCategory()), recipe.getGroup()),
+                pattern, CraftItemStack.asTemplate(recipe.getResult()));
+    }
+
+    private static net.minecraft.world.item.crafting.CraftingInput nativeInput(List<ItemStack> items) {
+        return net.minecraft.world.item.crafting.CraftingInput.of(3, 3, CraftItemStack.asNMSCopy(items));
+    }
+
+    private static List<ItemStack> craftingGrid(PotionRecipes recipes, int recipeIndex, ItemStack potionOverride) {
+        String[] shape = switch (recipeIndex) {
+            case 0 -> PotionRecipes.SHIFTING_SHAPE;
+            case 1 -> PotionRecipes.GROWTH_SHAPE;
+            case 2 -> PotionRecipes.DIMINUTION_SHAPE;
+            case 3 -> PotionRecipes.RESTORATION_SHAPE;
+            default -> throw new IllegalArgumentException("Unknown recipe index");
+        };
+        List<ItemStack> items = new ArrayList<>();
+        for (String row : shape) {
+            for (char symbol : row.toCharArray()) {
+                items.add(switch (symbol) {
+                    case 'A' -> new ItemStack(Material.AMETHYST_SHARD);
+                    case 'C' -> new ItemStack(Material.CHORUS_FRUIT);
+                    case 'G' -> new ItemStack(Material.GOLD_INGOT);
+                    case 'R' -> new ItemStack(Material.RABBIT_FOOT);
+                    case 'F' -> new ItemStack(Material.FERMENTED_SPIDER_EYE);
+                    case 'U' -> new ItemStack(Material.SUGAR);
+                    case 'W', 'S' -> potionOverride != null ? potionOverride.clone()
+                            : recipeIndex == 0 ? awkwardPotion() : recipes.create(StaturePotion.SHIFTING);
+                    default -> ItemStack.empty();
+                });
+            }
+        }
+        return items;
+    }
+
+    private static List<ItemStack> invalidPotionInputs(PotionRecipes recipes, int recipeIndex) {
+        ItemStack ordinary = new ItemStack(Material.POTION);
+        ItemStack unrelated = new ItemStack(Material.POTION);
+        unrelated.editMeta(org.bukkit.inventory.meta.PotionMeta.class,
+                meta -> meta.setBasePotionType(org.bukkit.potion.PotionType.HEALING));
+        if (recipeIndex == 0) {
+            return List.of(ordinary, unrelated, recipes.create(StaturePotion.SHIFTING));
+        }
+        ItemStack nameOnly = new ItemStack(Material.POTION);
+        nameOnly.editMeta(meta -> meta.displayName(
+                net.kyori.adventure.text.Component.text(StaturePotion.SHIFTING.displayName())));
+        return List.of(ordinary, unrelated, nameOnly, recipes.create(StaturePotion.GROWTH));
+    }
+
+    private static ItemStack awkwardPotion() {
+        ItemStack awkward = new ItemStack(Material.POTION);
+        awkward.editMeta(org.bukkit.inventory.meta.PotionMeta.class,
+                meta -> meta.setBasePotionType(org.bukkit.potion.PotionType.AWKWARD));
+        return awkward;
+    }
+
+    @Test
+    void registersAllAuthenticatedResultsInMiscWithExactPotionInputs() {
+        Server server = Bukkit.getServer();
+        List<Recipe> registered = new ArrayList<>();
+        when(server.addRecipe(any(Recipe.class))).thenAnswer(invocation -> {
+            registered.add(invocation.getArgument(0));
+            return true;
+        });
+        when(server.getPotionBrewer()).thenReturn(mock(PotionBrewer.class));
+        PotionRecipes recipes = new PotionRecipes(server,
+                new NamespacedKey("spigotheights", "stature_potion"), ItemStack::new);
+
+        recipes.register();
+
+        assertEquals(4, registered.size());
+        for (int index = 0; index < StaturePotion.values().length; index++) {
+            ShapedRecipe recipe = assertInstanceOf(ShapedRecipe.class, registered.get(index));
+            assertEquals(CraftingBookCategory.MISC, recipe.getCategory());
+            assertEquals(StaturePotion.values()[index], recipes.identify(recipe.getResult()));
+            RecipeChoice.ExactChoice choice = assertInstanceOf(RecipeChoice.ExactChoice.class,
+                    recipe.getChoiceMap().get(index == 0 ? 'W' : 'S'));
+            ItemStack selected = choice.getChoices().getFirst();
+            if (index == 0) {
+                assertEquals(Material.POTION, selected.getType());
+                assertTrue(recipes.isAwkwardPotion(selected));
+                assertNull(recipes.identify(selected));
+            } else {
+                assertEquals(StaturePotion.SHIFTING, recipes.identify(selected));
+            }
+        }
+    }
+}
@@ -27,9 +27,14 @@ import org.bukkit.craftbukkit.CraftRegistry;

 /** Loads vanilla registries/tags/components using the same path as the server's own tests. */
 final class NativeRuntime {
+    private static boolean bootstrapped;
+
    private NativeRuntime() {}

-    static void bootstrap() throws Exception {
+    static synchronized void bootstrap() throws Exception {
+        if (bootstrapped) {
+            return;
+        }
        SharedConstants.tryDetectVersion();
        Bootstrap.bootStrap();
        var flags = FeatureFlags.VANILLA_SET;
@@ -53,6 +58,7 @@ final class NativeRuntime {
                    Util.backgroundExecutor(), Runnable::run).join();
            datapack.updateComponentsAndStaticRegistryTags();
            CraftRegistry.setMinecraftRegistry(layers.compositeAccess().freeze());
+            bootstrapped = true;
        }
    }
 }
@@ -28,7 +28,7 @@ class BukkitCarryTest {
    private final BukkitCarry carry = new BukkitCarry(id -> id.equals(small.id) ? small.player
            : id.equals(large.id) ? large.player : null,
            () -> new HeightSettings(0.4, 2, 0.1, 0.5, 1.5, 20), scheduled::add, logger,
-            p -> actor(p).scale, () -> 0);
+            p -> actor(p).scale);

    private Actor actor(Player p) { return p == small.player ? small : large; }
    private final class Actor {
@@ -39,18 +39,19 @@ class BukkitCarryTest {
        Entity vehicle;
        Location location;
        double scale;
-        boolean sneaking = true, online = true, dead;
+        boolean sneaking, online = true, dead, sleeping;
+        GameMode gameMode = GameMode.SURVIVAL;
        Actor(String name, double scale, double x) {
            this.scale = scale; location = new Location(world, x, 64, 0);
            player = BukkitDoubles.proxy(Player.class, (p, m, a) -> switch (m.getName()) {
                case "getUniqueId" -> id;
                case "getName" -> name;
-                case "getWorld" -> world;
+                case "getWorld" -> location.getWorld();
                case "getLocation" -> location.clone();
                case "isOnline", "isValid" -> online;
                case "isDead" -> dead;
-                case "isSleeping" -> false;
-                case "getGameMode" -> GameMode.SURVIVAL;
+                case "isSleeping" -> sleeping;
+                case "getGameMode" -> gameMode;
                case "isSneaking" -> sneaking;
                case "isInsideVehicle" -> vehicle != null;
                case "getVehicle" -> vehicle;
@@ -97,13 +98,85 @@ class BukkitCarryTest {
        event.setCancelled(cancelled); carry.interact(event); return event;
    }
    private void start() {
-        click(small, large, EquipmentSlot.HAND, false); carry.command(large.player, "accept");
+        drain();
+        click(small, large, EquipmentSlot.HAND, false);
        assertSame(large.player, small.vehicle);
    }
    private void drain() {
        List<Runnable> tasks = List.copyOf(scheduled); scheduled.clear(); tasks.forEach(Runnable::run);
    }
    @Test
+    void mountingKeepsFourBlockSameWorldAndAvailableParticipantBoundaries() {
+        large.location.setX(4.000001);
+        click(small, large, EquipmentSlot.HAND, false);
+        assertNull(small.vehicle);
+        drain();
+        large.location.setX(4);
+        start();
+        carry.command(small.player, "stop");
+        drain();
+        UUID otherWorldId = UUID.randomUUID();
+        World otherWorld = BukkitDoubles.proxy(World.class, (p, m, a) -> {
+            if (m.getName().equals("getUID")) { return otherWorldId; }
+            throw new UnsupportedOperationException(m.getName());
+        });
+        large.location.setWorld(otherWorld);
+        click(small, large, EquipmentSlot.HAND, false);
+        assertNull(small.vehicle);
+        large.location.setWorld(world);
+        for (Actor unavailable : List.of(small, large)) {
+            for (int state = 0; state < 4; state++) {
+                drain();
+                unavailable.online = state != 0;
+                unavailable.dead = state == 1;
+                unavailable.sleeping = state == 2;
+                unavailable.gameMode = state == 3 ? GameMode.SPECTATOR : GameMode.SURVIVAL;
+                click(small, large, EquipmentSlot.HAND, false);
+                assertNull(small.vehicle);
+            }
+            unavailable.online = true; unavailable.dead = false; unavailable.sleeping = false;
+            unavailable.gameMode = GameMode.SURVIVAL;
+        }
+        start();
+    }
+    @Test
+    void existingVehiclesOrPassengersOfEitherParticipantAreNeverTouched() {
+        for (Actor busy : List.of(small, large)) {
+            Actor other = busy == small ? large : small;
+            busy.vehicle = other.player;
+            click(small, large, EquipmentSlot.HAND, false);
+            assertSame(other.player, busy.vehicle);
+            assertEquals(0, nativeDismounts);
+            busy.vehicle = null;
+            drain();
+            busy.passengers.add(other.player);
+            click(small, large, EquipmentSlot.HAND, false);
+            assertEquals(List.of(other.player), busy.passengers);
+            assertNull(small.vehicle);
+            assertEquals(0, nativeDismounts);
+            busy.passengers.clear();
+            drain();
+        }
+        start();
+        // Additional passengers/mounts involving either occupied role are rejected.
+        UUID extraId = UUID.randomUUID();
+        Entity extra = BukkitDoubles.proxy(Entity.class, (p, m, a) -> {
+            if (m.getName().equals("getUniqueId")) { return extraId; }
+            throw new UnsupportedOperationException(m.getName());
+        });
+        var extraRider = new org.bukkit.event.entity.EntityMountEvent(extra, large.player);
+        carry.mountEvent(extraRider);
+        assertTrue(extraRider.isCancelled());
+    }
+    @Test
+    void removedConsentActionsOnlyShowStopUsage() {
+        for (String action : List.of("accept", "decline", "unknown")) {
+            carry.command(large.player, action);
+            assertEquals("Usage: /heights carry stop", large.messages.getLast());
+            assertNull(small.vehicle);
+        }
+    }
+    @Test
    void startsWithoutSafeGroundAndNativeStopDoesNotTeleportOrResetMotion() {
        start();
        Location before = small.location.clone();
@@ -195,7 +268,7 @@ class BukkitCarryTest {
    }
    @Test
    void effectiveScaleChangesUseNativeCleanupAndRespectRefusals() {
-        start(); small.scale = 0.9; dismountAllowed = false;
+        start(); small.scale = 0.95; dismountAllowed = false;
        carry.tick();
        assertSame(large.player, small.vehicle);
        dismountAllowed = true; carry.tick();
@@ -225,7 +298,7 @@ class BukkitCarryTest {
    @Test
    void partialNativeMountIsTrackedUntilItsInvalidRelationshipCanBeDetached() {
        invalidMountTopology = true; dismountAllowed = false;
-        click(small, large, EquipmentSlot.HAND, false); carry.command(large.player, "accept");
+        click(small, large, EquipmentSlot.HAND, false);
        assertSame(large.player, small.vehicle);
        assertEquals(1, nativeDismounts, "Attempt native cleanup of a partially successful invalid mount");
        assertFalse(large.messages.getLast().contains("started"));
@@ -273,15 +346,13 @@ class BukkitCarryTest {
        assertEquals("No active ride.", large.messages.getLast());
    }
    @Test
-    void onlySneakingUncancelledMainHandRequestsMountAfterAcceptance() {
+    void onlyUncancelledMainHandSmallerInitiatorsMountImmediately() {
        click(small, large, EquipmentSlot.HAND, true);
        click(small, large, EquipmentSlot.OFF_HAND, false);
-        small.sneaking = false; click(small, large, EquipmentSlot.HAND, false); small.sneaking = true;
-        assertTrue(large.messages.isEmpty());
-        assertTrue(click(small, large, EquipmentSlot.HAND, false).isCancelled());
-        assertFalse(large.messages.isEmpty());
+        click(large, small, EquipmentSlot.HAND, false);
+        assertNull(small.vehicle);
        assertTrue(large.passengers.isEmpty());
-        carry.command(large.player, "accept");
+        assertTrue(click(small, large, EquipmentSlot.HAND, false).isCancelled());
        assertSame(large.player, small.vehicle);
        assertEquals(List.of(small.player), large.passengers);
        carry.command(large.player, "stop");
@@ -5,16 +5,24 @@ import org.junit.jupiter.api.Test;

 class CarryPolicyTest {
    @Test
-    void requiresThreeCurrentStepsWithDecimalBoundaryTolerance() {
-        assertTrue(CarryPolicy.eligible(1.0, 0.7, 0.1));
-        assertTrue(CarryPolicy.eligible(0.7, 0.4, 0.1));
-        assertFalse(CarryPolicy.eligible(1.0, 0.700001, 0.1));
-        assertFalse(CarryPolicy.eligible(1.0, 0.7, 0.2));
+    void usesIndependentGapWithDecimalBoundaryTolerance() {
+        assertTrue(CarryPolicy.eligible(1.0, 0.9, 0.1));
+        assertTrue(CarryPolicy.eligible(0.5, 0.4, 0.1));
+        assertFalse(CarryPolicy.eligible(1.0, 0.900001, 0.1));
+        assertFalse(CarryPolicy.eligible(1.0, 0.9, 0.2));
+        assertTrue(CarryPolicy.eligible(1.0, 0.8, 0.2));
        assertFalse(CarryPolicy.eligible(0.7, 1.0, 0.1));
-        for (double invalid : new double[] {0, -1, Double.NaN, Double.POSITIVE_INFINITY}) {
+    }
+
+    @Test
+    void zeroGapStillRequiresStrictlyLargerCarrierAndAllInputsMustBeValid() {
+        assertTrue(CarryPolicy.eligible(1, Math.nextDown(1.0), 0));
+        assertFalse(CarryPolicy.eligible(1, 1, 0));
+        assertFalse(CarryPolicy.eligible(0.9, 1, 0));
+        for (double invalid : new double[] {0, -1, Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY}) {
            assertFalse(CarryPolicy.eligible(invalid, 0.4, 0.1));
            assertFalse(CarryPolicy.eligible(1, invalid, 0.1));
-            assertFalse(CarryPolicy.eligible(1, 0.4, invalid));
+            if (invalid != 0) { assertFalse(CarryPolicy.eligible(1, 0.4, invalid)); }
        }
    }
 }
@@ -10,10 +10,10 @@ class CarryServiceTest {
            small, new CarryService.State(0.4, true, true),
            large, new CarryService.State(1, true, true),
            third, new CarryService.State(2, true, true)));
-    private long now;
-    private double step = 0.1;
+    private double gap = 0.1;
    private boolean near = true, mountAllowed = true, stopAllowed = true, attached;
    private int mounts, stops;
+    private Runnable onMount = () -> {};
    private UUID mountedCarrier, mountedRider;
    private final List<String> messages = new ArrayList<>();
    private final CarryService service = new CarryService(new CarryService.Port() {
@@ -21,6 +21,7 @@ class CarryServiceTest {
        public boolean nearby(UUID a, UUID b) { return near; }
        public boolean mount(UUID carrier, UUID rider) {
            mounts++; mountedCarrier = carrier; mountedRider = rider;
+            onMount.run();
            attached = mountAllowed; return mountAllowed;
        }
        public boolean attached(UUID carrier, UUID rider) { return attached; }
@@ -31,50 +32,80 @@ class CarryServiceTest {
            return stopAllowed;
        }
        public void message(UUID id, String text) { messages.add(text); }
-    }, () -> step, () -> now);
+    }, () -> gap);

    @Test
-    void consentExpiresAtThirtySecondsAndRechecksLiveConditions() {
-        service.request(small, large);
-        now = 30_000;
-        assertFalse(service.accept(large).contains("started"));
-        assertEquals(0, mounts);
-        for (int change = 0; change < 4; change++) {
-            near = true; step = 0.1;
-            states.put(small, new CarryService.State(0.4, true, true));
-            service.request(small, large);
-            switch (change) {
-                case 0 -> near = false;
-                case 1 -> step = 0.3;
-                case 2 -> states.put(small, new CarryService.State(0.8, true, true));
-                case 3 -> states.put(small, new CarryService.State(0.4, false, true));
-                default -> throw new AssertionError();
-            }
-            assertFalse(service.accept(large).contains("started"));
-            assertEquals(0, mounts);
-        }
-        near = true; step = 0.1;
-        states.put(small, new CarryService.State(0.4, true, true));
-        service.request(small, large);
-        now += 29_999;
-        assertTrue(service.accept(large).contains("started"));
+    void shutdownDuringNativeMountDetachesInsteadOfStartingANewRide() {
+        onMount = () -> service.close();
+        String result = service.ride(small, large);
+        assertFalse(result.contains("started"));
+        assertEquals(1, stops);
+        assertFalse(service.involved(small));
+        assertFalse(attached);
    }

    @Test
-    void eitherParticipantCanWithdrawPendingConsentWithStop() {
-        for (UUID caller : List.of(small, large)) {
-            assertTrue(service.request(small, large).contains("sent"));
-            assertTrue(service.stop(caller).contains("cancelled"));
-            assertTrue(service.accept(large).contains("No pending"));
+    void shutdownDuringMountStillReportsRefusedNativeDetachmentHonestly() {
+        stopAllowed = false;
+        onMount = () -> service.close();
+        String result = service.ride(small, large);
+        assertFalse(result.contains("started"));
+        assertTrue(result.contains("refused"));
+        assertTrue(service.involved(small));
+        assertTrue(attached);
+        assertEquals(1, service.close());
+        stopAllowed = true;
+        assertEquals(0, service.close());
+    }
+
+    @Test
+    void synchronousMountCallbacksCannotStartAnotherRideForEitherParticipant() {
+        onMount = () -> {
+            onMount = () -> {};
+            assertFalse(service.ride(small, third).contains("started"));
+            assertFalse(service.ride(large, third).contains("started"));
+        };
+        assertTrue(service.ride(small, large).contains("started"));
+        assertEquals(1, mounts);
+        assertEquals(large, mountedCarrier);
+        assertEquals(small, mountedRider);
+        assertFalse(service.involved(third));
+    }
+
+    @Test
+    void immediateRideIsSmallerInitiatedOnlyAndChecksCurrentEligibility() {
+        assertFalse(service.ride(large, small).contains("started"));
+        assertEquals(0, mounts);
+        for (int change = 0; change < 5; change++) {
+            near = true; gap = 0.1;
+            states.put(small, new CarryService.State(0.4, true, true));
+            switch (change) {
+                case 0 -> near = false;
+                case 1 -> gap = 0.7;
+                case 2 -> states.put(small, new CarryService.State(0.95, true, true));
+                case 3 -> states.put(small, new CarryService.State(0.4, false, true));
+                case 4 -> states.remove(small);
+                default -> throw new AssertionError();
+            }
+            assertFalse(service.ride(small, large).contains("started"));
            assertEquals(0, mounts);
        }
+        near = true; gap = 0.1;
+        states.put(small, new CarryService.State(0.9, true, true));
+        assertTrue(service.ride(small, large).contains("started"));
+        assertEquals(1, mounts);
+        assertEquals(large, mountedCarrier);
+        assertEquals(small, mountedRider);
+        assertTrue(service.involved(small));
+        assertTrue(service.involved(large));
+        assertTrue(messages.stream().noneMatch(message -> message.contains("request")));
    }

    @Test
    void automaticNativeRefusalIsReportedOnceRatherThanSilentlyRetried() {
-        service.request(small, large); service.accept(large);
+        service.ride(small, large);
        messages.clear();
-        states.put(small, new CarryService.State(0.9, true, true));
+        states.put(small, new CarryService.State(0.95, true, true));
        stopAllowed = false;
        service.tick(); service.tick();
        assertEquals(2, messages.size(), "Notify both participants once, not every tick");
@@ -84,51 +115,35 @@ class CarryServiceTest {
        assertFalse(service.involved(small));
    }

-    @Test
-    void reservesOneRequestPerPlayerAndDeclineReleasesBoth() {
-        assertTrue(service.request(small, large).contains("sent"));
-        assertFalse(service.request(third, large).contains("sent"));
-        assertFalse(service.request(small, third).contains("sent"));
-        assertTrue(service.decline(large).contains("declined"));
-        assertTrue(service.request(small, third).contains("sent"));
-        now = 30_000;
-        service.tick();
-        assertTrue(service.request(small, large).contains("sent"));
-    }
-
    @Test
    void rejectsExistingPassengersVehiclesAndActiveRidesAndFailedMounts() {
        for (UUID busy : List.of(small, large)) {
            CarryService.State before = states.get(busy);
            states.put(busy, new CarryService.State(before.scale(), true, false));
-            assertFalse(service.request(small, large).contains("sent"));
+            assertFalse(service.ride(small, large).contains("started"));
+            assertEquals(0, mounts);
            states.put(busy, before);
        }
-        service.request(small, large);
-        states.put(small, new CarryService.State(0.4, true, false));
-        assertFalse(service.accept(large).contains("started"));
-        states.put(small, new CarryService.State(0.4, true, true));
-        service.request(small, large);
        mountAllowed = false;
-        assertFalse(service.accept(large).contains("started"));
+        assertTrue(service.ride(small, large).contains("refused"));
        assertFalse(service.involved(small));
        mountAllowed = true;
-        service.request(small, large);
-        service.accept(large);
-        assertFalse(service.request(third, large).contains("sent"));
-        assertFalse(service.request(small, third).contains("sent"));
+        assertTrue(service.ride(small, large).contains("started"));
+        assertFalse(service.ride(third, large).contains("started"));
+        assertFalse(service.ride(small, third).contains("started"));
+        assertFalse(service.ride(large, third).contains("started"));
+        assertEquals(2, mounts);
    }

    @Test
    void lossOfEligibilityAttemptsNativeStopAndRefusedVoluntaryStopsRemainAccuratelyTracked() {
-        service.request(small, large); service.accept(large);
+        service.ride(small, large);
        stopAllowed = false;
-        states.put(small, new CarryService.State(0.9, true, true));
+        states.put(small, new CarryService.State(0.95, true, true));
        service.tick();
        assertEquals(1, stops);
        assertTrue(service.involved(small));
        assertTrue(service.stop(large).contains("refused"));
-        // No pending rescue job: if eligibility recovers, a voluntary stop can be requested again.
        states.put(small, new CarryService.State(0.4, true, true));
        stopAllowed = true;
        service.tick();
@@ -139,31 +154,30 @@ class CarryServiceTest {
    }

    @Test
-    void lifecycleClearsRequestsAndRidesAndReportsUnresolvedDisable() {
-        service.request(small, large);
+    void lifecycleCleansRidesAndReportsUnresolvedDisable() {
+        service.ride(small, large);
        assertTrue(service.cleanup(small));
-        assertTrue(service.accept(large).contains("No pending"));
-        service.request(small, large); service.accept(large);
+        service.ride(small, large);
        assertTrue(service.cleanup(large));
        assertFalse(service.involved(small));
-        service.request(small, large); service.accept(large);
+        service.ride(small, large);
        stopAllowed = false;
        assertFalse(service.cleanup(small));
        assertEquals(1, service.close());
        assertTrue(service.involved(small));
-        assertFalse(service.request(third, large).contains("sent"));
+        assertFalse(service.ride(third, large).contains("started"));
        stopAllowed = true;
        assertEquals(0, service.close());
    }

    @Test
    void unavailableOrDetachedParticipantsTriggerCleanup() {
-        service.request(small, large); service.accept(large);
+        service.ride(small, large);
        attached = false;
        service.tick();
        assertEquals(1, stops);
        assertFalse(service.involved(large));
-        service.request(small, large); service.accept(large);
+        service.ride(small, large);
        states.put(large, new CarryService.State(1, false, false));
        service.tick();
        assertEquals(2, stops);
@@ -171,19 +185,13 @@ class CarryServiceTest {
    }

    @Test
-    void eitherDirectionRequiresOtherPlayersExplicitConsent() {
-        for (boolean pickup : new boolean[] {false, true}) {
-            UUID sender = pickup ? large : small, recipient = pickup ? small : large;
-            assertTrue(service.request(sender, recipient).contains("sent"));
-            assertEquals(0, mounts);
-            assertTrue(service.accept(sender).contains("No pending"));
-            assertTrue(service.accept(recipient).contains("started"));
-            assertEquals(large, mountedCarrier);
-            assertEquals(small, mountedRider);
-            assertTrue(service.involved(small));
-            assertTrue(service.involved(large));
-            assertTrue(service.stop(sender).contains("ended"));
-            mounts = 0;
+    void eitherParticipantCanStopImmediatelyWithoutApprovalOrRemountCooldown() {
+        for (UUID caller : List.of(small, large)) {
+            assertTrue(service.ride(small, large).contains("started"));
+            assertTrue(service.stop(caller).contains("ended"));
+            assertFalse(service.involved(small));
        }
+        assertEquals(2, mounts);
+        assertEquals(2, stops);
    }
 }
@@ -13,6 +13,38 @@ class HeightSettingsTest {
        assertEquals(16, settings.randomStepCount());
    }

+    @Test
+    void missingGapDefaultsIndependentlyAndBoundsKeepExplicitGap() throws Exception {
+        var config = new org.bukkit.configuration.file.YamlConfiguration();
+        config.loadFromString(java.nio.file.Files.readString(java.nio.file.Path.of("src/main/resources/config.yml")));
+        assertEquals(0.1, SpigotHeightsPlugin.loadSettings(config).carryMinimumScaleGap());
+        config.set("carry.minimum-scale-gap", null);
+        config.set("height.adjustment-step", 0.25);
+        assertEquals(0.1, SpigotHeightsPlugin.loadSettings(config).carryMinimumScaleGap());
+        for (double gap : new double[] {0, 0.2, 1.5}) {
+            config.set("carry.minimum-scale-gap", gap);
+            HeightSettings settings = SpigotHeightsPlugin.loadSettings(config);
+            assertEquals(gap, settings.carryMinimumScaleGap());
+            assertEquals(0.25, settings.adjustmentStep());
+            var live = new LiveHeightSettings(settings, ignored -> {});
+            live.setBound("max", 3);
+            assertEquals(gap, live.get().carryMinimumScaleGap());
+            assertEquals(0.25, live.get().adjustmentStep());
+        }
+    }
+
+    @Test
+    void rejectsInvalidCarryGapInExistingConfigLoader() throws Exception {
+        var config = new org.bukkit.configuration.file.YamlConfiguration();
+        config.loadFromString(java.nio.file.Files.readString(java.nio.file.Path.of("src/main/resources/config.yml")));
+        for (Object invalid : new Object[] {-0.1, Double.NaN, Double.POSITIVE_INFINITY,
+                Double.NEGATIVE_INFINITY, "garbage", true, java.util.List.of(0.1)}) {
+            config.set("carry.minimum-scale-gap", invalid);
+            assertThrows(IllegalArgumentException.class, () -> SpigotHeightsPlugin.loadSettings(config),
+                    "Invalid carry gap must fail startup validation: " + invalid);
+        }
+    }
+
    @Test
    void rejectsInvalidRangesAndNumbers() {
        assertThrows(IllegalArgumentException.class,
@@ -51,19 +51,26 @@ class HeightsCommandTest {
        for (String action : List.of("accept", "decline", "stop")) {
            command.onCommand(player, null, "heights", new String[] {"CaRrY", action.toUpperCase()});
        }
-        assertEquals(List.of("accept", "decline", "stop"), actions);
+        assertEquals(List.of("stop"), actions);
+        assertTrue(messages.stream().allMatch(message -> message.equals("Usage: /heights carry stop")));
        for (String[] args : new String[][] {{"carry"}, {"carry", "throw"}, {"carry", "stop", "extra"},
                {"player", "Steve", "0.5"}, {"settings"}}) {
            command.onCommand(player, null, "heights", args);
        }
        command.onCommand(sender(true), null, "heights", new String[] {"carry", "accept"});
-        assertEquals(3, actions.size());
+        assertEquals(1, actions.size());
        assertEquals(List.of("carry"), complete(player, ""));
-        assertEquals(List.of("accept", "decline", "stop"), complete(player, "carry", ""));
+        assertEquals(List.of("stop"), complete(player, "carry", ""));
+        assertEquals(List.of(), complete(player, "carry", "a"));
+        assertEquals(List.of(), complete(player, "carry", "d"));
        assertEquals(List.of("stop"), complete(player, "carry", "s"));
        assertEquals(List.of(), complete(player, "player", ""));
        org.bukkit.configuration.file.YamlConfiguration yaml = org.bukkit.configuration.file.YamlConfiguration
                .loadConfiguration(new java.io.File("src/main/resources/plugin.yml"));
+        assertTrue(yaml.getString("commands.heights.usage").contains("carry stop"));
+        assertTrue(!yaml.getString("commands.heights.usage").contains("accept"));
+        assertTrue(!yaml.getString("commands.heights.usage").contains("decline"));
+        assertTrue(!yaml.getString("commands.heights.description").contains("consensual"));
        assertEquals(null, yaml.getString("commands.heights.permission"));
        assertEquals("op", yaml.getString("permissions.spigotheights.admin.default"));
    }
@@ -0,0 +1,78 @@
+package games.dmg.spigotheights;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.io.DataInputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.jar.JarFile;
+import org.junit.jupiter.api.Test;
+import org.yaml.snakeyaml.Yaml;
+
+class PurpurDistributionTest {
+    @Test
+    void packagesNewNameWithoutChangingRuntimeIdentityOrBundlingTheApi() throws Exception {
+        Path artifact = Path.of(System.getProperty("distribution.jar"));
+        String version = System.getProperty("distribution.version");
+        assertEquals("purpur-heights-" + version + ".jar", artifact.getFileName().toString());
+        try (var jar = new JarFile(artifact.toFile())) {
+            Map<?, ?> metadata = new Yaml().load(jar.getInputStream(jar.getJarEntry("plugin.yml")));
+            assertEquals(version, metadata.get("version"));
+            assertEquals("SpigotHeights", metadata.get("name"), "Retain the data directory and persistent namespace");
+            assertEquals("games.dmg.spigotheights.SpigotHeightsPlugin", metadata.get("main"));
+            assertTrue(((Map<?, ?>) metadata.get("permissions")).containsKey("spigotheights.admin"));
+            assertFalse(jar.stream().anyMatch(entry -> entry.getName().startsWith("org/bukkit/")
+                || entry.getName().startsWith("org/purpurmc/") || entry.getName().endsWith("Test.class")));
+        }
+    }
+
+    @Test
+    void packagesTheIntegratedRecipeDiscoveryLifecycle() throws Exception {
+        try (var jar = new JarFile(System.getProperty("distribution.jar"))) {
+            String plugin = classConstants(jar, "games/dmg/spigotheights/SpigotHeightsPlugin.class");
+            String lifecycle = classConstants(jar, "games/dmg/spigotheights/RecipeLifecycle.class");
+            String discovery = classConstants(jar, "games/dmg/spigotheights/RecipeDiscovery.class");
+            String recipes = classConstants(jar, "games/dmg/spigotheights/PotionRecipes.class");
+            assertTrue(plugin.contains("RecipeLifecycle"));
+            assertTrue(lifecycle.contains("getOnlinePlayers"));
+            assertTrue(lifecycle.contains("registerEvents"));
+            assertTrue(discovery.contains("discoverRecipes"));
+            assertTrue(discovery.contains("hasDiscoveredRecipe"));
+            assertTrue(recipes.contains("CraftingBookCategory"));
+            assertTrue(recipes.contains("AWKWARD"));
+            assertTrue(recipes.contains("RecipeChoice$ExactChoice"));
+            assertTrue(recipes.contains("removeRecipe"));
+        }
+    }
+
+    private static String classConstants(JarFile jar, String entry) throws Exception {
+        assertNotNull(jar.getJarEntry(entry), entry);
+        return new String(jar.getInputStream(jar.getJarEntry(entry)).readAllBytes(), StandardCharsets.ISO_8859_1);
+    }
+
+    @Test
+    void pluginBytecodeTargetsJava25() throws Exception {
+        try (var jar = new JarFile(System.getProperty("distribution.jar"));
+             var bytecode = new DataInputStream(jar.getInputStream(
+                 jar.getJarEntry("games/dmg/spigotheights/SpigotHeightsPlugin.class")))) {
+            assertEquals(0xCAFEBABE, bytecode.readInt());
+            bytecode.readUnsignedShort();
+            assertEquals(69, bytecode.readUnsignedShort());
+        }
+    }
+
+    @Test
+    void releaseAndCiAgreeWithThePurpurDistributionNameAndToolchain() throws Exception {
+        String build = Files.readString(Path.of("build.gradle.kts"));
+        assertTrue(build.contains("purpur-api:26.2.build.2618-stable"));
+        assertFalse(build.contains("org.spigotmc:spigot-api"));
+        for (String workflow : new String[] {"ci.yml", "release.yml"}) {
+            String content = Files.readString(Path.of(".gitea/workflows", workflow));
+            assertTrue(content.contains("java-version: 25"));
+            assertTrue(content.contains("purpur-heights-"), workflow);
+            assertFalse(content.contains("spigot-heights-"), workflow);
+        }
+    }
+}
@@ -0,0 +1,143 @@
+package games.dmg.spigotheights;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Handler;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.junit.jupiter.api.Test;
+
+class RecipeDiscoveryTest {
+    private final List<NamespacedKey> keys = List.of(
+            new NamespacedKey("spigotheights", "shifting_stature"),
+            new NamespacedKey("spigotheights", "growth"),
+            new NamespacedKey("spigotheights", "diminution"),
+            new NamespacedKey("spigotheights", "restoration"));
+
+    @Test
+    void allAlreadyOnlinePlayersReceiveEveryUnknownRecipe() {
+        Set<NamespacedKey> firstKnown = new LinkedHashSet<>();
+        Set<NamespacedKey> secondKnown = new LinkedHashSet<>();
+        RecipeDiscovery discovery = new RecipeDiscovery(keys, Logger.getAnonymousLogger());
+
+        discovery.discoverAll(List.of(
+                player("First", firstKnown, new ArrayList<>(), false),
+                player("Second", secondKnown, new ArrayList<>(), false)));
+
+        assertEquals(new LinkedHashSet<>(keys), firstKnown);
+        assertEquals(new LinkedHashSet<>(keys), secondKnown);
+    }
+
+    @Test
+    void joiningPlayerReceivesEveryUnknownRecipe() {
+        Set<NamespacedKey> known = new LinkedHashSet<>();
+        List<List<NamespacedKey>> awards = new ArrayList<>();
+        Player player = player("Joiner", known, awards, false);
+        RecipeDiscovery discovery = new RecipeDiscovery(keys, Logger.getAnonymousLogger());
+
+        discovery.onJoin(new PlayerJoinEvent(player, "joined"));
+
+        assertEquals(List.of(keys), awards);
+        assertEquals(new LinkedHashSet<>(keys), known);
+    }
+
+    @Test
+    void onePlayerExceptionIsLoggedWithoutBlockingOthersAndRetriesLater() {
+        Set<NamespacedKey> failedKnown = new LinkedHashSet<>();
+        Set<NamespacedKey> healthyKnown = new LinkedHashSet<>();
+        AtomicBoolean firstAttempt = new AtomicBoolean(true);
+        List<String> warnings = new ArrayList<>();
+        Logger logger = logger(warnings);
+        Player failing = BukkitDoubles.proxy(Player.class, (proxy, method, args) -> switch (method.getName()) {
+            case "getName" -> "Failing";
+            case "hasDiscoveredRecipe" -> failedKnown.contains(args[0]);
+            case "discoverRecipes" -> {
+                if (firstAttempt.getAndSet(false)) {
+                    throw new IllegalStateException("simulated discovery failure");
+                }
+                List<NamespacedKey> requested = ((Collection<?>) args[0]).stream()
+                        .map(NamespacedKey.class::cast).toList();
+                failedKnown.addAll(requested);
+                yield requested.size();
+            }
+            default -> throw new UnsupportedOperationException(method.getName());
+        });
+        RecipeDiscovery discovery = new RecipeDiscovery(keys, logger);
+
+        assertDoesNotThrow(() -> discovery.discover(failing));
+        discovery.discover(player("Healthy", healthyKnown, new ArrayList<>(), false));
+        discovery.discover(failing);
+
+        assertEquals(new LinkedHashSet<>(keys), healthyKnown);
+        assertEquals(new LinkedHashSet<>(keys), failedKnown);
+        assertEquals(1, warnings.size());
+    }
+
+    @Test
+    void missingPostconditionIsLoggedAndOnlyMissingRecipesRetryLater() {
+        Set<NamespacedKey> known = new LinkedHashSet<>();
+        List<List<NamespacedKey>> awards = new ArrayList<>();
+        List<String> warnings = new ArrayList<>();
+        Logger logger = logger(warnings);
+        RecipeDiscovery discovery = new RecipeDiscovery(keys, logger);
+
+        discovery.discover(player("Ada", known, awards, true));
+        discovery.discover(player("Ada", known, awards, false));
+
+        assertEquals(List.of(keys, List.of(keys.getLast())), awards);
+        assertEquals(1, warnings.size());
+        assertEquals(new LinkedHashSet<>(keys), known);
+    }
+
+    @Test
+    void discoversOnlyUnknownRecipesAndRepeatedDiscoveryIsSilent() {
+        Set<NamespacedKey> known = new LinkedHashSet<>();
+        List<List<NamespacedKey>> awards = new ArrayList<>();
+        Player player = player("Ada", known, awards, false);
+        RecipeDiscovery discovery = new RecipeDiscovery(keys, Logger.getAnonymousLogger());
+
+        discovery.discover(player);
+        discovery.discover(player);
+
+        assertEquals(List.of(keys), awards);
+        assertEquals(new LinkedHashSet<>(keys), known);
+    }
+
+    private static Logger logger(List<String> warnings) {
+        Logger logger = Logger.getAnonymousLogger();
+        logger.setUseParentHandlers(false);
+        logger.addHandler(new Handler() {
+            @Override public void publish(LogRecord record) { warnings.add(record.getMessage()); }
+            @Override public void flush() {}
+            @Override public void close() {}
+        });
+        return logger;
+    }
+
+    static Player player(String name, Set<NamespacedKey> known, List<List<NamespacedKey>> awards,
+            boolean omitLastAward) {
+        return BukkitDoubles.proxy(Player.class, (proxy, method, args) -> switch (method.getName()) {
+            case "getName" -> name;
+            case "hasDiscoveredRecipe" -> known.contains(args[0]);
+            case "discoverRecipes" -> {
+                List<NamespacedKey> requested = ((Collection<?>) args[0]).stream()
+                        .map(NamespacedKey.class::cast).toList();
+                awards.add(requested);
+                int limit = omitLastAward ? Math.max(0, requested.size() - 1) : requested.size();
+                known.addAll(requested.subList(0, limit));
+                yield limit;
+            }
+            default -> throw new UnsupportedOperationException(method.getName());
+        });
+    }
+}
Author	SHA1	Message	Date
dmg	a6c80e7ac9	feat(heights): discover stature potion recipes Release / release (push) Successful in 5m12s Details CI / build (push) Successful in 1m7s Details	2026-09-20 14:30:46 -04:00
dmg	960e8891a8	feat(heights): adopt Purpur distribution naming Release / release (push) Successful in 6m47s Details CI / build (push) Successful in 2m21s Details BREAKING CHANGE: New release assets use purpur-heights-<version>.jar. Runtime SpigotHeights identity, saved player data, permissions and potion keys remain unchanged. Replace the old JAR instead of loading both distributions.	2026-09-12 13:13:44 -04:00
dmg	a949fd99c4	feat(heights): mount larger players without consent Release / release (push) Successful in 4m6s Details CI / build (push) Successful in 2m7s Details	2026-09-12 08:35:29 -04:00