feat(run): campfire rest site — rest or smith (content gap: rest-site)

First slice of the remaining genre content gaps: the StS-family REST SITE. Adds
StandardEvents.RestSite offering the two staple options — REST (heal a flat amount)
or SMITH (upgrade one player-chosen deck card, up to a max level). Authored purely on
existing standard run effects (Heal + UpgradeCards over a player-chosen upgradable-card
selector) with no engine privilege, so it's placed as an ordinary EventNode like any
other event. Smith is offered even with nothing upgradable (resolves to a clean no-op);
an availability gate is a follow-up.

Worked tests: rest heals only, smith upgrades the chosen card and doesn't heal, smith is
a no-op at max upgrade level.

Suite green: Run 332; format clean.

Author: Paranoidgrinch

src/RogueDeck.Run/Nodes/StandardEvents.cs

@@ -18,6 +18,25 @@ public static EventScript Rest(int healAmount)
             .Build();
     }
 
+    // A campfire / rest site with the genre's two staple options: REST (heal a flat amount) or SMITH (upgrade one
+    // deck card the player chooses, up to upgradeMaxLevel). Picking either ends the node. Built entirely on the
+    // standard run effects (Heal + UpgradeCards over a player-chosen upgradable-card selector) — no engine privilege.
+    // Smith is offered even with nothing upgradable left; it then resolves to no upgrade (an availability gate is a
+    // follow-up). Content packs place this as an EventNode carrying the script, like any other event.
+    public static EventScript RestSite(int healAmount, int upgradeMaxLevel = 1)
+    {
+        return new EventScriptBuilder("restSite")
+            .Situation("restSite", "event.restSite", situation => situation
+                .Choice("rest", choice => choice
+                    .TextKey("event.restSite.rest")
+                    .Heal(healAmount))
+                .Choice("smith", choice => choice
+                    .TextKey("event.restSite.smith")
+                    .UpgradeCards(
+                        RunSelectors.DeckCards.Upgradable(upgradeMaxLevel).ChooseByPlayer(1, "smith: upgrade a card"))))
+            .Build();
+    }
+
     // A treasure: take a reward bundle (the contents are whatever the author passes).
     public static EventScript Treasure(RewardId reward, params IRunEffectRequest[] contents)
     {

tests/RogueDeck.Run.Tests/RestSiteTests.cs

@@ -0,0 +1,75 @@
+using RogueDeck.Core.Combat;
+using RogueDeck.Run;
+
+namespace RogueDeck.Run.Tests;
+
+// The campfire / rest site content event (StandardEvents.RestSite): the genre's two staple options, REST (heal a
+// flat amount) or SMITH (upgrade one player-chosen deck card). It is authored purely on the standard run effects
+// (Heal + UpgradeCards over a player-chosen upgradable-card selector) — no engine privilege — so these tests drive
+// it exactly as a run would: an EventNode carrying the script, resolved with a scripted choice + entity chooser.
+public class RestSiteTests
+{
+    private static RunDefinitionRegistry BuildRegistry()
+    {
+        var builder = new RunDefinitionRegistryBuilder();
+        new StandardRunPackage().RegisterDefinitions(builder);
+        return builder.Build();
+    }
+
+    private static RunState DeckOf(int current, int max, params string[] kinds)
+    {
+        var run = new RunState(new RunId("run"), new HealthState(current, max), new RunMap(Array.Empty<Node>()));
+        foreach (var kind in kinds)
+            run.AddDeckCard(new CardDefinitionId(kind));
+        return run;
+    }
+
+    // Resolve the rest-site node once, taking the given choice; the scripted provider doubles as the entity chooser
+    // (it picks the first candidate) so a smith upgrades the first upgradable card in the deck.
+    private static void Play(RunState run, EventScript script, string choice)
+    {
+        var registry = BuildRegistry();
+        var processor = new RunEffectProcessor();
+        var provider = new ScriptedChoiceProvider(choice);
+        run.SetEntityChooser(provider);
+        var node = new Node(new NodeId("n"), StandardRunIds.EventNode, script);
+        new EventNodeResolver().Resolve(new NodeResolveContext(run, provider, registry, processor), node);
+        processor.ResolvePending(run, registry);
+    }
+
+    [Fact]
+    public void Rest_heals_the_flat_amount()
+    {
+        var run = DeckOf(20, 40, "strike", "defend");
+
+        Play(run, StandardEvents.RestSite(healAmount: 12), "rest");
+
+        Assert.Equal(32, run.Health.Current);                  // 20 + 12
+        Assert.All(run.Deck, c => Assert.Equal(0, c.UpgradeLevel)); // resting upgrades nothing
+    }
+
+    [Fact]
+    public void Smith_upgrades_the_chosen_deck_card_and_leaves_health_alone()
+    {
+        var run = DeckOf(20, 40, "strike", "defend");
+
+        Play(run, StandardEvents.RestSite(healAmount: 12), "smith");
+
+        var strike = run.Deck.Single(c => c.DefinitionId == new CardDefinitionId("strike"));
+        Assert.Equal(1, strike.UpgradeLevel);                  // the chosen (first upgradable) card is smithed
+        var defend = run.Deck.Single(c => c.DefinitionId == new CardDefinitionId("defend"));
+        Assert.Equal(0, defend.UpgradeLevel);                  // the other card is untouched
+        Assert.Equal(20, run.Health.Current);                  // smithing does not heal
+    }
+
+    [Fact]
+    public void Smith_does_not_re_upgrade_past_the_max_level()
+    {
+        var run = DeckOf(20, 40, "strike");
+        run.Deck[0].Upgrade();                                 // already at the default max (level 1)
+
+        Play(run, StandardEvents.RestSite(healAmount: 12, upgradeMaxLevel: 1), "smith");
+
+        Assert.Equal(1, run.Deck[0].UpgradeLevel);             // no upgradable card ⇒ smith is a clean no-op
+    }
+}