Slow Death's draw is one blow, countered against its total (table ruling)

Two cards drawn is a two-point blow: ABSORB soaks up to three of the
total, BLUNT halves it rounding up (so it finally earns a place — 2
becomes 1), counters may chain, declining takes the rest. The client
labels each counter with the exact points it leaves; the bots weigh
the total against their floor. Amends rev 13 minutes after it shipped;
every production ledger still replays clean.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015RCWSTnb1KYTPyL4GmhGnF

packages/engine/src/game.ts

@@ -284,9 +284,10 @@ export interface GameConfig {
    * number riding the cast fuels it, and numbers or POWER RUN points
    * played under the dash double; older games doubled only the base
    * allowance and consumed the rider without effect.
-   * Rev 13: SLOW DEATH's bites pause for a victim holding ABSORB — each
-   * absorb soaks exactly one point (FAQ: "only stop the damage incurred
-   * by one card"); older games bit instantly.
+   * Rev 13: SLOW DEATH's per-draw bites land as ONE blow that pauses
+   * for a victim holding ABSORB or BLUNT — countered against the total
+   * (absorb soaks up to 3, blunt halves rounding up); older games bit
+   * instantly.
    */
   deckRev?: number;
 }
@@ -304,8 +305,9 @@ export interface GameState {
   /** A treasure was just grabbed and its owner holds WARD:
    * the table waits while they choose to play it "at that time" or not. */
   wardPending: { ownerId: PlayerId; takerId: PlayerId } | null;
-  /** SLOW DEATH's bites hang while the victim decides whether an ABSORB
-   * soaks a point ("only stop the damage incurred by one card"). */
+  /** SLOW DEATH's bites hang while the victim weighs counteractions:
+   * the draw's total is one blow — ABSORB soaks up to three of it,
+   * BLUNT halves it rounding up (table ruling). */
   slowDeathPending: { playerId: PlayerId; points: number } | null;
   /** CHAOS is landing: each queued player may play FULL SHIELD to sit out. */
   chaosPending: { casterId: PlayerId; excluded: PlayerId[]; queue: PlayerId[] } | null;
@@ -752,7 +754,7 @@ export type GameEvent =
   | { type: "madDash"; player: PlayerId; newAllowance: number }
   | { type: "safeOpened"; player: PlayerId; cell: Cell; withCardId: string }
   | { type: "slowDeathWindow"; player: PlayerId; points: number }
-  | { type: "slowDeathAbsorbed"; player: PlayerId; remaining: number }
+  | { type: "slowDeathCountered"; player: PlayerId; cardId: string; remaining: number }
   | { type: "safeDamaged"; attacker: PlayerId; cell: Cell; amount: number; total: number }
   | { type: "safeSmashed"; attacker: PlayerId; cell: Cell }
   | { type: "trapSprung"; player: PlayerId; cardId?: string }
@@ -796,7 +798,7 @@ export type Command =
   | { type: "testIllusion"; cell: Cell; side: Side }
   | { type: "armWard" }
   | { type: "wardChoice"; play: boolean }
-  | { type: "slowDeathChoice"; absorbInstanceId?: string }
+  | { type: "slowDeathChoice"; counterInstanceId?: string }
   | { type: "warpStep" }
   | { type: "moveCreature"; creatureId: string; direction: Side }
   | { type: "creatureWarpStep"; creatureId: string }
@@ -3901,8 +3903,8 @@ function applyCommandInner(state: GameState, playerId: PlayerId, command: Comman
   // SLOW DEATH's window: the bites hang while the victim weighs an absorb.
   if (state.slowDeathPending) {
     if (playerId !== state.slowDeathPending.playerId) return err("waiting on the slow death's victim");
-    if (command.type !== "slowDeathChoice") return err("soak a point with an Absorb or take the bites");
-    return doSlowDeathChoice(state, playerId, command.absorbInstanceId);
+    if (command.type !== "slowDeathChoice") return err("counter the bites or take them");
+    return doSlowDeathChoice(state, playerId, command.counterInstanceId);
   }
 
   if (state.pendingDiscard) {
@@ -6704,10 +6706,12 @@ function applySlowDeathOnDraw(state: GameState, events: GameEvent[], p: PlayerSt
   }
   const bites = cardsDrawn * (curses.length - blessed);
   if (bites === 0) return;
-  // Rev 13, per the FAQ: ABSORB "will only stop the damage incurred by one
-  // card" — one point, one bite. A victim holding an ABSORB gets the choice
-  // before the bites land. Older games bit instantly and replay so.
-  if ((state.config.deckRev ?? 1) >= 13 && p.hand.some((c) => c.cardId === "absorb")) {
+  // Rev 13 (table ruling): the draw's bites land as ONE blow, countered
+  // against the total — ABSORB soaks up to three, BLUNT halves rounding
+  // up. A victim holding either gets the window; older games bit
+  // instantly and replay so.
+  if ((state.config.deckRev ?? 1) >= 13 &&
+      p.hand.some((c) => c.cardId === "absorb" || c.cardId === "blunt")) {
     state.slowDeathPending = { playerId: p.id, points: bites };
     events.push({ type: "slowDeathWindow", player: p.id, points: bites });
     return;
@@ -6719,22 +6723,28 @@ function applySlowDeathOnDraw(state: GameState, events: GameEvent[], p: PlayerSt
   checkVictory(state, events);
 }
 
-/** The victim's answer to hanging SLOW DEATH bites: each ABSORB soaks
- * exactly one point ("the damage incurred by one card" is one bite);
- * declining, or running out of absorbs, takes the rest. */
-function doSlowDeathChoice(prev: GameState, playerId: PlayerId, absorbInstanceId?: string): CommandResult {
+/** The victim's answer to hanging SLOW DEATH bites. The batch is one
+ * blow countered against its total: ABSORB soaks up to three points,
+ * BLUNT halves it rounding up, and counters may chain as they would
+ * against any attack. Declining takes what remains. */
+function doSlowDeathChoice(prev: GameState, playerId: PlayerId, counterInstanceId?: string): CommandResult {
   const state = clone(prev);
   const pending = state.slowDeathPending!;
   const p = state.players.find((q) => q.id === playerId)!;
   const events: GameEvent[] = [];
-  if (absorbInstanceId) {
-    const card = p.hand.find((c) => c.instanceId === absorbInstanceId);
-    if (!card || card.cardId !== "absorb") return err("that is not an Absorb in your hand");
-    takeFromHand(p, absorbInstanceId);
+  if (counterInstanceId) {
+    const card = p.hand.find((c) => c.instanceId === counterInstanceId);
+    if (!card || (card.cardId !== "absorb" && card.cardId !== "blunt")) {
+      return err("only an Absorb or a Blunt answers the rot");
+    }
+    takeFromHand(p, counterInstanceId);
     state.discard.push(card);
-    pending.points -= 1;
-    events.push({ type: "slowDeathAbsorbed", player: p.id, remaining: pending.points });
-    if (pending.points > 0 && p.hand.some((c) => c.cardId === "absorb")) {
+    pending.points = card.cardId === "absorb"
+      ? Math.max(0, pending.points - 3)
+      : Math.ceil(pending.points / 2);
+    events.push({ type: "slowDeathCountered", player: p.id, cardId: card.cardId, remaining: pending.points });
+    if (pending.points > 0 &&
+        p.hand.some((c) => c.cardId === "absorb" || c.cardId === "blunt")) {
       return { ok: true, state, events };
     }
   }