feat(pack): export native delivery and client statuses

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

@@ -186,6 +186,12 @@ public final class FantasyStickPlugin extends JavaPlugin {
     private java.util.concurrent.CompletionStage<Void> switchAuditDrain = java.util.concurrent.CompletableFuture.completedFuture(null);
     private games.dmg.fantasystick.events.SwitchConfigEventBridge switchConfigEvents;
     private java.util.concurrent.CompletionStage<Void> switchConfigAuditDrain = java.util.concurrent.CompletableFuture.completedFuture(null);
+    private games.dmg.fantasystick.events.RoleplayAvailabilityEventBridge roleplayAvailabilityEvents;
+    private java.util.concurrent.CompletionStage<Void> roleplayAuditDrain = java.util.concurrent.CompletableFuture.completedFuture(null);
+    private games.dmg.fantasystick.events.PartyCapacityEventBridge partyCapacityEvents;
+    private java.util.concurrent.CompletionStage<Void> partyCapacityAuditDrain = java.util.concurrent.CompletableFuture.completedFuture(null);
+    private games.dmg.fantasystick.events.SheetResourcePackEventBridge sheetResourcePackEvents;
+    private java.util.concurrent.CompletionStage<Void> sheetResourcePackAuditDrain = java.util.concurrent.CompletableFuture.completedFuture(null);
     private games.dmg.fantasystick.events.CharacterIdentityEventBridge identityAuditEvents;
     private java.util.concurrent.CompletionStage<Void> identityAuditDrain = java.util.concurrent.CompletableFuture.completedFuture(null);
     private games.dmg.fantasystick.events.EquipmentEventBridge equipmentAuditEvents;
@@ -809,6 +815,19 @@ public final class FantasyStickPlugin extends JavaPlugin {
                     eventLog::emit, Clock.systemUTC(), getDataFolder().toPath(), sessions,
                     failure -> getLogger().log(Level.WARNING, "Switch configuration event intent failed", failure));
                 admin.attachSwitchConfigEvents(switchConfigEvents);
+                roleplayAvailabilityEvents = new games.dmg.fantasystick.events.RoleplayAvailabilityEventBridge(
+                    eventLog::emit, Clock.systemUTC(), getDataFolder().toPath(), sessions,
+                    failure -> getLogger().log(Level.WARNING, "Roleplay availability event intent failed", failure));
+                admin.attachRoleplayAvailabilityEvents(roleplayAvailabilityEvents);
+                partyCapacityEvents = new games.dmg.fantasystick.events.PartyCapacityEventBridge(
+                    eventLog::emit, Clock.systemUTC(), getDataFolder().toPath(), sessions,
+                    failure -> getLogger().log(Level.WARNING, "Party capacity event intent failed", failure));
+                admin.attachPartyCapacityEvents(partyCapacityEvents);
+                sheetResourcePackEvents = new games.dmg.fantasystick.events.SheetResourcePackEventBridge(
+                    eventLog::emit, Clock.systemUTC(), getDataFolder().toPath(), sessions,
+                    failure -> getLogger().log(Level.WARNING, "Sheet resource-pack event intent failed", failure));
+                admin.attachSheetResourcePackEvents(sheetResourcePackEvents);
+                sheetResourcePack.attachEvents(sheetResourcePackEvents);
                 var identitySessions = sessions;
                 identityAuditEvents = new games.dmg.fantasystick.events.CharacterIdentityEventBridge(
                     eventLog::emit, Clock.systemUTC(), getDataFolder().toPath(),
@@ -836,7 +855,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
                     id -> presentation.snapshot().get(id),sessionAuditEvents,eventLog::emit,Clock.systemUTC());
                 getServer().getPluginManager().registerEvents(messageAuditEvents,this);
             } catch (java.io.IOException failure) {
-                eventLog = null; eventCapture = null; downedEvents = null; rareEvents = null; bookEvents = null; progressionEvents = null; reviveEvents = null; adminRevivalEvents = null; partyAuditEvents = null; combatRewardEvents = null; coinEvents = null; sessionAuditEvents = null; nutritionAuditEvents = null; switchAuditEvents = null; switchConfigEvents = null; identityAuditEvents = null; equipmentAuditEvents = null; sessionRecoveryAuditEvents = null; messageAuditEvents = null;
+                eventLog = null; eventCapture = null; downedEvents = null; rareEvents = null; bookEvents = null; progressionEvents = null; reviveEvents = null; adminRevivalEvents = null; partyAuditEvents = null; combatRewardEvents = null; coinEvents = null; sessionAuditEvents = null; nutritionAuditEvents = null; switchAuditEvents = null; switchConfigEvents = null; roleplayAvailabilityEvents = null; partyCapacityEvents = null; sheetResourcePackEvents = null; identityAuditEvents = null; equipmentAuditEvents = null; sessionRecoveryAuditEvents = null; messageAuditEvents = null;
                 getLogger().log(Level.WARNING,"Fantasy Stick local events are unavailable; gameplay remains enabled",failure);
             }
             getServer().getPluginManager().registerEvents(crafting, this);
@@ -922,6 +941,21 @@ public final class FantasyStickPlugin extends JavaPlugin {
                     if (failure != null) getLogger().log(Level.WARNING, "Previous nutrition event intent drain failed", failure);
                     if (replayNutritionEvents != null) replayNutritionEvents.replay();
                 });
+                var replayRoleplayEvents = roleplayAvailabilityEvents;
+                roleplayAuditDrain.whenComplete((ignored, failure) -> {
+                    if (failure != null) getLogger().log(Level.WARNING, "Previous roleplay event intent drain failed", failure);
+                    if (replayRoleplayEvents != null) replayRoleplayEvents.replay();
+                });
+                var replayPartyCapacityEvents = partyCapacityEvents;
+                partyCapacityAuditDrain.whenComplete((ignored, failure) -> {
+                    if (failure != null) getLogger().log(Level.WARNING, "Previous party capacity event intent drain failed", failure);
+                    if (replayPartyCapacityEvents != null) replayPartyCapacityEvents.replay();
+                });
+                var replaySheetPackEvents = sheetResourcePackEvents;
+                sheetResourcePackAuditDrain.whenComplete((ignored, failure) -> {
+                    if (failure != null) getLogger().log(Level.WARNING, "Previous sheet pack event intent drain failed", failure);
+                    if (replaySheetPackEvents != null) replaySheetPackEvents.replay();
+                });
                 var replaySwitchConfigEvents = switchConfigEvents;
                 switchConfigAuditDrain.whenComplete((ignored, failure) -> {
                     if (failure != null) getLogger().log(Level.WARNING, "Previous switch configuration intent drain failed", failure);
@@ -993,6 +1027,9 @@ public final class FantasyStickPlugin extends JavaPlugin {
         var closingNutritionAuditEvents = nutritionAuditEvents; nutritionAuditEvents = null;
         var closingSwitchAuditEvents = switchAuditEvents; switchAuditEvents = null;
         var closingSwitchConfigEvents = switchConfigEvents; switchConfigEvents = null;
+        var closingRoleplayEvents = roleplayAvailabilityEvents; roleplayAvailabilityEvents = null;
+        var closingPartyCapacityEvents = partyCapacityEvents; partyCapacityEvents = null;
+        var closingSheetPackEvents = sheetResourcePackEvents; sheetResourcePackEvents = null;
         var closingIdentityAuditEvents = identityAuditEvents; identityAuditEvents = null;
         var closingAdminRevivalAuditEvents = adminRevivalEvents; adminRevivalEvents = null;
         var closingEquipmentAuditEvents = equipmentAuditEvents; equipmentAuditEvents = null;
@@ -1314,6 +1351,36 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 return null;
             }).thenCompose(ignored -> closingNutritionAuditEvents.drained());
         });
