Five fidelity gaps closed: teleport escapes, slime traps, the Big Man

moves like a giant, and the boards are diagram-verified

TELEPORT as a counteraction (official FAQ: "the attack has no chance
of hitting you"): the defender names an escape square within four
spaces, the escape resolves before anything lands, and an ANTI-ANTI
pins their boots to the floor. Additive — no revision gate needed.

FILL SQUARE WITH SLIME holds spells now: an attack cast at the slime
sticks in the gel (leaving the discard pile), springs once at whoever
is inside or next enters, and counteractions against the trapped
blast cannot touch its caster — reflections vanish into the ooze. A
five-point waterbolt washes the slime and its cargo away, and the
waterwall waves clear slime from their path.

BIG MAN, under rules rev 5, finally moves like the card says: he
pushes players and monsters down the corridor ahead of him (stuck or
unpushable occupants block his advance), steps over a pit, tacks, or
killer ooze for two movement points without ever entering the square
(click two cells beyond the hazard), and monsters may not enter his
square. All gated so stored games replay under their own rules.

The boards were never wrong — the rulebook's Set-Up Diagram photo
confirms every pairing the code already had: 2p crossed, 3p stair
with the Aisle Warp arc, 4p/6p straight-across, 5p plus with all four
corner arcs. The stale TODOs are gone, replaced by tests pinning each
letter pair, and relocation's "only opposite board edges connect"
(which discards the aisle warp) is pinned too. Wall of Fire vs
Waterbolt turned out to be implemented and tested all along — its
TODO comment was the only thing wrong.

Also: hotseat saves now request durable storage (iOS evicts
unprotected origins under pressure).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

packages/engine/test/casting.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { applyCommand, activePlayer, boardView, createGame } from "../src/game";
-import { cellKey, edgeKey, hasLineOfSight, neighbor, type Side, SIDES } from "../src/board";
+import { cellKey, edgeKey, hasLineOfSight, neighbor, type Side, SIDES, stepTarget } from "../src/board";
 import type { CardInstance } from "../src/cards";
 import { newGame, must, giveCard, toRound2, faceOff } from "./helpers";
 
@@ -534,3 +534,139 @@ describe("zero-damage utility attacks", () => {
     expect(result.state.players.find((p) => p.id === defender)!.carriedTreasureId).toBe(treasure.id);
   });
 });
