fix(reference): Death Events remember a right-hand neighbour, not a board index

A Deathrattle summon used the dying minion's board index from before the
Death Creation Step removed anything. That index is stale when a minion to
its left dies in the same step, so the token landed one place too far right.

Each Death Event now records `before`: the nearest minion to the right that
is not dying in the same step. The position handed to the effect context is
resolved when the trigger resolves: the current index of `before`, or the
right end. Applied to the Rust and TS references of Modules 3-10.

Module 3 gains two tests, documented in scenarios.md:
test_03_summon_position_after_simultaneous_deaths (fails before the fix) and
test_03_simultaneous_summons_keep_board_order.

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

course/08-push-chains/reference/ts/src/engine/death.ts

@@ -5,7 +5,7 @@
 // ends. Then this step removes every marked minion at once.
 
 import type { Event } from "./event";
-import type { World } from "./world";
+import type { EntityId, World } from "./world";
 
 /**
  * Remove every mortally wounded or pending-destroy minion from play, simultaneously.
@@ -13,9 +13,17 @@ import type { World } from "./world";
  */
 export function deathCreationStep(world: World): Event[] {
   const dying = world.minionsInPlay().filter((id) => world.isDoomed(id));
-  // Every position is read before anything moves: removal is simultaneous, and each
-  // Death Event remembers where its minion stood when the step began.
-  const deaths = dying.map((id) => ({ type: "Destroyed" as const, id, position: world.boardIndex(id)! }));
-  for (const { id, position } of deaths) world.kill(id, position);
+  // Every neighbour is read before anything moves: removal is simultaneous. Each Death
+  // Event remembers where its minion stood as a handle, the minion that stays to its
+  // right, not as a board index: an index goes stale as soon as a minion further left
+  // leaves play in the same step (Module 1: hold handles, not indexes).
+  const deaths = dying.map((id) => ({ type: "Destroyed" as const, id, before: survivorToTheRight(world, id) }));
+  for (const { id, before } of deaths) world.kill(id, before);
   return deaths;
 }
+
+/** The nearest minion to the right of `id` on its board that is not leaving play in this step, if any. */
+function survivorToTheRight(world: World, id: EntityId): EntityId | undefined {
+  const board = world.zone(world.ownerOf(id), "board");
+  return board.slice(board.indexOf(id) + 1).find((other) => !world.isDoomed(other));
+}

course/08-push-chains/reference/ts/src/engine/effect.ts

@@ -60,7 +60,7 @@ function targets(target: Target, ctx: Ctx): EntityId[] {
 
 /**
  * Where a summon goes: to the right of a source still on the board; where a dead
- * source stood (its Death Event's position); at the right end for a spell.
+ * source stood (left of the minion its Death Event remembers); at the right end for a spell.
  */
 function summonPosition(ctx: Ctx): number | undefined {
   const index = ctx.source === undefined ? undefined : ctx.world.boardIndex(ctx.source);

course/08-push-chains/reference/ts/src/engine/event.ts

@@ -14,9 +14,11 @@ export type Event =
   | { type: "SpellCast"; card: string }
   /**
    * A Death Event: the Death Creation Step moved `id` from play to the graveyard.
-   * `position` is the board index it had when the step began; its Deathrattle summons there.
+   * `before` is the nearest minion to its right that did not die in the same step, if any:
+   * its Deathrattle summons immediately left of that minion, or at the right end. It is a
+   * handle because a board index goes stale when a minion further left dies in the same step.
    */
-  | { type: "Destroyed"; id: EntityId; position: number }
+  | { type: "Destroyed"; id: EntityId; before: EntityId | undefined }
   | { type: "DeathPhase"; round: number }
   /** A minion was played from hand (it has just entered the board). Its Battlecry answers this. */
   | { type: "Played"; id: EntityId };

course/08-push-chains/reference/ts/src/engine/queue.ts

@@ -55,8 +55,8 @@ export class Ctx {
     /** The chosen target, if any. */
     readonly target?: EntityId,
     /**
-     * The source's board position. For a Deathrattle, the source has left play,
-     * and this is the position its Death Event remembered.
+     * The source's board position. For a Deathrattle, the source has left play, and
+     * this is where it stood: immediately left of the minion its Death Event remembers.
      */
     readonly position?: number,
   ) {}
@@ -188,12 +188,26 @@ function react(world: World, events: Event[]): void {
     const times = activations(world, world.ownerOf(source), trigger.on);
     for (let i = 0; i < times; i++) {
       world.record({ type: "Triggered", source, on: trigger.on });
-      const position = event.type === "Destroyed" && event.id === source ? event.position : world.boardIndex(source);
+      const position =
+        event.type === "Destroyed" && event.id === source
+          ? positionLeftOf(world, world.ownerOf(source), event.before)
+          : world.boardIndex(source);
       runEffects(world, trigger.effects, new Ctx(world, world.ownerOf(source), source, undefined, position));
     }
   }
 }
 
+/**
+ * The board index, right now, immediately left of `before` on `owner`'s board; the
+ * right end if `before` is undefined or no longer there. A Death Event remembers the
+ * minion, not an index, so this still holds after other minions have left or arrived.
+ */
+function positionLeftOf(world: World, owner: PlayerId, before: EntityId | undefined): number {
+  const board = world.zone(owner, "board");
+  const index = before === undefined ? -1 : board.indexOf(before);
+  return index < 0 ? board.length : index;
+}
+
 /**
  * Who may respond to `event`, in order of play: every minion in play and, for a
  * Death Event, the minion that died. It has left play, but its Deathrattle still answers.

course/08-push-chains/reference/ts/src/engine/world.ts

@@ -275,10 +275,10 @@ export class World {
   }
 
   /** Move a minion from play to its owner's graveyard, recording its Death Event. */
-  kill(id: EntityId, position: number): void {
+  kill(id: EntityId, before: EntityId | undefined): void {
     this.entity(id).pendingDestroy = false;
     this.moveTo(id, "graveyard");
-    this.record({ type: "Destroyed", id, position });
+    this.record({ type: "Destroyed", id, before });
   }
 
   gainArmor(player: PlayerId, amount: number): void {