+        if (closingRoleplayEvents != null) cleanup("roleplay availability event intent drain", () -> {
+            var settingsDrained = closingRoleplaySettings == null
+                ? java.util.concurrent.CompletableFuture.<Void>completedFuture(null)
+                : closingRoleplaySettings.drained();
+            roleplayAuditDrain = settingsDrained.handle((ignored, failure) -> {
+                if (failure != null) getLogger().log(Level.WARNING, "Roleplay setting drain failed", failure);
+                closingRoleplayEvents.close();
+                return null;
+            }).thenCompose(ignored -> closingRoleplayEvents.drained());
+        });
+        if (closingPartyCapacityEvents != null) cleanup("party capacity event intent drain", () -> {
+            var settingsDrained = closingPartySettings == null
+                ? java.util.concurrent.CompletableFuture.<Void>completedFuture(null)
+                : closingPartySettings.drained();
+            partyCapacityAuditDrain = settingsDrained.handle((ignored, failure) -> {
+                if (failure != null) getLogger().log(Level.WARNING, "Party setting drain failed", failure);
+                closingPartyCapacityEvents.close();
+                return null;
+            }).thenCompose(ignored -> closingPartyCapacityEvents.drained());
+        });
+        if (closingSheetPackEvents != null) cleanup("sheet resource-pack event intent drain", () -> {
+            var settingsDrained = closingSheetResourcePackSettings == null
+                ? java.util.concurrent.CompletableFuture.<Void>completedFuture(null)
+                : closingSheetResourcePackSettings.drained();
+            sheetResourcePackAuditDrain = settingsDrained.handle((ignored, failure) -> {
+                if (failure != null) getLogger().log(Level.WARNING, "Sheet pack setting drain failed", failure);
+                closingSheetPackEvents.close();
+                return null;
+            }).thenCompose(ignored -> closingSheetPackEvents.drained());
+        });
         if (closingSwitchConfigEvents != null) cleanup("switch configuration event intent drain", () -> {
             var settingsDrained = closingSwitchDelaySettings == null
                 ? java.util.concurrent.CompletableFuture.<Void>completedFuture(null)

src/main/java/games/dmg/fantasystick/events/PartyCapacityEventBridge.java

@@ -0,0 +1,109 @@
+package games.dmg.fantasystick.events;
+
+import games.dmg.fantasystick.persistence.PartySettings;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.time.Clock;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.CompletionStage;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import org.bukkit.Location;
+import org.bukkit.command.BlockCommandSender;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+/** Observes effective party join capacity without reading or mutating protected rosters. */
+public final class PartyCapacityEventBridge implements AutoCloseable {
+    public record Actor(String kind, EventInput.Context context) { }
+
+    private final Function<EventInput, CompletionStage<LocalEventLog.Delivery>> sink;
+    private final Clock clock;
+    private final EquipmentSessions sessions;
+    private final FeatureEventOutbox outbox;
+
+    public PartyCapacityEventBridge(Function<EventInput, CompletionStage<LocalEventLog.Delivery>> sink,
+                                    Clock clock, Path data, EquipmentSessions sessions,
+                                    Consumer<Throwable> failures) {
+        this.sink = Objects.requireNonNull(sink);
+        this.clock = Objects.requireNonNull(clock);
+        this.sessions = Objects.requireNonNull(sessions);
+        outbox = new FeatureEventOutbox(data, "party-capacity-event-intents",
+            java.util.Set.of("config.changed"), sink, failures);
+    }
+
+    public Actor actor(CommandSender sender) {
+        try {
+            var player = sender instanceof Player value ? value : null;
+            var kind = player != null ? "player" : sender instanceof BlockCommandSender ? "command_block" : "console";
+            var active = player == null ? null : sessions.active(player.getUniqueId()).orElse(null);
+            var record = active == null ? null : sessions.currentRecord(active).orElse(null);
+            return new Actor(kind, player == null ? null : new EventInput.Context(player.getUniqueId(),
+                player.getName(), record == null ? null : record.id(),
+                record == null ? null : record.name(), active == null ? null : active.session(),
+                safeLocation(player)));
+        } catch (RuntimeException unavailable) { return null; }
+    }
+
+    public void read(Actor actor, String effective) {
+        if (actor == null) return;
+        var values = common(actor);
+        values.put("effective", effective);
+        values.put("outcome", "acknowledged_read");
+        var operation = UUID.randomUUID();
+        try { sink.apply(new EventInput(id(operation, "config.read"), operation, clock.instant(),
+            "config.read", actor.context(), values)); }
+        catch (RuntimeException ignored) { /* Observation cannot change party capacity. */ }
+    }
+
+    public void changed(Actor actor, UUID operation, String before, String effective,
+                        PartySettings.Update saved) {
+        if (actor == null) return;
+        try {
+            var values = common(actor);
+            values.put("operation_id", operation.toString());
+            values.put("policy_revision", Long.toString(saved.sequence()));
+            values.put("before", before);
+            values.put("after", saved.value());
+            values.put("effective", effective);
+            values.put("existing_rosters_grandfathered", true);
+            values.put("outcome", "acknowledged");
+            outbox.accepted(new EventInput(id(operation, "config.changed"), operation, clock.instant(),
+                "config.changed", actor.context(), values));
+        } catch (RuntimeException ignored) { /* Audit failure cannot roll back a published join limit. */ }
+    }
+
+    private static Map<String, Object> common(Actor actor) {
+        var values = new LinkedHashMap<String, Object>();
+        values.put("key", PartySettings.KEY);
+        values.put("default", PartySettings.DEFAULT);
+        values.put("actor_kind", actor.kind());
+        values.put("application_scope", "future_join_checks");
+        if (actor.context() == null) values.put("location_status", "not_applicable");
+        else if (actor.context().location() == null) values.put("location_status", "unavailable");
+        return values;
+    }
+
+    private EventInput.Location safeLocation(Player player) {
+        try {
+            Location location = player.getLocation();
+            if (location == null || location.getWorld() == null) return null;
+            var world = location.getWorld();
+            return new EventInput.Location(world.getUID(), world.getName(), location.getX(),
+                location.getY(), location.getZ(), clock.instant(), "exact");
+        } catch (RuntimeException unavailable) { return null; }
+    }
+
+    private static UUID id(UUID operation, String type) {
+        return UUID.nameUUIDFromBytes(("fantasystick:party-capacity:" + operation + ":" + type)
+            .getBytes(StandardCharsets.UTF_8));
+    }
+
+    public void replay() { outbox.replay(); }
+    public CompletionStage<Void> drained() { return outbox.drained(); }
+    @Override public void close() { outbox.close(); }
+}

src/main/java/games/dmg/fantasystick/events/RoleplayAvailabilityEventBridge.java

@@ -0,0 +1,127 @@
+package games.dmg.fantasystick.events;
+
+import games.dmg.fantasystick.persistence.RoleplaySettings;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.time.Clock;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.CompletionStage;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import org.bukkit.Location;
+import org.bukkit.command.BlockCommandSender;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+/** A policy publication requests ordinary exits; it never attests their later receipt completion. */
+public final class RoleplayAvailabilityEventBridge implements AutoCloseable {
+    public record Actor(String kind, EventInput.Context context) { }
+
+    private final Function<EventInput, CompletionStage<LocalEventLog.Delivery>> sink;
+    private final Clock clock;
+    private final EquipmentSessions sessions;
+    private final FeatureEventOutbox outbox;
+
+    public RoleplayAvailabilityEventBridge(Function<EventInput, CompletionStage<LocalEventLog.Delivery>> sink,
+                                           Clock clock, Path data, EquipmentSessions sessions,
+                                           Consumer<Throwable> failures) {
+        this.sink = Objects.requireNonNull(sink);
+        this.clock = Objects.requireNonNull(clock);
+        this.sessions = Objects.requireNonNull(sessions);
+        outbox = new FeatureEventOutbox(data, "roleplay-availability-event-intents",
+            java.util.Set.of("config.changed", "game.availability_changed"), sink, failures);
+    }
+
+    public Actor actor(CommandSender sender) {
+        try {
+            var player = sender instanceof Player value ? value : null;
+            var kind = player != null ? "player" : sender instanceof BlockCommandSender ? "command_block" : "console";
+            var active = player == null ? null : sessions.active(player.getUniqueId()).orElse(null);
+            var record = active == null ? null : sessions.currentRecord(active).orElse(null);
+            return new Actor(kind, player == null ? null : new EventInput.Context(player.getUniqueId(),
+                player.getName(), record == null ? null : record.id(),
+                record == null ? null : record.name(), record == null ? null : active.session(),
+                safeLocation(player)));
+        } catch (RuntimeException unavailable) { return null; }
+    }
+
+    public void read(Actor actor, boolean disabled) {
+        if (actor == null) return;
+        var values = common(actor);
+        values.put("effective", disabled);
+        values.put("available", !disabled);
+        values.put("outcome", "acknowledged_read");
+        var operation = UUID.randomUUID();
+        try { sink.apply(new EventInput(id(operation, "config.read"), operation, clock.instant(),
+            "config.read", actor.context(), values)); }
+        catch (RuntimeException ignored) { /* An observation cannot change availability. */ }
+    }
+
+    public void changed(Actor actor, UUID operation, boolean before, RoleplaySettings.Update saved,
+                        EquipmentSessions.DisableSummary exits) {
+        if (actor == null) return;
+        try {
+            var config = common(actor);
+            config.put("operation_id", operation.toString());
+            config.put("policy_revision", Long.toString(saved.sequence()));
+            config.put("before", before);
+            config.put("after", saved.disabled());
+            config.put("effective", saved.disabled());
+            config.put("outcome", "acknowledged");
+            durable(operation, "config.changed", actor.context(), config);
+
+            var availability = common(actor);
+            availability.put("origin_admin_action_id", operation.toString());
+            availability.put("policy_revision", Long.toString(saved.sequence()));
+            availability.put("available_before", !before);
+            availability.put("available_after", !saved.disabled());
+            availability.put("exit_requested_count", exits == null ? 0 : exits.exitRequested());
+            availability.put("exit_request_accepted_count", exits == null ? 0 : exits.exitRequested());
+            availability.put("exit_native_restored_pending_receipt_count",
+                exits == null ? 0 : exits.nativeRestoredPendingReceipt());
+            availability.put("exit_confirmed_count", 0);
+            availability.put("exit_failed_count", exits == null ? 0 : exits.exitFailed());
+            availability.put("exit_pending_count", exits == null ? 0 : exits.exitPending());
+            availability.put("pending_entry_refused_count", exits == null ? 0 : exits.entryRefused());
+            availability.put("receipt_state", "not_yet_observed");
+            availability.put("outcome", "policy_published_exit_requests_only");
+            durable(operation, "game.availability_changed", actor.context(), availability);
+        } catch (RuntimeException ignored) { /* Logging failure cannot reverse policy or reissue exits. */ }
+    }
+
+    private static Map<String, Object> common(Actor actor) {
+        var values = new LinkedHashMap<String, Object>();
+        values.put("key", RoleplaySettings.KEY);
+        values.put("actor_kind", actor.kind());
+        values.put("application_scope", "global_and_active_sessions");
+        if (actor.context() == null) values.put("location_status", "not_applicable");
+        else if (actor.context().location() == null) values.put("location_status", "unavailable");
+        return values;
+    }
+
+    private EventInput.Location safeLocation(Player player) {
+        try {
+            Location location = player.getLocation();
+            if (location == null || location.getWorld() == null) return null;
+            var world = location.getWorld();
+            return new EventInput.Location(world.getUID(), world.getName(), location.getX(),
+                location.getY(), location.getZ(), clock.instant(), "exact");
+        } catch (RuntimeException unavailable) { return null; }
+    }
+
+    private void durable(UUID operation, String type, EventInput.Context actor, Map<String, Object> values) {
+        outbox.accepted(new EventInput(id(operation, type), operation, clock.instant(), type, actor, values));
+    }
+    private static UUID id(UUID operation, String type) {
+        return UUID.nameUUIDFromBytes(("fantasystick:roleplay-availability:" + operation + ":" + type)
+            .getBytes(StandardCharsets.UTF_8));
+    }
+
+    public void replay() { outbox.replay(); }
+    public CompletionStage<Void> drained() { return outbox.drained(); }
+    @Override public void close() { outbox.close(); }
+}

src/main/java/games/dmg/fantasystick/events/SheetResourcePackEventBridge.java

@@ -0,0 +1,178 @@
+package games.dmg.fantasystick.events;
+
+import games.dmg.fantasystick.persistence.SheetResourcePackSettings;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.time.Clock;
+import java.util.HexFormat;
+import java.util.LinkedHashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.CompletionStage;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import org.bukkit.Location;
+import org.bukkit.command.BlockCommandSender;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerResourcePackStatusEvent;
+
+/** Pack events describe native offers and callbacks, never actual client rendering or gameplay authority. */
+public final class SheetResourcePackEventBridge implements AutoCloseable {
+    public record Actor(String kind, EventInput.Context context) { }
+    public record Request(UUID action, UUID pack, String assetIdentity, String sha1) { }
+
+    private final Function<EventInput, CompletionStage<LocalEventLog.Delivery>> sink;
+    private final Clock clock;
+    private final EquipmentSessions sessions;
+    private final FeatureEventOutbox outbox;
+
+    public SheetResourcePackEventBridge(Function<EventInput, CompletionStage<LocalEventLog.Delivery>> sink,
+                                        Clock clock, Path data, EquipmentSessions sessions,
+                                        Consumer<Throwable> failures) {
+        this.sink = Objects.requireNonNull(sink);
+        this.clock = Objects.requireNonNull(clock);
+        this.sessions = Objects.requireNonNull(sessions);
+        outbox = new FeatureEventOutbox(data, "sheet-resource-pack-event-intents",
+            java.util.Set.of("config.changed", "resource_pack.delivery_requested",
+                "resource_pack.delivery_resolved"), sink, failures);
+    }
+
+    public Actor actor(CommandSender sender) {
+        try {
+            var player = sender instanceof Player value ? value : null;
+            var kind = player != null ? "player" : sender instanceof BlockCommandSender ? "command_block" : "console";
+            var active = player == null ? null : sessions.active(player.getUniqueId()).orElse(null);
+            var record = active == null ? null : sessions.currentRecord(active).orElse(null);
+            return new Actor(kind, player == null ? null : new EventInput.Context(player.getUniqueId(),
+                player.getName(), record == null ? null : record.id(),
+                record == null ? null : record.name(), active == null ? null : active.session(),
+                safeLocation(player)));
+        } catch (RuntimeException unavailable) { return null; }
+    }
+
+    public void read(Actor actor, String key, String value) {
+        if (actor == null) return;
+        var values = config(actor, key);
+        values.put("effective", safeValue(key, value));
+        values.put("outcome", "acknowledged_read");
+        var action = UUID.randomUUID();
+        try { sink.apply(new EventInput(id(action, "config.read"), action, clock.instant(),
+            "config.read", actor.context(), values)); }
+        catch (RuntimeException ignored) { /* A read cannot change a delivery. */ }
+    }
+
+    public void changed(Actor actor, UUID action, String key, String before, String effective,
+                        SheetResourcePackSettings.Update saved) {
+        if (actor == null) return;
+        try {
+            var values = config(actor, key);
+            values.put("operation_id", action.toString());
+            values.put("policy_revision", Long.toString(saved.sequence()));
+            values.put("before", safeValue(key, before));
+            values.put("after", safeValue(key, key.equals(SheetResourcePackSettings.URL_KEY)
+                ? saved.snapshot().url() : saved.snapshot().sha1()));
+            values.put("effective", safeValue(key, effective));
+            values.put("outcome", "acknowledged_before_optional_redelivery");
+            durable(action, "config.changed", actor.context(), values);
+        } catch (RuntimeException ignored) { /* An audit failure cannot reverse a paired setting. */ }
+    }
+
+    public Request requested(Player player, UUID pack, String url, String sha1, String trigger,
+                             boolean delivered) {
+        var action = UUID.randomUUID();
+        var request = new Request(action, pack, identity(url), sha1);
+        try {
+            var values = new LinkedHashMap<String, Object>();
+            values.put("pack_id", pack.toString());
+            values.put("asset_identity", request.assetIdentity());
+            values.put("sha1", sha1);
+            values.put("trigger", trigger);
+            values.put("prompt", "Optional Fantasy Stick first-person sheet presentation");
+            values.put("required", false);
+            values.put("outcome", delivered ? "native_offer_returned" : "native_offer_failed");
+            var context = playerContext(player);
+            values.put("location_quality", context.location() == null ? "unavailable" : context.location().quality());
+            if (context.location() == null) values.put("location_status", "unavailable");
+            durable(action, "resource_pack.delivery_requested", context, values);
+        } catch (RuntimeException ignored) { /* Pack requests and gameplay never depend on the audit writer. */ }
+        return request;
+    }
+
+    public void resolved(Player player, Request request, PlayerResourcePackStatusEvent.Status status) {
+        try {
+            var outcome = status.name().toLowerCase(Locale.ROOT);
+            if (status == PlayerResourcePackStatusEvent.Status.FAILED_RELOAD) outcome = "reload_failed";
+            var values = new LinkedHashMap<String, Object>();
+            values.put("pack_id", request.pack().toString());
+            values.put("asset_identity", request.assetIdentity());
+            values.put("sha1", request.sha1());
+            values.put("origin_delivery_action_id", request.action().toString());
+            values.put("status", outcome);
+            values.put("reason", "client_reported_status");
+            values.put("callback_time", clock.instant().toString());
+            var context = playerContext(player);
+            values.put("location_quality", context.location() == null ? "unavailable" : context.location().quality());
+            if (context.location() == null) values.put("location_status", "unavailable");
+            durable(request.action(), "resource_pack.delivery_resolved", context, values, status.name());
+        } catch (RuntimeException ignored) { /* A status cannot authorize gameplay. */ }
+    }
+
+    private static Map<String, Object> config(Actor actor, String key) {
+        var values = new LinkedHashMap<String, Object>();
+        values.put("key", key);
+        values.put("actor_kind", actor.kind());
+        values.put("application_scope", "later_optional_redelivery");
+        if (actor.context() == null) values.put("location_status", "not_applicable");
+        else if (actor.context().location() == null) values.put("location_status", "unavailable");
+        return values;
+    }
+
+    /** A URL's query can contain credentials; only a one-way identity escapes the policy boundary. */
+    public static String safeValue(String key, String value) {
+        return SheetResourcePackSettings.URL_KEY.equals(key) ? identity(value) : value;
+    }
+
+    private static String identity(String url) {
+        try {
+            return "sha256:" + HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256")
+                .digest(url.getBytes(StandardCharsets.UTF_8)));
+        } catch (NoSuchAlgorithmException unavailable) { throw new IllegalStateException(unavailable); }
+    }
+
+    private EventInput.Context playerContext(Player player) {
+        return new EventInput.Context(player.getUniqueId(), player.getName(), null, null, null,
+            safeLocation(player));
+    }
+
+    private EventInput.Location safeLocation(Player player) {
+        try {
+            Location location = player.getLocation();
+            if (location == null || location.getWorld() == null) return null;
+            var world = location.getWorld();
+            return new EventInput.Location(world.getUID(), world.getName(), location.getX(),
+                location.getY(), location.getZ(), clock.instant(), "exact");
+        } catch (RuntimeException unavailable) { return null; }
+    }
+
+    private void durable(UUID action, String type, EventInput.Context context, Map<String, Object> values) {
+        durable(action, type, context, values, type);
+    }
+    private void durable(UUID action, String type, EventInput.Context context, Map<String, Object> values,
+                         String discriminator) {
+        outbox.accepted(new EventInput(id(action, discriminator), action, clock.instant(), type, context, values));
+    }
+    private static UUID id(UUID action, String discriminator) {
+        return UUID.nameUUIDFromBytes(("fantasystick:sheet-pack:" + action + ":" + discriminator)
+            .getBytes(StandardCharsets.UTF_8));
+    }
+
+    public void replay() { outbox.replay(); }
+    public CompletionStage<Void> drained() { return outbox.drained(); }
+    @Override public void close() { outbox.close(); }
+}

src/main/java/games/dmg/fantasystick/presentation/SheetResourcePack.java

@@ -1,7 +1,12 @@
 package games.dmg.fantasystick.presentation;
 
 import games.dmg.fantasystick.persistence.SheetResourcePackSettings;
+import games.dmg.fantasystick.events.SheetResourcePackEventBridge;
 import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
 import java.util.Objects;
 import java.util.UUID;
 import java.util.function.BiConsumer;
@@ -9,6 +14,7 @@ import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.event.player.PlayerResourcePackStatusEvent;
 
 /** Optional cosmetic pack delivery. Status never authorizes or cancels gameplay. */
@@ -16,36 +22,71 @@ public final class SheetResourcePack implements Listener, AutoCloseable {
     public static final UUID ID = UUID.fromString("0d53e627-f13b-5a49-b8d5-882d3f4122bb");
     private final SheetResourcePackSettings settings;
     private final BiConsumer<UUID, Throwable> failures;
+    private final Map<UUID, Offer> offers = new HashMap<>();
+    private final Map<UUID, Player> recipients = new HashMap<>();
+    private SheetResourcePackEventBridge events;
     private boolean closed;
 
+    private record Offer(SheetResourcePackEventBridge.Request request,
+                         Set<PlayerResourcePackStatusEvent.Status> statuses) { }
+
     public SheetResourcePack(SheetResourcePackSettings settings, BiConsumer<UUID, Throwable> failures) {
         this.settings = Objects.requireNonNull(settings);
         this.failures = Objects.requireNonNull(failures);
     }
 
-    public void deliverAll(Collection<? extends Player> players) {
-        if (closed) return;
-        for (var player : players) if (player != null && player.isOnline()) deliver(player);
+    public void attachEvents(SheetResourcePackEventBridge bridge) {
+        if (closed || events != null) throw new IllegalStateException("Sheet pack events unavailable");
+        events = Objects.requireNonNull(bridge);
     }
 
-    public void deliver(Player player) {
+    public void deliverAll(Collection<? extends Player> players) { deliverAll(players, "startup"); }
+
+    public void deliverAll(Collection<? extends Player> players, String trigger) {
+        if (closed) return;
+        for (var player : players) if (player != null && player.isOnline()) deliver(player, trigger);
+    }
+
+    public void deliver(Player player) { deliver(player, "explicit"); }
+
+    private void deliver(Player player, String trigger) {
         if (closed || !player.isOnline()) return;
+        var playerId = player.getUniqueId();
+        var prior = offers.get(playerId);
+        var pack = UUID.randomUUID(); // Native callbacks expose only this ID, not a usable hash.
+        var url = settings.url(); var sha1 = settings.sha1();
         try {
-            player.addResourcePack(ID, settings.url(), java.util.HexFormat.of().parseHex(settings.sha1()),
+            player.addResourcePack(pack, url, java.util.HexFormat.of().parseHex(sha1),
                 "Optional Fantasy Stick first-person sheet presentation", false);
+            if (events != null) offers.put(playerId, new Offer(
+                events.requested(player, pack, url, sha1, trigger, true), new HashSet<>()));
+            recipients.put(playerId, player);
+            if (prior != null) try { player.removeResourcePack(prior.request().pack()); }
+            catch (RuntimeException failure) { report(playerId, failure); }
         } catch (RuntimeException failure) {
-            report(player.getUniqueId(), failure);
-            player.sendMessage("Fantasy Stick cosmetic resource pack could not be offered; gameplay is unchanged.");
+            if (events != null) events.requested(player, pack, url, sha1, trigger, false);
+            report(playerId, failure);
+            try { player.sendMessage("Fantasy Stick cosmetic resource pack could not be offered; gameplay is unchanged."); }
+            catch (RuntimeException feedbackFailure) { report(playerId, feedbackFailure); }
         }
     }
 
-    @EventHandler public void join(PlayerJoinEvent event) { deliver(event.getPlayer()); }
+    @EventHandler public void join(PlayerJoinEvent event) { deliver(event.getPlayer(), "join"); }
+    @EventHandler public void quit(PlayerQuitEvent event) {
+        var id = event.getPlayer().getUniqueId(); offers.remove(id); recipients.remove(id);
+    }
 
     @EventHandler public void status(PlayerResourcePackStatusEvent event) {
-        if (closed || !ID.equals(event.getID())) return;
+        if (closed) return;
+        var offer = offers.get(event.getPlayer().getUniqueId());
+        if (offer == null || !offer.request().pack().equals(event.getID())) return;
+        if (offer.statuses().add(event.getStatus()) && events != null)
+            events.resolved(event.getPlayer(), offer.request(), event.getStatus());
         switch (event.getStatus()) {
-            case DECLINED, FAILED_DOWNLOAD, INVALID_URL, FAILED_RELOAD, DISCARDED ->
-                event.getPlayer().sendMessage("Fantasy Stick cosmetic resource pack is unavailable; gameplay is unchanged.");
+            case DECLINED, FAILED_DOWNLOAD, INVALID_URL, FAILED_RELOAD, DISCARDED -> {
+                try { event.getPlayer().sendMessage("Fantasy Stick cosmetic resource pack is unavailable; gameplay is unchanged."); }
+                catch (RuntimeException feedbackFailure) { report(event.getPlayer().getUniqueId(), feedbackFailure); }
+            }
             default -> { /* Acceptance/loading is cosmetic and needs no gameplay callback. */ }
         }
     }
@@ -55,5 +96,13 @@ public final class SheetResourcePack implements Listener, AutoCloseable {
         catch (RuntimeException ignored) { /* Diagnostics cannot make a cosmetic pack mandatory. */ }
     }
 
-    @Override public void close() { closed = true; }
+    @Override public void close() {
+        closed = true;
+        offers.forEach((id, offer) -> {
+            var player = recipients.get(id);
+            if (player != null) try { player.removeResourcePack(offer.request().pack()); }
+            catch (RuntimeException failure) { report(id, failure); }
+        });
+        offers.clear(); recipients.clear(); events = null;
+    }
 }

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

@@ -74,7 +74,9 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     private games.dmg.fantasystick.persistence.SwitchDelaySettings switchDelaySettings;
     private games.dmg.fantasystick.events.SwitchConfigEventBridge switchConfigEvents;
     private games.dmg.fantasystick.persistence.RoleplaySettings roleplaySettings;
+    private games.dmg.fantasystick.events.RoleplayAvailabilityEventBridge roleplayAvailabilityEvents;
     private games.dmg.fantasystick.persistence.PartySettings partySettings;
+    private games.dmg.fantasystick.events.PartyCapacityEventBridge partyCapacityEvents;
     private games.dmg.fantasystick.persistence.PartyEconomySettings partyEconomySettings;
     private games.dmg.fantasystick.persistence.GearSettings gearSettings;
     private games.dmg.fantasystick.persistence.CoinSettings coinSettings;
@@ -86,6 +88,7 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     private games.dmg.fantasystick.party.CombatExperience combatExperience;
     private games.dmg.fantasystick.persistence.SheetResourcePackSettings sheetResourcePackSettings;
     private games.dmg.fantasystick.presentation.SheetResourcePack sheetResourcePack;
+    private games.dmg.fantasystick.events.SheetResourcePackEventBridge sheetResourcePackEvents;
     private games.dmg.fantasystick.persistence.OutOfCombatRecoverySettings outOfCombatRecoverySettings;
     private OutOfCombatRecovery outOfCombatRecovery;
     private games.dmg.fantasystick.persistence.QuickerRegenerationSettings quickerRegenerationSettings;
@@ -343,7 +346,15 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         switchConfigEvents=Objects.requireNonNull(events);
     }
     public void attachRoleplaySettings(games.dmg.fantasystick.persistence.RoleplaySettings settings){if(closed||roleplaySettings!=null)throw new IllegalStateException("Roleplay settings already attached or command closed");roleplaySettings=Objects.requireNonNull(settings);}
+    public void attachRoleplayAvailabilityEvents(games.dmg.fantasystick.events.RoleplayAvailabilityEventBridge events){
+        if(closed||roleplaySettings==null||roleplayAvailabilityEvents!=null)throw new IllegalStateException("Roleplay availability events unavailable");
+        roleplayAvailabilityEvents=Objects.requireNonNull(events);
+    }
     public void attachPartySettings(games.dmg.fantasystick.persistence.PartySettings settings){if(closed||partySettings!=null)throw new IllegalStateException("Party settings already attached or command closed");partySettings=Objects.requireNonNull(settings);}
+    public void attachPartyCapacityEvents(games.dmg.fantasystick.events.PartyCapacityEventBridge events){
+        if(closed||partySettings==null||partyCapacityEvents!=null)throw new IllegalStateException("Party capacity events unavailable");
+        partyCapacityEvents=Objects.requireNonNull(events);
+    }
     public void attachPartyEconomySettings(games.dmg.fantasystick.persistence.PartyEconomySettings settings){if(closed||partyEconomySettings!=null)throw new IllegalStateException("Party economy settings already attached or command closed");partyEconomySettings=Objects.requireNonNull(settings);}
     public void attachGearSettings(games.dmg.fantasystick.persistence.GearSettings settings){if(closed||gearSettings!=null)throw new IllegalStateException("Gear settings already attached or command closed");gearSettings=Objects.requireNonNull(settings);}
     public void attachCoinSettings(games.dmg.fantasystick.persistence.CoinSettings settings){if(closed||coinSettings!=null)throw new IllegalStateException("Coin settings already attached or command closed");coinSettings=Objects.requireNonNull(settings);}
@@ -361,6 +372,11 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     }
     public void attachDungeons(games.dmg.fantasystick.dungeon.DungeonCommands commands){if(closed||dungeonCommands!=null)throw new IllegalStateException("Dungeons already attached or command closed");dungeonCommands=Objects.requireNonNull(commands);}
     public void attachSheetResourcePack(games.dmg.fantasystick.persistence.SheetResourcePackSettings settings,games.dmg.fantasystick.presentation.SheetResourcePack delivery){if(closed||sheetResourcePackSettings!=null)throw new IllegalStateException("Sheet resource pack already attached or command closed");sheetResourcePackSettings=Objects.requireNonNull(settings);sheetResourcePack=Objects.requireNonNull(delivery);}
+    public void attachSheetResourcePackEvents(games.dmg.fantasystick.events.SheetResourcePackEventBridge events){
+        if(closed||sheetResourcePackSettings==null||sheetResourcePackEvents!=null)
+            throw new IllegalStateException("Sheet pack events unavailable");
+        sheetResourcePackEvents=Objects.requireNonNull(events);
+    }
     public void attachOutOfCombatRecovery(games.dmg.fantasystick.persistence.OutOfCombatRecoverySettings settings,
                                            OutOfCombatRecovery recovery) {
         if (closed || outOfCombatRecoverySettings != null) throw new IllegalStateException("Out-of-combat recovery already attached or command closed");
@@ -1827,7 +1843,40 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         });
     }
 