+
+describe("teleport as a counteraction", () => {
+  it("the attack has no chance of hitting you — you are simply elsewhere", () => {
+    let { state } = newGame();
+    state = toRound2(state);
+    const { attacker, defender } = faceOff(state);
+    const fb = giveCard(state, attacker, "fireball");
+    const tp = giveCard(state, defender, "teleport", "TP", 0);
+    const d = state.players.find((p) => p.id === defender)!;
+    const escape = { x: d.position.x, y: d.position.y + 1 };
+    state = must(state, attacker, {
+      type: "cast", instanceId: fb.instanceId, target: { kind: "player", playerId: defender },
+    });
+    state = must(state, defender, { type: "counteract", instanceId: tp.instanceId, params: { cell: escape } });
+    state = must(state, attacker, { type: "pass" });
+    state = must(state, defender, { type: "pass" });
+    const after = state.players.find((p) => p.id === defender)!;
+    expect(after.life).toBe(15);
+    expect(cellKey(after.position)).toBe(cellKey(escape));
+  });
+
+  it("ANTI-ANTI pins the boots: the escape never happens and the spell lands", () => {
+    let { state } = newGame();
+    state = toRound2(state);
+    const { attacker, defender } = faceOff(state);
+    const fb = giveCard(state, attacker, "fireball");
+    const aa = giveCard(state, attacker, "anti-anti", "AA", 1);
+    const tp = giveCard(state, defender, "teleport", "TP", 0);
+    const d = state.players.find((p) => p.id === defender)!;
+    const home = { ...d.position };
+    state = must(state, attacker, {
+      type: "cast", instanceId: fb.instanceId, target: { kind: "player", playerId: defender },
+    });
+    state = must(state, defender, { type: "counteract", instanceId: tp.instanceId, params: { cell: { x: home.x, y: home.y + 1 } } });
+    state = must(state, attacker, { type: "counteract", instanceId: aa.instanceId });
+    state = must(state, defender, { type: "pass" });
+    const after = state.players.find((p) => p.id === defender)!;
+    expect(cellKey(after.position)).toBe(cellKey(home));
+    expect(after.life).toBe(10);
+  });
+
+  it("reaches at most four spaces", () => {
+    let { state } = newGame();
+    state = toRound2(state);
+    const { attacker, defender } = faceOff(state);
+    const fb = giveCard(state, attacker, "fireball");
+    const tp = giveCard(state, defender, "teleport", "TP", 0);
+    const d = state.players.find((p) => p.id === defender)!;
+    state = must(state, attacker, {
+      type: "cast", instanceId: fb.instanceId, target: { kind: "player", playerId: defender },
+    });
+    const far = { x: d.position.x, y: d.position.y + 5 };
+    expect(applyCommand(state, defender, {
+      type: "counteract", instanceId: tp.instanceId, params: { cell: far },
+    }).ok).toBe(false);
+  });
+});
+
+describe("slime holds spells", () => {
+  function slimeRig() {
+    let { state } = createGame({ playerIds: ["alice", "bob"], seed: 42, sets: ["basic", "expansion1"], deckRev: 5 });
+    state = toRound2(state);
+    const caster = activePlayer(state);
+    const victim = state.players.find((p) => p.id !== caster.id)!;
+    // A slime square beside the victim, with the victim adjacent to walk in.
+    const spot = { x: victim.position.x, y: victim.position.y };
+    const cellBeside = (() => {
+      const view = boardView(state);
+      for (const side of SIDES) {
+        const t = stepTarget(view, spot, side);
+        if (t.kind === "step" && !state.players.some((p) => cellKey(p.position) === cellKey(t.to)) &&
+            !boardView(state).homes.some((h) => cellKey(h) === cellKey(t.to))) {
+          return { cell: t.to, side };
+        }
+      }
+      throw new Error("setup: no free square beside the victim");
+    })();
+    state.squareContents[cellKey(cellBeside.cell)] = { kind: "slime", damage: 0, createdBy: caster.id };
+    // The caster stands with the victim: one open edge to the slime = clear LOS.
+    caster.position = { ...victim.position };
+    return { state, caster: caster.id, victim: victim.id, slimeAt: cellBeside };
+  }
+
+  it("a fireball cast at the slime waits, then goes off on the next visitor", () => {
+    const rig = slimeRig();
+    let state = rig.state;
+    const fb = giveCard(state, rig.caster, "fireball");
+    state = must(state, rig.caster, {
+      type: "cast", instanceId: fb.instanceId, target: { kind: "cell", cell: rig.slimeAt.cell },
+    });
+    expect(Object.keys(state.slimeTraps).length).toBe(1);
+    state = must(state, rig.caster, { type: "endTurn", draw: 0 });
+    // The victim walks in: stuck, and the fireball erupts.
+    state = must(state, rig.victim, { type: "move", direction: rig.slimeAt.side });
+    expect(state.stack?.attackCard?.cardId).toBe("fireball");
+    expect(state.stack?.trapped).toBe(true);
+    state = must(state, rig.victim, { type: "pass" });
+    expect(state.players.find((p) => p.id === rig.victim)!.life).toBe(10);
+    expect(Object.keys(state.slimeTraps).length).toBe(0);
+  });
+
+  it("reflections off a trapped spell never touch its caster", () => {
+    const rig = slimeRig();
+    let state = rig.state;
+    const fb = giveCard(state, rig.caster, "fireball");
+    giveCard(state, rig.victim, "full-reflection", "FR", 0);
+    state = must(state, rig.caster, {
+      type: "cast", instanceId: fb.instanceId, target: { kind: "cell", cell: rig.slimeAt.cell },
+    });
+    state = must(state, rig.caster, { type: "endTurn", draw: 0 });
+    state = must(state, rig.victim, { type: "move", direction: rig.slimeAt.side });
+    state = must(state, rig.victim, { type: "counteract", instanceId: "full-reflection#FR" });
+    state = must(state, rig.caster, { type: "pass" });
+    state = must(state, rig.victim, { type: "pass" });
+    expect(state.players.find((p) => p.id === rig.caster)!.life).toBe(15);
+    expect(state.players.find((p) => p.id === rig.victim)!.life).toBe(15);
+  });
+
+  it("a five-point waterbolt washes the slime (and its cargo) away", () => {
+    const rig = slimeRig();
+    let state = rig.state;
+    const fb = giveCard(state, rig.caster, "fireball");
+    state = must(state, rig.caster, {
+      type: "cast", instanceId: fb.instanceId, target: { kind: "cell", cell: rig.slimeAt.cell },
+    });
+    state = must(state, rig.caster, { type: "endTurn", draw: 0 });
+    const wb = giveCard(state, rig.victim, "waterbolt", "WB", 0);
+    giveCard(state, rig.victim, "number-5", "N", 1);
+    state = must(state, rig.victim, {
+      type: "cast", instanceId: wb.instanceId, numberInstanceIds: ["number-5#N"],
+      target: { kind: "cell", cell: rig.slimeAt.cell },
+    });
+    expect(state.squareContents[cellKey(rig.slimeAt.cell)]).toBeUndefined();
+    expect(Object.keys(state.slimeTraps).length).toBe(0);
+  });
+});