-    private void sheetResourcePackConfiguration(CommandSender sender,String[] args){if(sheetResourcePackSettings==null){configurationUsage(sender);return;}String key=args[1];if(args.length==2){sender.sendMessage(key+"="+sheetResourcePackSettings.value(key));return;}java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.SheetResourcePackSettings.Update> operation;try{operation=sheetResourcePackSettings.set(key,args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Sheet resource-pack value is invalid; use an absolute HTTPS URL or 40 hexadecimal SHA-1 characters.");return;}operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-sheet-resource-pack",failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;boolean applied=false;if(failure==null){applied=sheetResourcePackSettings.publish(saved);if(applied)sheetResourcePack.deliverAll(server.getOnlinePlayers());}if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;if(failure!=null)sender.sendMessage("Sheet resource-pack configuration save failed; effective values are unchanged.");else if(!applied)sender.sendMessage("Saved request was superseded; effective "+key+"="+sheetResourcePackSettings.value(key)+".");else sender.sendMessage("Saved "+key+"="+sheetResourcePackSettings.value(key)+"; optional delivery was requested for online players.");});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});}
+    private void sheetResourcePackConfiguration(CommandSender sender,String[] args){
+        if(sheetResourcePackSettings==null){configurationUsage(sender);return;}
+        String key=args[1]; var audit=sheetResourcePackEvents;
+        if(args.length==2){
+            var effective=sheetResourcePackSettings.value(key);
+            if(audit!=null)audit.read(audit.actor(sender),key,effective);
+            sender.sendMessage(key+"="+effective); return;
+        }
+        var actor=audit==null?null:audit.actor(sender);
+        var action=UUID.randomUUID();
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.SheetResourcePackSettings.Update> operation;
+        try{operation=sheetResourcePackSettings.set(key,args[2]);}
+        catch(IllegalArgumentException invalid){sender.sendMessage("Sheet resource-pack value is invalid; use an absolute HTTPS URL or 40 hexadecimal SHA-1 characters.");return;}
+        operation.whenComplete((saved,failure)->{
+            if(failure!=null)report(null,"config-sheet-resource-pack",failure);
+            if(closed)return;
+            try{nextTick.accept(()->{
+                if(closed)return;
+                boolean applied=false;
+                if(failure==null){
+                    var before=sheetResourcePackSettings.value(key);
+                    applied=sheetResourcePackSettings.publish(saved);
+                    var effective=sheetResourcePackSettings.value(key);
+                    if(audit!=null&&applied&&!before.equals(effective))
+                        audit.changed(actor,action,key,before,effective,saved);
+                    if(applied)sheetResourcePack.deliverAll(server.getOnlinePlayers(),"config_change");
+                }
+                if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;
+                if(failure!=null)sender.sendMessage("Sheet resource-pack configuration save failed; effective values are unchanged.");
+                else if(!applied)sender.sendMessage("Saved request was superseded; effective "+key+"="+sheetResourcePackSettings.value(key)+".");
+                else sender.sendMessage("Saved "+key+"="+sheetResourcePackSettings.value(key)+"; optional delivery was requested for online players.");
+            });}catch(RuntimeException rejected){report(null,"config-response",rejected);}
+        });
+    }
 
     private void partyEconomyConfiguration(CommandSender sender,String[] args){String key=args[1],before=partyEconomySettings.value(key),actorKind=sender instanceof org.bukkit.entity.Player?"player":sender instanceof org.bukkit.command.BlockCommandSender?"command_block":"console";UUID actorPlayer=sender instanceof org.bukkit.entity.Player player?player.getUniqueId():null;String actorName=sender instanceof org.bukkit.entity.Player?sender.getName():null;if(args.length==2){if(partyEvents!=null)partyEvents.configRead(actorKind,actorPlayer,actorName,key,before);sender.sendMessage(key+"="+before+" (applies to future party transactions only)");return;}java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.PartyEconomySettings.Update> operation;try{operation=partyEconomySettings.set(key,args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Party price is invalid; enter a whole number from 0 through 2147483647.");return;}operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-"+key,failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;boolean applied=failure==null&&partyEconomySettings.publish(saved);if(applied&&partyEvents!=null)partyEvents.configChanged(actorKind,actorPlayer,actorName,key,before,saved.value());if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;if(failure!=null)sender.sendMessage("Party price save failed; the effective price is unchanged.");else if(!applied)sender.sendMessage("Saved request was superseded; effective "+key+"="+partyEconomySettings.value(key)+".");else sender.sendMessage("Saved "+key+"="+saved.value()+" for future party transactions.");});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});}
 
@@ -1871,9 +1920,77 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-"+key,failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;boolean applied=failure==null&&adventureQuestSettings.publish(saved);if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;if(failure!=null)sender.sendMessage("Adventure quest configuration save failed; effective values are unchanged.");else if(!applied)sender.sendMessage("Saved request was superseded; effective "+key+"="+adventureQuestSettings.value(key)+".");else sender.sendMessage("Saved "+key+"="+saved.value()+" for later catalogs, acceptances or attempts; active state is unchanged.");});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});
     }
 
-    private void partyConfiguration(CommandSender sender,String[] args){if(partySettings==null){configurationUsage(sender);return;}if(args.length==2){sender.sendMessage(games.dmg.fantasystick.persistence.PartySettings.KEY+"="+partySettings.value()+" (existing parties are retained)");return;}java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.PartySettings.Update> operation;try{operation=partySettings.set(args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Party maximum is invalid; enter a positive whole number.");return;}operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-party",failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;boolean applied=false;if(failure==null)applied=partySettings.publish(saved);if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;if(failure!=null)sender.sendMessage("Party configuration save failed; the effective limit and rosters are unchanged.");else if(!applied)sender.sendMessage("Saved request was superseded; effective "+games.dmg.fantasystick.persistence.PartySettings.KEY+"="+partySettings.value()+".");else sender.sendMessage("Saved "+games.dmg.fantasystick.persistence.PartySettings.KEY+"="+saved.value()+"; existing members are retained.");});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});}
+    private void partyConfiguration(CommandSender sender,String[] args){
+        if(partySettings==null){configurationUsage(sender);return;}
+        var audit=partyCapacityEvents;
+        if(args.length==2){
+            var effective=partySettings.value();
+            if(audit!=null)audit.read(audit.actor(sender),effective);
+            sender.sendMessage(games.dmg.fantasystick.persistence.PartySettings.KEY+"="+effective+" (existing parties are retained)");
+            return;
+        }
+        var actor=audit==null?null:audit.actor(sender);
+        var operationId=java.util.UUID.randomUUID();
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.PartySettings.Update> operation;
+        try{operation=partySettings.set(args[2]);}
+        catch(IllegalArgumentException invalid){sender.sendMessage("Party maximum is invalid; enter a positive whole number.");return;}
+        operation.whenComplete((saved,failure)->{
+            if(failure!=null)report(null,"config-party",failure);
+            if(closed)return;
+            try{nextTick.accept(()->{
+                if(closed)return;
+                boolean applied=false;
+                if(failure==null){
+                    var before=partySettings.value();
+                    applied=partySettings.publish(saved);
+                    var effective=partySettings.value();
+                    if(audit!=null&&applied&&!before.equals(effective))
+                        audit.changed(actor,operationId,before,effective,saved);
+                }
+                if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;
+                if(failure!=null)sender.sendMessage("Party configuration save failed; the effective limit and rosters are unchanged.");
+                else if(!applied)sender.sendMessage("Saved request was superseded; effective "+games.dmg.fantasystick.persistence.PartySettings.KEY+"="+partySettings.value()+".");
+                else sender.sendMessage("Saved "+games.dmg.fantasystick.persistence.PartySettings.KEY+"="+saved.value()+"; existing members are retained.");
+            });}catch(RuntimeException rejected){report(null,"config-response",rejected);}
+        });
+    }
 
-    private void roleplayConfiguration(CommandSender sender,String[] args){if(roleplaySettings==null){configurationUsage(sender);return;}if(args.length==2){sender.sendMessage(games.dmg.fantasystick.persistence.RoleplaySettings.KEY+"="+roleplaySettings.value());return;}java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.RoleplaySettings.Update> operation;try{operation=roleplaySettings.set(args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Usage: /fstickadmin config roleplay-disabled [true|false]");return;}operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-roleplay",failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;boolean applied=false;if(failure==null){applied=roleplaySettings.publish(saved);if(applied&&saved.disabled())sessions.disableRoleplay();}if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;if(failure!=null)sender.sendMessage("Roleplay configuration save failed; policy and sessions are unchanged.");else if(!applied)sender.sendMessage("Saved request was superseded; effective "+games.dmg.fantasystick.persistence.RoleplaySettings.KEY+"="+roleplaySettings.value()+".");else sender.sendMessage("Saved "+games.dmg.fantasystick.persistence.RoleplaySettings.KEY+"="+saved.disabled()+(saved.disabled()?"; ordinary exits were requested for active sessions.":"; normal sheet activation is available."));});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});}
+    private void roleplayConfiguration(CommandSender sender,String[] args){
+        if(roleplaySettings==null){configurationUsage(sender);return;}
+        var audit=roleplayAvailabilityEvents;
+        if(args.length==2){
+            var disabled=roleplaySettings.disabled();
+            if(audit!=null)audit.read(audit.actor(sender),disabled);
+            sender.sendMessage(games.dmg.fantasystick.persistence.RoleplaySettings.KEY+"="+disabled);
+            return;
+        }
+        var actor=audit==null?null:audit.actor(sender);
+        var operationId=java.util.UUID.randomUUID();
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.RoleplaySettings.Update> operation;
+        try{operation=roleplaySettings.set(args[2]);}
+        catch(IllegalArgumentException invalid){sender.sendMessage("Usage: /fstickadmin config roleplay-disabled [true|false]");return;}
+        operation.whenComplete((saved,failure)->{
+            if(failure!=null)report(null,"config-roleplay",failure);
+            if(closed)return;
+            try{nextTick.accept(()->{
+                if(closed)return;
+                boolean applied=false;
+                if(failure==null){
+                    var before=roleplaySettings.disabled();
+                    applied=roleplaySettings.publish(saved);
+                    EquipmentSessions.DisableSummary exits=null;
+                    if(applied&&saved.disabled())exits=sessions.disableRoleplay();
+                    if(audit!=null&&applied&&before!=saved.disabled())audit.changed(actor,operationId,before,saved,exits);
+                }
+                if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;
+                if(failure!=null)sender.sendMessage("Roleplay configuration save failed; policy and sessions are unchanged.");
+                else if(!applied)sender.sendMessage("Saved request was superseded; effective "+games.dmg.fantasystick.persistence.RoleplaySettings.KEY+"="+roleplaySettings.value()+".");
+                else sender.sendMessage("Saved "+games.dmg.fantasystick.persistence.RoleplaySettings.KEY+"="+saved.disabled()
+                    +(saved.disabled()?"; ordinary exits were requested for active sessions."
+                    :"; normal sheet activation is available."));
+            });}catch(RuntimeException rejected){report(null,"config-response",rejected);}
+        });
+    }
 
     private void switchDelayConfiguration(CommandSender sender,String[] args){
         if(switchDelaySettings==null){configurationUsage(sender);return;}

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

@@ -1345,12 +1345,30 @@ public final class EquipmentSessions implements AutoCloseable {
             });
     }
 
+    /** A synchronous exit request is not proof of an acknowledged character/receipt restoration. */
+    public record DisableSummary(int entryRefused, int exitRequested, int nativeRestoredPendingReceipt,
+                                 int exitFailed, int exitPending) { }
+
     /** Cancel pending activation and route every active player through ordinary restoration. */
-    public synchronized void disableRoleplay() {
-        for (var attempt : java.util.List.copyOf(pending.values())) {
+    public synchronized DisableSummary disableRoleplay() {
+        var pendingEntries = java.util.List.copyOf(pending.values());
+        var activeSessions = java.util.List.copyOf(active.values());
+        for (var attempt : pendingEntries) {
             refuse(attempt, "ROLEPLAY_DISABLED", "Fantasy roleplaying was disabled before activation completed.");
         }
-        for (var attempt : java.util.List.copyOf(active.values())) exit(attempt.player);
+        int nativeRestored = 0, failed = 0;
+        for (var attempt : activeSessions) {
+            try {
+                var result = exit(attempt.player);
+                if (result == EquipmentStorage.RestoreResult.RESTORED) nativeRestored++;
+                else if (result != EquipmentStorage.RestoreResult.NOT_FOUND) failed++;
+            } catch (RuntimeException uncertain) {
+                diagnostic(attempt, uncertain);
+                failed++;
+            }
+        }
+        return new DisableSummary(pendingEntries.size(), activeSessions.size(), nativeRestored,
+            failed, activeSessions.size() - failed);
     }
 
     public synchronized void cancelEntry(UUID player) {

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

@@ -1615,6 +1615,7 @@ class FantasyStickLifecycleNativeTest {
         final List<org.bukkit.Sound> sounds = new ArrayList<>();
         final List<net.kyori.adventure.title.Title> titles = new ArrayList<>();
         final List<Object[]> resourcePacks = new ArrayList<>();
+        final List<java.util.UUID> removedResourcePacks = new ArrayList<>();
         final java.util.Set<org.bukkit.NamespacedKey> knownRecipes = new java.util.LinkedHashSet<>();
         final List<List<org.bukkit.NamespacedKey>> recipeAwards = new ArrayList<>();
         final net.minecraft.world.entity.ai.attributes.AttributeMap healthAttributes = new net.minecraft.world.entity.ai.attributes.AttributeMap(
@@ -1720,6 +1721,7 @@ class FantasyStickLifecycleNativeTest {
                     case "playSound" -> { if (args.length > 1 && args[1] instanceof org.bukkit.Sound sound) sounds.add(sound); yield null; }
                     case "showTitle" -> { titles.add((net.kyori.adventure.title.Title)args[0]); yield null; }
                     case "addResourcePack" -> { resourcePacks.add(args.clone()); yield null; }
+                    case "removeResourcePack" -> { removedResourcePacks.add((java.util.UUID)args[0]); yield null; }
                     case "hasDiscoveredRecipe" -> knownRecipes.contains((org.bukkit.NamespacedKey) args[0]);
                     case "discoverRecipes" -> {
                         var requested = ((java.util.Collection<?>) args[0]).stream()

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

@@ -0,0 +1,267 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import games.dmg.fantasystick.persistence.PartySettings;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.bukkit.command.CommandSender;
+
+/** Evidence must join the registered policy path to actual roster enforcement and exported JSONL. */
+class PartyCapacityEventsNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void registeredReadAndAcknowledgedReductionAndIncreaseGovernActualJoinsAndExportPolicy() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", PartySettings.KEY});
+            assertTrue(admin.messages.getLast().contains("=6"));
+            var leader = PartyCapacityNativeTest.actor(f, data);
+            var member = PartyCapacityNativeTest.actor(f, data);
+            var third = PartyCapacityNativeTest.actor(f, data);
+            var roster = PartyLifecycleNativeTest.parties(f);
+            var party = roster.create(leader.core.id).orElseThrow();
+            var first = roster.invite(leader.core.id, party.id(), member.core.id).orElseThrow();
+            assertTrue(roster.accept(member.core.id, first.id()));
+            var second = roster.invite(leader.core.id, party.id(), third.core.id).orElseThrow();
+            change(f, admin, "2");
+            assertFalse(roster.accept(third.core.id, second.id()));
+            change(f, admin, "3");
+            assertTrue(roster.accept(third.core.id, second.id()));
+            change(f, admin, "2");
+            assertEquals(3, roster.partyOf(leader.core.id).orElseThrow().members().size());
+            assertTrue(roster.invite(leader.core.id, party.id(), java.util.UUID.randomUUID()).isEmpty());
+            for (int i = 0; i < 200 && config().size() < 4; i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        var entries = config(); assertEquals(4, entries.size(), "Only exported JSONL proves event delivery");
+        assertEquals(List.of("6", "2", "3", "2"), entries.stream()
+            .map(e -> e.getAsJsonObject("data").get("effective").getAsString()).toList());
+        assertEquals(List.of("config.read", "config.changed", "config.changed", "config.changed"), entries.stream()
+            .map(e -> e.get("type").getAsString().substring(e.get("type").getAsString().lastIndexOf(".",
+                e.get("type").getAsString().lastIndexOf(".") - 1) + 1)).toList());
+        assertTrue(entries.stream().skip(1).allMatch(e -> e.getAsJsonObject("data")
+            .get("existing_rosters_grandfathered").getAsBoolean()));
+    }
+
+    @Test void deniedInvalidAndFailedSaveNeverExportAChangeOrModifyCapacity() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new EquipmentAdminCommandNativeTest.Sender(); admin.allowed = false;
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", PartySettings.KEY});
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", PartySettings.KEY, "2"});
+            admin.allowed = true;
+            for (var invalid : List.of("0", "-2", "2.5", "2147483648", "not-a-number")) {
+                f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", PartySettings.KEY, invalid});
+                assertTrue(admin.messages.getLast().contains("invalid"));
+            }
+            Files.createDirectory(data.resolve("config.yml"));
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", PartySettings.KEY, "2"});
+            for (int i = 0; i < 30 && !admin.messages.getLast().contains("save failed"); i++) {
+                var callback = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(callback); callback.run();
+            }
+            assertTrue(admin.messages.getLast().contains("save failed"));
+            assertEquals(PartySettings.DEFAULT, ((PartySettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "partySettings")).value());
+            f.plugin.setEnabled(false);
+        }
+        assertTrue(config().isEmpty(), "Refusals and failed writes have no feature-owned success");
+    }
+
+    @Test void outOfOrderSavedCallbacksAndRepeatedValueNeverPublishFalseChanges() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            while (!f.tasks.isEmpty()) f.tasks.remove().run();
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", PartySettings.KEY, "2"});
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", PartySettings.KEY, "3"});
+            var settings = (PartySettings) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "partySettings");
+            var worker = (java.util.concurrent.ExecutorService) FantasyStickLifecycleNativeTest.Fixture.field(
+                settings, "worker");
+            java.util.concurrent.CompletableFuture.runAsync(() -> {}, worker).get(5, TimeUnit.SECONDS);
+            var first = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(first);
+            var second = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(second);
+            second.run(); first.run();
+            assertEquals("3", settings.value());
+            change(f, admin, "3");
+            for (int i = 0; i < 200 && config().isEmpty(); i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        var entries = config(); assertEquals(1, entries.size());
+        var values = entries.getFirst().getAsJsonObject("data");
+        assertEquals("6", values.get("before").getAsString());
+        assertEquals("3", values.get("effective").getAsString());
+        assertEquals("future_join_checks", values.get("application_scope").getAsString());
+        assertNotNull(values.get("operation_id")); assertNotNull(values.get("policy_revision"));
+    }
+
+    @Test void physicalAdministratorReadReportsExactIdentityLocationAndDefaultWithoutRosters() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new FantasyStickLifecycleNativeTest.Actor(data);
+            doReturn(true).when(admin.player).hasPermission("fantasystick.admin");
+            doReturn("Administrator").when(admin.player).getName();
+            f.players.put(admin.core.id, admin.player);
+            f.adminCommand.execute(admin.player, "fstickadmin", new String[]{"config", PartySettings.KEY});
+            for (int i = 0; i < 200 && config().isEmpty(); i++) Thread.sleep(10);
+            var observed = config(); assertEquals(1, observed.size());
+            var data = observed.getFirst().getAsJsonObject("data");
+            assertEquals(admin.core.id.toString(), data.get("player_id").getAsString());
+            assertEquals(admin.core.location.getX(), data.getAsJsonObject("location").get("x").getAsDouble());
+            f.plugin.setEnabled(false);
+        }
+        var entries = config(); assertEquals(1, entries.size());
+        var values = entries.getFirst().getAsJsonObject("data");
+        assertEquals("6", values.get("default").getAsString());
+        assertEquals("6", values.get("effective").getAsString());
+        assertEquals("player", values.get("actor_kind").getAsString());
+        assertEquals("Administrator", values.get("player_name").getAsString());
+        assertEquals("future_join_checks", values.get("application_scope").getAsString());
+        assertNotNull(values.getAsJsonObject("location").get("x"));
+    }
+
+    @Test void unavailableWriterRetainsSingleAcceptedPolicyIntentAcrossRestartWithoutAnotherWrite() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            var log = (games.dmg.fantasystick.events.LocalEventLog)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "eventLog");
+            log.close(); change(f, admin, "2");
+            assertEquals("2", ((PartySettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "partySettings")).value());
+            f.plugin.setEnabled(false);
+            assertTrue(config().isEmpty(), "Only exported segments count as evidence");
+            f.plugin.setEnabled(true);
+            for (int i = 0; i < 200 && config().isEmpty(); i++) Thread.sleep(10);
+            assertEquals("2", ((PartySettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "partySettings")).value());
+            f.plugin.setEnabled(false);
+        }
+        var entries = config(); assertEquals(1, entries.size());
+        assertEquals("2", entries.getFirst().getAsJsonObject("data").get("effective").getAsString());
+    }
+
+    @Test void auditStoreFailureCannotRollBackAnAcknowledgedLimitOrMutateGrandfatheredRoster() throws Exception {
+        Files.writeString(data.resolve("party-capacity-event-intents"), "blocked");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var leader = PartyCapacityNativeTest.actor(f, data);
+            var member = PartyCapacityNativeTest.actor(f, data);
+            var third = PartyCapacityNativeTest.actor(f, data);
+            var roster = PartyLifecycleNativeTest.parties(f);
+            var party = roster.create(leader.core.id).orElseThrow();
+            assertTrue(roster.accept(member.core.id, roster.invite(leader.core.id, party.id(), member.core.id)
+                .orElseThrow().id()));
+            assertTrue(roster.accept(third.core.id, roster.invite(leader.core.id, party.id(), third.core.id)
+                .orElseThrow().id()));
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            change(f, admin, "2");
+            assertEquals("2", ((PartySettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "partySettings")).value());
+            assertEquals(3, roster.partyOf(leader.core.id).orElseThrow().members().size());
+            assertTrue(roster.invite(leader.core.id, party.id(), java.util.UUID.randomUUID()).isEmpty());
+            f.plugin.setEnabled(false);
+        }
+        assertTrue(config().isEmpty(), "Intent-store failure cannot fabricate an exported success");
+    }
+
+    @Test void callbackAfterCloseDoesNotInventAnUnpublishedRuntimeChange() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var settings = (PartySettings) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "partySettings");
+            var worker = (java.util.concurrent.ExecutorService) FantasyStickLifecycleNativeTest.Fixture.field(
+                settings, "worker");
+            var entered = new java.util.concurrent.CountDownLatch(1);
+            var release = new java.util.concurrent.CountDownLatch(1);
+            worker.execute(() -> {
+                entered.countDown();
+                try { release.await(); } catch (InterruptedException interrupted) { Thread.currentThread().interrupt(); }
+            });
+            assertTrue(entered.await(5, TimeUnit.SECONDS));
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", PartySettings.KEY, "2"});
+            try { f.plugin.setEnabled(false); } finally { release.countDown(); }
+            settings.drained().toCompletableFuture().get(5, TimeUnit.SECONDS);
+            while (!f.tasks.isEmpty()) f.tasks.remove().run();
+            assertEquals("6", settings.value()); assertTrue(config().isEmpty());
+            f.plugin.setEnabled(true);
+            assertEquals("2", ((PartySettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "partySettings")).value());
+            f.plugin.setEnabled(false);
+        }
+        assertTrue(config().isEmpty(), "Startup must not fabricate an earlier runtime publication");
+    }
+
+    @Test void failedFeedbackCannotReverseAcknowledgedLimitOrOwnedEvent() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            CommandSender broken = FantasyStickLifecycleNativeTest.port(CommandSender.class, (name, args) -> {
+                return switch (name) {
+                    case "hasPermission" -> true;
+                    case "sendMessage" -> throw new IllegalStateException("feedback delivery failed");
+                    default -> throw new AssertionError("Unexpected sender call " + name);
+                };
+            });
+            f.adminCommand.execute(broken, "fstickadmin", new String[]{"config", PartySettings.KEY, "2"});
+            var settings = (PartySettings) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "partySettings");
+            for (int i = 0; i < 30 && !"2".equals(settings.value()); i++) {
+                var callback = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(callback);
+                try { callback.run(); } catch (IllegalStateException feedback) {
+                    assertEquals("feedback delivery failed", feedback.getMessage());
+                }
+            }
+            assertEquals("2", settings.value());
+            for (int i = 0; i < 200 && config().isEmpty(); i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        assertEquals(1, config().size());
+        assertEquals("2", config().getFirst().getAsJsonObject("data").get("effective").getAsString());
+    }
+
+    private void change(FantasyStickLifecycleNativeTest.Fixture f,
+                        EquipmentAdminCommandNativeTest.Sender admin, String value) throws Exception {
+        int before = admin.messages.size();
+        f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", PartySettings.KEY, value});
+        for (int i = 0; i < 30 && admin.messages.size() == before; i++) {
+            var callback = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(callback); callback.run();
+        }
+        assertTrue(admin.messages.getLast().startsWith("Saved "), admin.messages.toString());
+    }
+
+    private List<JsonObject> config() throws Exception {
+        var entries = new ArrayList<JsonObject>(); var root = data.resolve("events");
+        if (!Files.isDirectory(root)) return entries;
+        try (var days = Files.list(root)) {
+            for (var day : days.filter(p -> p.getFileName().toString().matches("\\d{4}-\\d{2}-\\d{2}")
+                    && Files.isDirectory(p, java.nio.file.LinkOption.NOFOLLOW_LINKS)).toList()) {
+                try (var segments = Files.list(day)) {
+                    for (var path : segments.filter(p -> p.getFileName().toString().endsWith(".jsonl")).toList()) {
+                        var content = Files.readString(path); int end = content.lastIndexOf('\n');
+                        if (end < 0) continue;
+                        for (var line : content.substring(0, end).lines().toList()) if (!line.isBlank()) {
+                            var event = JsonParser.parseString(line).getAsJsonObject();
+                            if (event.get("type").getAsString().endsWith("config.read")
+                                    || event.get("type").getAsString().endsWith("config.changed")) {
+                                var values = event.getAsJsonObject("data");
+                                if (values.has("key") && PartySettings.KEY.equals(values.get("key").getAsString()))
+                                    entries.add(event);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return entries;
+    }
+}

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

@@ -0,0 +1,344 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import games.dmg.fantasystick.persistence.RoleplaySettings;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import org.bukkit.command.CommandSender;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+/** Availability is a saved policy and exit request, not a claim that every restoration completed. */
+class RoleplayAvailabilityEventsNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void registeredReadAndDisableRequestTwoOrdinaryExitsWithoutClaimingCompletedRestoration() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", RoleplaySettings.KEY});
+            assertTrue(admin.messages.getLast().contains("=false"));
+            var one = new FantasyStickLifecycleNativeTest.Actor(data);
+            var two = new FantasyStickLifecycleNativeTest.Actor(data);
+            var ordinary = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(one.core.id, one.player); f.players.put(two.core.id, two.player);
+            f.players.put(ordinary.core.id, ordinary.player);
+            f.activate(one); f.activate(two);
+            var ordinaryBefore = ordinary.core.snapshot();
+            change(f, admin, "true");
+            assertArrayEquals(ordinaryBefore, ordinary.core.snapshot());
+            var policy = (RoleplaySettings) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "roleplaySettings");
+            assertTrue(policy.disabled());
+            var sessions = (EquipmentSessions) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "sessions");
+            assertTrue(sessions.active(one.core.id).isEmpty()); assertTrue(sessions.active(two.core.id).isEmpty());
+            f.awaitCharacterAndReceipt(one); f.awaitCharacterAndReceipt(two);
+            assertNotNull(f.receipts().find(one.core.id).toCompletableFuture()
+                .get(5, TimeUnit.SECONDS).orElseThrow().lastExit());
+            assertNotNull(f.receipts().find(two.core.id).toCompletableFuture()
+                .get(5, TimeUnit.SECONDS).orElseThrow().lastExit());
+            var blocked = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(blocked.core.id, blocked.player);
+            var original = blocked.core.snapshot();
+            f.changed(blocked); PartyBookNativeTest.drain(f);
+            assertTrue(sessions.active(blocked.core.id).isEmpty());
+            assertArrayEquals(original, blocked.core.snapshot());
+            for (int i = 0; i < 200 && config().size() < 3; i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        var changes = config();
+        assertEquals(List.of("config.read", "config.changed", "game.availability_changed"), changes.stream()
+            .map(event -> event.get("type").getAsString().replace("games.dmg.minecraft.fantasystick.", ""))
+            .toList());
+        var config = changes.get(1).getAsJsonObject("data");
+        var availability = changes.get(2).getAsJsonObject("data");
+        assertEquals("false", config.get("before").getAsString());
+        assertEquals("true", config.get("effective").getAsString());
+        assertEquals(config.get("operation_id").getAsString(), availability.get("origin_admin_action_id").getAsString());
+        assertEquals(2, availability.get("exit_requested_count").getAsInt());
+        assertEquals(2, availability.get("exit_request_accepted_count").getAsInt());
+        assertEquals(0, availability.get("exit_confirmed_count").getAsInt(),
+            "The synchronous policy callback cannot attest later receipt completion");
+        assertEquals(2, availability.get("exit_pending_count").getAsInt());
+        assertEquals(0, availability.get("exit_failed_count").getAsInt());
+        assertTrue(availability.get("available_before").getAsBoolean());
+        assertFalse(availability.get("available_after").getAsBoolean());
+    }
+
+    @Test void failedNativeRestoreIsCountedSeparatelyFromPendingAndNeverConfirmedByToggle() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            var failed = new FantasyStickLifecycleNativeTest.Actor(data);
+            var intact = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(failed.core.id, failed.player); f.players.put(intact.core.id, intact.player);
+            f.activate(failed); f.activate(intact);
+            failed.core.mutation = () -> { throw new IllegalStateException("native restoration refused"); };
+            change(f, admin, "true");
+            failed.core.mutation = () -> {};
+            var failedReceipt = f.receipts().find(failed.core.id).toCompletableFuture()
+                .get(5, TimeUnit.SECONDS).orElseThrow();
+            assertNotNull(failedReceipt.pending(), "Failed native custody retains proof for recovery");
+            f.awaitCharacterAndReceipt(intact);
+            assertNotNull(f.receipts().find(intact.core.id).toCompletableFuture()
+                .get(5, TimeUnit.SECONDS).orElseThrow().lastExit());
+            for (int i = 0; i < 200 && config().size() < 2; i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        var result = config().stream().filter(event -> event.get("type").getAsString()
+            .endsWith("game.availability_changed")).findFirst().orElseThrow().getAsJsonObject("data");
+        assertEquals(2, result.get("exit_requested_count").getAsInt());
+        assertEquals(1, result.get("exit_failed_count").getAsInt());
+        assertEquals(1, result.get("exit_pending_count").getAsInt());
+        assertEquals(1, result.get("exit_native_restored_pending_receipt_count").getAsInt());
+        assertEquals(0, result.get("exit_confirmed_count").getAsInt());
+    }
+
+    @Test void deniedInvalidOrFailedSaveCannotExportReadChangeOrAvailability() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            var active = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(active.core.id, active.player); f.activate(active);
+            admin.allowed = false;
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", RoleplaySettings.KEY});
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", RoleplaySettings.KEY, "true"});
+            admin.allowed = true;
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", RoleplaySettings.KEY, "TRUE"});
+            assertTrue(admin.messages.getLast().contains("true|false"));
+            Files.createDirectory(data.resolve("config.yml"));
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", RoleplaySettings.KEY, "true"});
+            for (int i = 0; i < 20 && !admin.messages.getLast().contains("save failed"); i++) {
+                var callback = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(callback); callback.run();
+            }
+            assertTrue(admin.messages.getLast().contains("save failed"));
+            assertFalse(((RoleplaySettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "roleplaySettings")).disabled());
+            assertTrue(((EquipmentSessions) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "sessions")).active(active.core.id).isPresent());
+            f.plugin.setEnabled(false);
+        }
+        assertTrue(config().isEmpty());
+    }
+
+    @Test void repeatedSettingDoesNotDuplicateAvailabilityAndReenableHasNoExitRequest() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            var active = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(active.core.id, active.player); f.activate(active);
+            change(f, admin, "true");
+            f.awaitCharacterAndReceipt(active);
+            change(f, admin, "true");
+            change(f, admin, "false");
+            for (int i = 0; i < 200 && config().size() < 4; i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        var entries = config();
+        assertEquals(4, entries.size(), "Read-free true/false changes have one config and one availability record each");
+        var availability = entries.stream().filter(e -> e.get("type").getAsString()
+            .endsWith("game.availability_changed")).map(e -> e.getAsJsonObject("data")).toList();
+        assertEquals(2, availability.size());
+        assertEquals(1, availability.getFirst().get("exit_requested_count").getAsInt());
+        assertEquals(0, availability.getLast().get("exit_requested_count").getAsInt());
+        assertFalse(availability.getFirst().get("available_after").getAsBoolean());
+        assertTrue(availability.getLast().get("available_after").getAsBoolean());
+    }
+
+    @Test void unavailableEventWriterRetainsOnePolicyTransitionForRestartReplayWithoutNewExits() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            var log = (games.dmg.fantasystick.events.LocalEventLog)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "eventLog");
+            log.close();
+            change(f, admin, "true");
+            f.plugin.setEnabled(false);
+            assertTrue(config().isEmpty(), "Pending intents are not exported day-segment evidence");
+            f.plugin.setEnabled(true);
+            for (int i = 0; i < 200 && config().size() < 2; i++) Thread.sleep(10);
+            assertTrue(((RoleplaySettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "roleplaySettings")).disabled());
+            f.plugin.setEnabled(false);
+        }
+        var entries = config(); assertEquals(2, entries.size());
+        var changed = entries.stream().filter(e -> e.get("type").getAsString().endsWith("config.changed"))
+            .findFirst().orElseThrow().getAsJsonObject("data");
+        var availability = entries.stream().filter(e -> e.get("type").getAsString()
+            .endsWith("game.availability_changed")).findFirst().orElseThrow().getAsJsonObject("data");
+        assertEquals(changed.get("operation_id").getAsString(),
+            availability.get("origin_admin_action_id").getAsString());
+        assertEquals(0, availability.get("exit_requested_count").getAsInt());
+    }
+
+    @Test void reversedSavedCallbacksCannotPublishSupersededDisableOrInventAnAvailabilityChange() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            for (int i = 0; i < 30 && !f.tasks.isEmpty(); i++) f.tasks.remove().run();
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            var actor = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(actor.core.id, actor.player); f.activate(actor);
+            f.awaitCharacterAndReceipt(actor); PartyBookNativeTest.drain(f);
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", RoleplaySettings.KEY, "true"});
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", RoleplaySettings.KEY, "false"});
+            var policy = (RoleplaySettings) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "roleplaySettings");
+            var worker = (java.util.concurrent.ExecutorService) FantasyStickLifecycleNativeTest.Fixture.field(
+                policy, "worker");
+            java.util.concurrent.CompletableFuture.runAsync(() -> {}, worker).get(5, TimeUnit.SECONDS);
+            var first = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(first);
+            var second = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(second);
+            second.run(); first.run();
+            assertFalse(policy.disabled());
+            assertTrue(((EquipmentSessions) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "sessions")).active(actor.core.id).isPresent());
+            f.plugin.setEnabled(false);
+        }
+        assertTrue(config().isEmpty(), "No effective availability transition was published");
+    }
+
+    @Test void administratorReadCapturesRealPlayerAndLocationWithoutPublishingPolicy() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new FantasyStickLifecycleNativeTest.Actor(data);
+            doReturn("Administrator").when(admin.player).getName();
+            doReturn(true).when(admin.player).hasPermission("fantasystick.admin");
+            f.players.put(admin.core.id, admin.player);
+            f.adminCommand.execute(admin.player, "fstickadmin", new String[]{"config", RoleplaySettings.KEY});
+            for (int i = 0; i < 200 && config().isEmpty(); i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+            var events = config(); assertEquals(1, events.size());
+            var read = events.getFirst().getAsJsonObject("data");
+            assertEquals(admin.core.id.toString(), read.get("player_id").getAsString());
+            assertEquals("Administrator", read.get("player_name").getAsString());
+            assertEquals("player", read.get("actor_kind").getAsString());
+            assertFalse(read.get("effective").getAsBoolean());
+            assertEquals(admin.core.location.getX(), read.getAsJsonObject("location").get("x").getAsDouble());
+        }
+        assertFalse(Files.exists(data.resolve("config.yml")));
+    }
+
+    @Test void closedLifetimeCannotPublishOrReplayAnOldAvailabilitySuccess() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var old = (RoleplaySettings) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "roleplaySettings");
+            var worker = (java.util.concurrent.ExecutorService) FantasyStickLifecycleNativeTest.Fixture.field(
+                old, "worker");
+            var entered = new java.util.concurrent.CountDownLatch(1);
+            var release = new java.util.concurrent.CountDownLatch(1);
+            worker.execute(() -> {
+                entered.countDown();
+                try { release.await(); } catch (InterruptedException interrupted) { Thread.currentThread().interrupt(); }
+            });
+            assertTrue(entered.await(5, TimeUnit.SECONDS));
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", RoleplaySettings.KEY, "true"});
+            try { f.plugin.setEnabled(false); } finally { release.countDown(); }
+            old.drained().toCompletableFuture().get(5, TimeUnit.SECONDS);
+            while (!f.tasks.isEmpty()) f.tasks.remove().run();
+            assertFalse(old.disabled(), "The disabled old command did not publish a late callback");
+            assertTrue(config().isEmpty());
+            f.plugin.setEnabled(true);
+            for (int i = 0; i < 40 && FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "sessions") == null; i++)
+                f.tick();
+            assertTrue(((RoleplaySettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "roleplaySettings")).disabled(), "The new boot loads the saved policy");
+            f.plugin.setEnabled(false);
+        }
+        assertTrue(config().isEmpty(), "Startup must not invent an old-lifetime admin action");
+    }
+
+    @Test void feedbackFailureCannotRollBackAcknowledgedPolicyOrItsAvailabilityRecords() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var actor = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(actor.core.id, actor.player); f.activate(actor);
+            CommandSender broken = FantasyStickLifecycleNativeTest.port(CommandSender.class, (name, args) -> {
+                return switch (name) {
+                    case "hasPermission" -> true;
+                    case "sendMessage" -> throw new IllegalStateException("feedback delivery failed");
+                    default -> throw new AssertionError("Unexpected sender call " + name);
+                };
+            });
+            f.adminCommand.execute(broken, "fstickadmin", new String[]{"config", RoleplaySettings.KEY, "true"});
+            for (int i = 0; i < 30 && !((RoleplaySettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                    f.plugin, "roleplaySettings")).disabled(); i++) {
+                var callback = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(callback);
+                try { callback.run(); } catch (IllegalStateException feedback) {
+                    assertEquals("feedback delivery failed", feedback.getMessage());
+                }
+            }
+            f.awaitCharacterAndReceipt(actor);
+            for (int i = 0; i < 200 && config().size() < 2; i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        var entries = config(); assertEquals(2, entries.size());
+        assertEquals(1, entries.stream().filter(e -> e.get("type").getAsString()
+            .endsWith("game.availability_changed")).count());
+        assertTrue(entries.stream().anyMatch(e -> e.get("type").getAsString().endsWith("config.changed")));
+    }
+
+    @Test void auditStoreFailureDoesNotPreventSavedDisableAndNativeExit() throws Exception {
+        Files.writeString(data.resolve("roleplay-availability-event-intents"), "unavailable");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var actor = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(actor.core.id, actor.player); f.activate(actor);
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            change(f, admin, "true");
+            f.awaitCharacterAndReceipt(actor);
+            assertTrue(((RoleplaySettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "roleplaySettings")).disabled());
+            assertTrue(((EquipmentSessions) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "sessions")).active(actor.core.id).isEmpty());
+            f.plugin.setEnabled(false);
+        }
+        assertTrue(config().isEmpty(), "An unavailable audit store cannot undo or claim the real transition");
+    }
+
+    private static void change(FantasyStickLifecycleNativeTest.Fixture f,
+                               EquipmentAdminCommandNativeTest.Sender admin, String value) throws Exception {
+        int responses = admin.messages.size();
+        f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", RoleplaySettings.KEY, value});
+        for (int i = 0; i < 30 && admin.messages.size() == responses; i++) {
+            var task = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(task); task.run();
+        }
+        assertTrue(admin.messages.getLast().startsWith("Saved "), admin.messages.toString());
+    }
+
+    private List<JsonObject> config() throws Exception {
+        var events = new ArrayList<JsonObject>();
+        var root = data.resolve("events");
+        if (!Files.isDirectory(root)) return events;
+        try (var days = Files.list(root)) {
+            for (var day : days.filter(path -> path.getFileName().toString().matches("\\d{4}-\\d{2}-\\d{2}")
+                    && Files.isDirectory(path, java.nio.file.LinkOption.NOFOLLOW_LINKS)).toList()) {
+                try (var segments = Files.list(day)) {
+                    for (var path : segments.filter(file -> file.getFileName().toString().endsWith(".jsonl")).toList()) {
+                        var content = Files.readString(path);
+                        int end = content.lastIndexOf('\n');
+                        if (end < 0) continue;
+                        for (var line : content.substring(0, end).lines().toList()) if (!line.isBlank()) {
+                            var event = JsonParser.parseString(line).getAsJsonObject();
+                            var type = event.get("type").getAsString();
+                            if (type.endsWith("game.availability_changed")
+                                || (type.endsWith("config.read") || type.endsWith("config.changed"))
+                                    && event.getAsJsonObject("data").has("key")
+                                    && event.getAsJsonObject("data").get("key").getAsString().equals(RoleplaySettings.KEY))
+                                events.add(event);
+                        }
+                    }
+                }
+            }
+        }
+        return events;
+    }
+}

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

@@ -0,0 +1,384 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import games.dmg.fantasystick.persistence.SheetResourcePackSettings;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import org.bukkit.event.player.PlayerResourcePackStatusEvent;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+/** Native optional delivery and actual status callbacks, not a cosmetic or request-only inference. */
+class SheetResourcePackEventsNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void startupNativeRequestAndRealAcceptedThenLoadedCallbacksExportDistinctEvents() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            var player = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(player.core.id, player.player);
+            f.plugin.setEnabled(true);
+            assertEquals(1, player.resourcePacks.size());
+            var request = SheetResourcePackNativeTest.request(player.resourcePacks.getFirst());
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", SheetResourcePackSettings.URL_KEY});
+            f.dispatcher.accept(new PlayerResourcePackStatusEvent(player.player, request.id(),
+                PlayerResourcePackStatusEvent.Status.ACCEPTED));
+            f.dispatcher.accept(new PlayerResourcePackStatusEvent(player.player, request.id(),
+                PlayerResourcePackStatusEvent.Status.SUCCESSFULLY_LOADED));
+            for (int i = 0; i < 200 && events().size() < 4; i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        var entries = events(); assertEquals(4, entries.size(), "Native delivery/status/read must reach exported JSONL");
+        assertEquals(1, entries.stream().filter(e -> e.get("type").getAsString().endsWith("delivery_requested")).count());
+        assertEquals(2, entries.stream().filter(e -> e.get("type").getAsString().endsWith("delivery_resolved")).count());
+        assertEquals(1, entries.stream().filter(e -> e.get("type").getAsString().endsWith("config.read")).count());
+    }
+
+    @Test void acknowledgedRedeliveryUsesDistinctRequestIdentitySoLateOldStatusCannotClaimNewLoad() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            var player = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(player.core.id, player.player); f.plugin.setEnabled(true);
+            var first = SheetResourcePackNativeTest.request(player.resourcePacks.getFirst());
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            var url = "https://packs.example.test/sheet-v2.zip?secret=do-not-export";
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{
+                "config", SheetResourcePackSettings.URL_KEY, url});
+            for (int i = 0; i < 30 && player.resourcePacks.size() < 2; i++) {
+                var callback = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(callback); callback.run();
+            }
+            var second = SheetResourcePackNativeTest.request(player.resourcePacks.getLast());
+            assertNotEquals(first.id(), second.id(), "A status exposes only pack ID; each offer needs a distinct ID");
+            f.dispatcher.accept(new PlayerResourcePackStatusEvent(player.player, first.id(),
+                PlayerResourcePackStatusEvent.Status.SUCCESSFULLY_LOADED));
+            f.dispatcher.accept(new PlayerResourcePackStatusEvent(player.player, second.id(),
+                PlayerResourcePackStatusEvent.Status.DECLINED));
+            for (int i = 0; i < 200 && events().size() < 4; i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        assertTrue(events().stream().noneMatch(e -> e.toString().contains("do-not-export")));
+        var requested = events().stream().filter(e -> e.get("type").getAsString().endsWith("delivery_requested")).toList();
+        assertEquals(2, requested.size());
+        var statuses = events().stream().filter(e -> e.get("type").getAsString().endsWith("delivery_resolved")).toList();
+        assertEquals(1, statuses.size(), "A late prior-request callback cannot claim current client load");
+        assertEquals("declined", statuses.getFirst().getAsJsonObject("data").get("status").getAsString());
+    }
+
+    @Test void reloadCannotAssignAnOldLifetimeStatusToANewStartupOffer() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            var player = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(player.core.id, player.player);
+            f.plugin.setEnabled(true);
+            var old = SheetResourcePackNativeTest.request(player.resourcePacks.getLast());
+            f.plugin.setEnabled(false);
+            f.plugin.setEnabled(true);
+            var current = SheetResourcePackNativeTest.request(player.resourcePacks.getLast());
+            assertNotEquals(old.id(), current.id(), "Old callbacks must never identify a new lifetime's offer");
+            f.dispatcher.accept(new PlayerResourcePackStatusEvent(player.player, old.id(),
+                PlayerResourcePackStatusEvent.Status.SUCCESSFULLY_LOADED));
+            for (int i = 0; i < 200 && events().size() < 2; i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        assertEquals(2, events().stream().filter(e -> e.get("type").getAsString()
+            .endsWith("delivery_requested")).count());
+        assertTrue(events().stream().noneMatch(e -> e.get("type").getAsString()
+            .endsWith("delivery_resolved")));
+    }
+
+    @Test void joinAndNativeOutcomesAreDistinctDeduplicatedAndNeverImplyAnUnobservedLoad() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var player = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(player.core.id, player.player);
+            f.dispatcher.accept(new org.bukkit.event.player.PlayerJoinEvent(player.player,
+                (net.kyori.adventure.text.Component)null));
+            var request = SheetResourcePackNativeTest.request(player.resourcePacks.getFirst());
+            for (var status : List.of(PlayerResourcePackStatusEvent.Status.ACCEPTED,
+                    PlayerResourcePackStatusEvent.Status.DOWNLOADED,
+                    PlayerResourcePackStatusEvent.Status.FAILED_DOWNLOAD,
+                    PlayerResourcePackStatusEvent.Status.FAILED_DOWNLOAD))
+                f.dispatcher.accept(new PlayerResourcePackStatusEvent(player.player, request.id(), status));
+            f.dispatcher.accept(new PlayerResourcePackStatusEvent(player.player, java.util.UUID.randomUUID(),
+                PlayerResourcePackStatusEvent.Status.SUCCESSFULLY_LOADED));
+            for (int i = 0; i < 200 && events().size() < 4; i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        var entries = events(); assertEquals(4, entries.size());
+        var requested = entries.stream().filter(e -> e.get("type").getAsString().endsWith("delivery_requested")).toList();
+        assertEquals("join", requested.getFirst().getAsJsonObject("data").get("trigger").getAsString());
+        var statuses = entries.stream().filter(e -> e.get("type").getAsString().endsWith("delivery_resolved")).toList();
+        assertEquals(List.of("accepted", "downloaded", "failed_download"), statuses.stream()
+            .map(e -> e.getAsJsonObject("data").get("status").getAsString()).toList());
+        assertTrue(statuses.stream().allMatch(e -> e.getAsJsonObject("data")
+            .get("origin_delivery_action_id").getAsString().equals(requested.getFirst().getAsJsonObject("data")
+                .get("action_id").getAsString())));
+    }
+
+    @Test void authorizedPhysicalReadsAndRefusalsNeverLeakUrlSecretsOrClaimFailedChanges() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(admin.core.id, admin.player);
+            doReturn(true).when(admin.player).hasPermission("fantasystick.admin");
+            doReturn("Administrator").when(admin.player).getName();
+            f.adminCommand.execute(admin.player, "fstickadmin", new String[]{"config", SheetResourcePackSettings.URL_KEY});
+            f.adminCommand.execute(admin.player, "fstickadmin", new String[]{"config", SheetResourcePackSettings.SHA1_KEY});
+            for (int i = 0; i < 200 && events().size() < 2; i++) Thread.sleep(10);
+            var reads = events(); assertEquals(2, reads.size());
+            assertEquals(admin.core.id.toString(), reads.getFirst().getAsJsonObject("data")
+                .get("player_id").getAsString());
+            assertEquals(admin.core.location.getX(), reads.getFirst().getAsJsonObject("data")
+                .getAsJsonObject("location").get("x").getAsDouble());
+            var sender = new EquipmentAdminCommandNativeTest.Sender(); sender.allowed = false;
+            f.adminCommand.execute(sender.port, "fstickadmin", new String[]{"config", SheetResourcePackSettings.URL_KEY});
+            f.adminCommand.execute(sender.port, "fstickadmin", new String[]{"config", SheetResourcePackSettings.URL_KEY,
+                "https://packs.example.test/other.zip?secret=do-not-export"});
+            sender.allowed = true;
+            f.adminCommand.execute(sender.port, "fstickadmin", new String[]{"config", SheetResourcePackSettings.URL_KEY,
+                "http://packs.example.test/invalid.zip"});
+            f.adminCommand.execute(sender.port, "fstickadmin", new String[]{"config", SheetResourcePackSettings.SHA1_KEY,
+                "not-a-hash"});
+            Files.createDirectory(data.resolve("config.yml"));
+            f.adminCommand.execute(sender.port, "fstickadmin", new String[]{"config", SheetResourcePackSettings.URL_KEY,
+                "https://packs.example.test/other.zip?secret=do-not-export"});
+            for (int i = 0; i < 30 && !sender.messages.getLast().contains("save failed"); i++) {
+                var callback = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(callback); callback.run();
+            }
+            assertTrue(sender.messages.getLast().contains("save failed"));
+            f.plugin.setEnabled(false);
+        }
+        assertEquals(2, events().size());
+        assertTrue(events().stream().noneMatch(e -> e.toString().contains("do-not-export")));
+    }
+
+    @Test void writerUnavailableRetainsOneAcknowledgedChangeForReplayAfterRestart() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var log = (games.dmg.fantasystick.events.LocalEventLog)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "eventLog");
+            log.close();
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            f.adminCommand.execute(sender.port, "fstickadmin", new String[]{
+                "config", SheetResourcePackSettings.SHA1_KEY, "a".repeat(40)});
+            for (int i = 0; i < 30 && sender.messages.isEmpty(); i++) {
+                var callback = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(callback); callback.run();
+            }
+            assertTrue(sender.messages.getLast().startsWith("Saved "));
+            f.plugin.setEnabled(false);
+            assertTrue(events().stream().noneMatch(e -> e.get("type").getAsString().endsWith("config.changed")));
+            f.plugin.setEnabled(true);
+            for (int i = 0; i < 200 && events().stream().noneMatch(e -> e.get("type").getAsString()
+                    .endsWith("config.changed")); i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        var changes = events().stream().filter(e -> e.get("type").getAsString().endsWith("config.changed")).toList();
+        assertEquals(1, changes.size());
+        assertEquals("a".repeat(40), changes.getFirst().getAsJsonObject("data").get("effective").getAsString());
+    }
+
+    @Test void closedOldCallbackAndFailedFeedbackNeverFabricateClientLoadOrReverseSavedPair() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            CommandSender broken = FantasyStickLifecycleNativeTest.port(CommandSender.class, (name, args) -> {
+                return switch (name) {
+                    case "hasPermission" -> true;
+                    case "sendMessage" -> throw new IllegalStateException("feedback delivery failed");
+                    default -> throw new AssertionError("Unexpected sender call " + name);
+                };
+            });
+            f.adminCommand.execute(broken, "fstickadmin", new String[]{
+                "config", SheetResourcePackSettings.SHA1_KEY, "a".repeat(40)});
+            var settings = (SheetResourcePackSettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "sheetResourcePackSettings");
+            for (int i = 0; i < 30 && !"a".repeat(40).equals(settings.sha1()); i++) {
+                var callback = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(callback);
+                try { callback.run(); } catch (IllegalStateException feedback) {
+                    assertEquals("feedback delivery failed", feedback.getMessage());
+                }
+            }
+            assertEquals("a".repeat(40), settings.sha1());
+            for (int i = 0; i < 200 && events().stream().noneMatch(e -> e.get("type").getAsString()
+                    .endsWith("config.changed")); i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        assertEquals(1, events().stream().filter(e -> e.get("type").getAsString().endsWith("config.changed")).count());
+        assertTrue(events().stream().noneMatch(e -> e.get("type").getAsString().endsWith("delivery_resolved")));
+    }
+
+    @Test void nativeOfferAndFeedbackFailureRemainOptionalAndCannotPreventStartup() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            var player = new FantasyStickLifecycleNativeTest.Actor(data);
+            Player broken = FantasyStickLifecycleNativeTest.port(Player.class, (name, args) -> {
+                if (name.equals("addResourcePack")) throw new IllegalStateException("native offer failed");
+                if (name.equals("sendMessage")) throw new IllegalStateException("feedback failed");
+                var arguments = args == null ? new Object[0] : args;
+                var matching = java.util.Arrays.stream(Player.class.getMethods())
+                    .filter(method -> method.getName().equals(name) && method.getParameterCount() == arguments.length)
+                    .filter(method -> java.util.stream.IntStream.range(0, arguments.length)
+                        .allMatch(i -> arguments[i] == null || method.getParameterTypes()[i].isInstance(arguments[i])
+                            || method.getParameterTypes()[i].isPrimitive()))
+                    .findFirst().orElseThrow();
+                try { return matching.invoke(player.player, arguments); }
+                catch (ReflectiveOperationException failed) { throw new IllegalStateException(failed); }
+            });
+            f.players.put(player.core.id, broken);
+            assertDoesNotThrow(() -> f.plugin.setEnabled(true));
+            for (int i = 0; i < 200 && events().isEmpty(); i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        var requested = events().stream().filter(e -> e.get("type").getAsString().endsWith("delivery_requested")).toList();
+        assertEquals(1, requested.size());
+        assertEquals("native_offer_failed", requested.getFirst().getAsJsonObject("data").get("outcome").getAsString());
+        assertTrue(events().stream().noneMatch(e -> e.get("type").getAsString().endsWith("delivery_resolved")));
+    }
+
+    @Test void unavailableLocationIsExplicitlyQualifiedWithoutBlockingNativeOfferAndStatus() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var player = mock(Player.class);
+            when(player.isOnline()).thenReturn(true);
+            when(player.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            when(player.getName()).thenReturn("LocationUnavailable");
+            when(player.getLocation()).thenThrow(new IllegalArgumentException("World unloaded"));
+            var delivery = (games.dmg.fantasystick.presentation.SheetResourcePack)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "sheetResourcePack");
+            delivery.deliver(player);
+            var offered = org.mockito.ArgumentCaptor.forClass(java.util.UUID.class);
+            verify(player).addResourcePack(offered.capture(), anyString(), any(byte[].class), anyString(), eq(false));
+            f.dispatcher.accept(new PlayerResourcePackStatusEvent(player, offered.getValue(),
+                PlayerResourcePackStatusEvent.Status.DECLINED));
+            for (int i = 0; i < 200 && events().size() < 2; i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        var entries = events(); assertEquals(2, entries.size());
+        assertTrue(entries.stream().allMatch(e -> e.getAsJsonObject("data").has("location_status")
+            && "unavailable".equals(e.getAsJsonObject("data").get("location_status").getAsString())));
+        assertTrue(entries.stream().allMatch(e -> !e.getAsJsonObject("data").has("location")));
+    }
+
+    @Test void failedAuditIntentCannotPreventOptionalDeliveryOrSaveBeforeRedelivery() throws Exception {
+        Files.writeString(data.resolve("sheet-resource-pack-event-intents"), "blocked");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            var player = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(player.core.id, player.player);
+            f.plugin.setEnabled(true);
+            assertEquals(1, player.resourcePacks.size());
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{
+                "config", SheetResourcePackSettings.SHA1_KEY, "a".repeat(40)});
+            for (int i = 0; i < 30 && player.resourcePacks.size() < 2; i++) {
+                var callback = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(callback); callback.run();
+            }
+            assertEquals(2, player.resourcePacks.size());
+            assertArrayEquals(java.util.HexFormat.of().parseHex("a".repeat(40)),
+                SheetResourcePackNativeTest.request(player.resourcePacks.getLast()).hash());
+            f.plugin.setEnabled(false);
+        }
+        assertTrue(events().isEmpty(), "The unavailable audit writer cannot manufacture exported evidence");
+    }
+
+    @Test void supersededSavedCallbacksNeverRedeliverOrRecordTheStalePair() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            var player = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(player.core.id, player.player);
+            f.plugin.setEnabled(true);
+            f.awaitCharacterAndReceipt(player);
+            PartyBookNativeTest.drain(f);
+            while (!f.tasks.isEmpty()) f.tasks.remove().run();
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            var callbacks = new java.util.concurrent.LinkedBlockingQueue<Runnable>();
+            var command = FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "admin");
+            var scheduler = command.getClass().getDeclaredField("nextTick");
+            scheduler.setAccessible(true);
+            var original = scheduler.get(command);
+            try {
+                scheduler.set(command, (java.util.function.Consumer<Runnable>)callbacks::add);
+                f.adminCommand.execute(admin.port, "fstickadmin", new String[]{
+                    "config", SheetResourcePackSettings.SHA1_KEY, "a".repeat(40)});
+                var first = callbacks.poll(5, TimeUnit.SECONDS); assertNotNull(first);
+                f.adminCommand.execute(admin.port, "fstickadmin", new String[]{
+                    "config", SheetResourcePackSettings.SHA1_KEY, "b".repeat(40)});
+                var second = callbacks.poll(5, TimeUnit.SECONDS); assertNotNull(second);
+                second.run(); first.run();
+            } finally { scheduler.set(command, original); }
+            var settings = (SheetResourcePackSettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "sheetResourcePackSettings");
+            assertEquals("b".repeat(40), settings.sha1());
+            assertEquals(2, player.resourcePacks.size(), "Only the latest acknowledged policy redelivers");
+            for (int i = 0; i < 200 && events().stream().noneMatch(e -> e.get("type").getAsString()
+                    .endsWith("config.changed")); i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        var changes = events().stream().filter(e -> e.get("type").getAsString().endsWith("config.changed")).toList();
+        assertEquals(1, changes.size());
+        assertEquals("b".repeat(40), changes.getFirst().getAsJsonObject("data").get("effective").getAsString());
+    }
+
+    @Test void closeBeforeSavedCallbackCannotClaimUnpublishedConfigOrDeliverPack() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            var player = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(player.core.id, player.player);
+            f.plugin.setEnabled(true);
+            var settings = (SheetResourcePackSettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "sheetResourcePackSettings");
+            var worker = (java.util.concurrent.ExecutorService) FantasyStickLifecycleNativeTest.Fixture.field(settings, "worker");
+            var entered = new java.util.concurrent.CountDownLatch(1);
+            var release = new java.util.concurrent.CountDownLatch(1);
+            worker.execute(() -> {
+                entered.countDown();
+                try { release.await(); } catch (InterruptedException interrupted) { Thread.currentThread().interrupt(); }
+            });
+            assertTrue(entered.await(5, TimeUnit.SECONDS));
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{
+                "config", SheetResourcePackSettings.SHA1_KEY, "a".repeat(40)});
+            try { f.plugin.setEnabled(false); } finally { release.countDown(); }
+            settings.drained().toCompletableFuture().get(5, TimeUnit.SECONDS);
+            while (!f.tasks.isEmpty()) f.tasks.remove().run();
+            assertEquals(1, player.resourcePacks.size());
+            assertTrue(events().stream().noneMatch(e -> e.get("type").getAsString().endsWith("config.changed")));
+            f.plugin.setEnabled(true);
+            assertEquals("a".repeat(40), ((SheetResourcePackSettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "sheetResourcePackSettings")).sha1());
+            f.plugin.setEnabled(false);
+        }
+        assertTrue(events().stream().noneMatch(e -> e.get("type").getAsString().endsWith("config.changed")));
+    }
+
+    private List<JsonObject> events() throws Exception {
+        var entries = new ArrayList<JsonObject>(); var root = data.resolve("events");
+        if (!Files.isDirectory(root)) return entries;
+        try (var days = Files.list(root)) {
+            for (var day : days.filter(p -> p.getFileName().toString().matches("\\d{4}-\\d{2}-\\d{2}")
+                    && Files.isDirectory(p, java.nio.file.LinkOption.NOFOLLOW_LINKS)).toList()) {
+                try (var segments = Files.list(day)) {
+                    for (var path : segments.filter(p -> p.getFileName().toString().endsWith(".jsonl")).toList()) {
+                        var content = Files.readString(path); int end = content.lastIndexOf('\n');
+                        if (end < 0) continue;
+                        for (var line : content.substring(0, end).lines().toList()) if (!line.isBlank()) {
+                            var event = JsonParser.parseString(line).getAsJsonObject();
+                            var type = event.get("type").getAsString();
+                            if (type.endsWith("resource_pack.delivery_requested")
+                                    || type.endsWith("resource_pack.delivery_resolved")
+                                    || (type.endsWith("config.read") || type.endsWith("config.changed"))
+                                        && event.getAsJsonObject("data").has("key")
+                                        && event.getAsJsonObject("data").get("key").getAsString().startsWith("sheet-resource-pack-"))
+                                entries.add(event);
+                        }
+                    }
+                }
+            }
+        }
+        return entries;
+    }
+}

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

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