houserules/packages/chess/e2e/parity-rules.spec.ts

/**
 * T83 (Wave 15) — Playwright e2e for parity rules `all_on_red` and
 * `ice_physics`.
 *
 * Both rules use trigger-rooted cascades whose root is NOT
 * `on-rule-activated` wrapping `request-choice` (the shape T79's
 * `__test__.activate-descriptor` handles). They drive through the
 * T83 `__test__.apply-descriptor` debug frame, which runs the full
 * `applyCustomDescriptor` walker against `GAME_ENTITY` — that
 * walks every primitive in `descriptor.primitives` (matching what
 * a profile-time apply would do) AND fires `on-rule-activated`
 * hooks once per descriptor instance.
 *
 * ─────────────────────────────────────────────────────────────────────
 * Test 1 — all_on_red
 * ─────────────────────────────────────────────────────────────────────
 *
 * Descriptor (parity/all_on_red.json):
 *
 *   on-turn-start
 *     └── with-probability(p=0.1)
 *           └── seed-attribute(BlockAllExceptKing, true,
 *                              lifetime: turns/5)
 *
 * `applyCustomDescriptor` seeds `OnTurnStartHooks` on `GAME_ENTITY`.
 * Each subsequent `applyMove` fires the hook on the post-move
 * non-mover's color and calls into the inner arm. The
 * `with-probability` primitive draws from `engine.rng()` — we pin
 * `RngSeed = 1` server-side so the e2e is deterministic.
 *
 * The all_on_red unit test
 * (`packages/chess/src/__fixtures__/parity/all_on_red-real.test.ts`)
 * pins the locked numerics for seed=1: across N moves, the
 * probability draw lands inside (0, 0.1) on a known set of turn
 * indices. We don't reproduce that locked numeric set here — the
 * e2e's load-bearing pin is "after enough moves the
 * `BlockAllExceptKing` flag becomes observable on `GAME_ENTITY`",
 * which is the wire/UI-level cascade contract.
 *
 * Reading the flag: we walk through the page's
 * `__paratypeChessPrediction` PredictionManager export to query
 * the engine's session directly. This sidesteps the lack of a
 * UI rendering path for the `BlockAllExceptKing` attr (V1 doesn't
 * surface every game-level flag in the DOM; engine introspection
 * is the canonical "did the descriptor fire" probe).
 *
 * ─────────────────────────────────────────────────────────────────────
 * Test 2 — ice_physics
 * ─────────────────────────────────────────────────────────────────────
 *
 * Descriptor (parity/ice_physics.json):
 *
 *   on-rule-activated
 *     └── for-each-piece(filter: pieceType=bishop) → set-piece-attr(SlideMustBeMaxDistance=true)
 *     └── for-each-piece(filter: pieceType=rook)   → set-piece-attr(SlideMustBeMaxDistance=true)
 *     └── for-each-piece(filter: pieceType=queen)  → set-piece-attr(SlideMustBeMaxDistance=true)
 *
 * The `on-rule-activated` arm runs on first `applyCustomDescriptor`,
 * so by the time we drive moves every slider on the board carries
 * `SlideMustBeMaxDistance = true`. Move-gen consumers (Wave 12 /
 * T75) read the attr and filter the slider's legal-move set down
 * to ONLY the maximum-distance step on each ray.
 *
 * Concrete test: a clear bishop diagonal from c1 (white bishop)
 * after 1.b3 opens c1's diagonal. Pre-physics, c1→a3, b2, c3 (no,
 * blocked), d2 (no, blocked), … the bishop's legal squares are
 * {a3, b2}. With ice_physics, ONLY a3 (max-distance) is legal —
 * b2 is rejected because it's not the max step.
 *
 * Drive: drag the bishop from c1 to b2 → expect REJECTION (board
 * stays unchanged). Then drag c1→a3 → expect SUCCESS.
 *
 * The `b3` setup move is needed because c1's bishop starts blocked
 * on a fresh board (b2 + d2 are pawns); 1.b3 opens c1→a3 along
 * the a3-c1 diagonal AND opens c1→b2 (b2 is empty post-b3 because
 * the b-pawn moved off it). Wait — after 1.b3 the b-pawn is on
 * b3, so b2 is empty and c1→b2 is a legal one-step bishop move.
 * Actually 1.b4 or even 1.a3 doesn't help — the bishop's diagonal
 * needs b2 vacated. After 1.b3, b2 is empty AND a3 is empty, so
 * c1→{b2, a3} are both legal bishop moves. With ice_physics
 * active, only a3 should remain legal.
 */

import { test, expect, type Page } from '@playwright/test';
import { spawn, type ChildProcess } from 'node:child_process';
import { setTimeout as sleep } from 'node:timers/promises';
import { existsSync, mkdirSync, readFileSync } from 'node:fs';
import { join } from 'node:path';

// ---------------------------------------------------------------------------
// Server lifecycle (mirrors `multiplayer.spec.ts` / `request-choice.spec.ts`)
// ---------------------------------------------------------------------------

let wsServerProcess: ChildProcess | null = null;

async function isWsServerRunning(): Promise<boolean> {
  try {
    const res = await fetch('http://localhost:7357/healthz');
    return res.ok;
  } catch {
    return false;
  }
}

test.beforeAll(async () => {
  if (await isWsServerRunning()) return;
  wsServerProcess = spawn('bun', ['run', 'packages/server/src/index.ts'], {
    stdio: 'pipe',
    env: { ...process.env, PORT: '7357' },
  });
  for (let i = 0; i < 40; i++) {
    await sleep(250);
    if (await isWsServerRunning()) break;
  }
});

test.afterAll(async () => {
  if (wsServerProcess) {
    wsServerProcess.kill('SIGINT');
    await sleep(200);
    wsServerProcess = null;
  }
});

// ---------------------------------------------------------------------------
// Fixtures + screenshot helpers
// ---------------------------------------------------------------------------

const EVIDENCE_DIR = join(
  process.cwd(),
  '.sisyphus/evidence/wave15-t83-parity-screenshots',
);
if (!existsSync(EVIDENCE_DIR)) mkdirSync(EVIDENCE_DIR, { recursive: true });

const ALL_ON_RED_DESCRIPTOR = JSON.parse(
  readFileSync(
    join(process.cwd(), 'packages/chess/src/__fixtures__/parity/all_on_red.json'),
    'utf8',
  ),
) as Record<string, unknown>;

function allOnRedAlwaysFires(): Record<string, unknown> {
  const cloned = JSON.parse(JSON.stringify(ALL_ON_RED_DESCRIPTOR)) as {
    id: string;
    primitives: Array<{
      kind: string;
      params: { primitives: Array<{ kind: string; params: { p: number } }> };
    }>;
  };
  const onTurnStart = cloned.primitives[0]!;
  const withProbability = onTurnStart.params.primitives[0]!;
  if (withProbability.kind !== 'with-probability') {
    throw new Error(
      `parity fixture drift: expected on-turn-start > with-probability, got ${withProbability.kind}`,
    );
  }
  withProbability.params.p = 1.0;
  cloned.id = 'parity:all_on_red__test-p1';
  return cloned as unknown as Record<string, unknown>;
}

const ICE_PHYSICS_DESCRIPTOR = JSON.parse(
  readFileSync(
    join(process.cwd(), 'packages/chess/src/__fixtures__/parity/ice_physics.json'),
    'utf8',
  ),
) as Record<string, unknown>;

async function snapshot(page: Page, label: string): Promise<void> {
  await page.screenshot({
    path: join(EVIDENCE_DIR, `${label}.png`),
    fullPage: true,
  });
}

// ---------------------------------------------------------------------------
// Room helpers (raw WS — no Lobby UI involvement)
// ---------------------------------------------------------------------------

async function wsCreateRoom(
  page: Page,
): Promise<{ code: string; token: string; color: string }> {
  return page.evaluate(async () => {
    return new Promise<{ code: string; token: string; color: string }>(
      (resolve, reject) => {
        const ws = new WebSocket('ws://localhost:7357/ws');
        const timer = setTimeout(
          () => reject(new Error('wsCreateRoom: timeout')),
          5000,
        );
        ws.onopen = () => {
          ws.send(
            JSON.stringify({
              v: 1,
              seq: 1,
              ts: Date.now(),
              type: 'room.create',
              payload: {},
            }),
          );
        };
        ws.onmessage = (e: MessageEvent) => {
          const msg = JSON.parse(e.data as string) as {
            type: string;
            payload: { code: string; token: string; color: string; message?: string };
          };
          if (msg.type === 'room.created') {
            clearTimeout(timer);
            ws.close();
            resolve(msg.payload);
          } else if (msg.type === 'error') {
            clearTimeout(timer);
            ws.close();
            reject(new Error(msg.payload.message ?? 'room.create error'));
          }
        };
        ws.onerror = () => {
          clearTimeout(timer);
          reject(new Error('wsCreateRoom: WebSocket error'));
        };
      },
    );
  });
}

async function joinAsHost(
  page: Page,
): Promise<{ code: string; token: string; color: string }> {
  await page.goto('http://localhost:5173/');
  await page.waitForSelector('[data-testid="page-home"]');
  const room = await wsCreateRoom(page);
  await page.evaluate((r) => {
    sessionStorage.setItem('room-code', r.code);
    sessionStorage.setItem('room-token', r.token);
    sessionStorage.setItem('player-color', r.color);
  }, room);
  await page.goto('http://localhost:5173/game');
  await expect(page.locator('[data-testid="turn-indicator"]')).toBeVisible();
  // Wait for the GameClient + PredictionManager to install on
  // window — both test-debug frames travel through the client and
  // the engine probe reads through the manager.
  await page.waitForFunction(
    () =>
      Boolean(
        (globalThis as { __paratypeChessClient?: unknown }).__paratypeChessClient,
      ) &&
      Boolean(
        (globalThis as { __paratypeChessPrediction?: unknown })
          .__paratypeChessPrediction,
      ),
    null,
    { timeout: 5000 },
  );
  return room;
}

/**
 * Drive `__test__.apply-descriptor` through the page's existing
 * GameClient socket. The handler runs server-side, mutates the
 * engine via `applyCustomDescriptor`, and emits a fresh `game.state`
 * snapshot. The page's MultiplayerGame view re-renders the post-apply
 * board automatically.
 */
async function applyDescriptor(
  page: Page,
  args: {
    code: string;
    descriptor: unknown;
    rngSeed?: number;
    /**
     * T83: optional 0..63 LERF square to apply the descriptor to.
     * Resolves server-side to the piece-id at that square.
     * Required for descriptors whose root trigger is per-piece
     * (`on-turn-start`, `on-move`, `on-capture`, …) since the
     * dispatcher only walks pieces — a hook seeded on
     * `GAME_ENTITY` would never fire. Omit for `on-rule-activated`
     * descriptors (one-shot game-level cascade — `ice_physics`).
     */
    targetSquare?: number;
  },
): Promise<void> {
  await page.evaluate((a) => {
    const client = (
      globalThis as {
        __paratypeChessClient?: {
          send: (msg: { type: string; payload: unknown }) => void;
        };
      }
    ).__paratypeChessClient;
    if (!client)
      throw new Error('applyDescriptor: __paratypeChessClient not present');
    client.send({
      type: '__test__.apply-descriptor',
      payload: {
        roomCode: a.code,
        descriptor: a.descriptor,
        rngSeed: a.rngSeed,
        targetSquare: a.targetSquare,
      },
    });
  }, args);
}

/** Drag a piece via the same UI path the multiplayer e2e uses. */
const drag = async (page: Page, from: string, to: string): Promise<void> => {
  await page
    .locator(`[data-square="${from}"] [data-piece]`)
    .dragTo(page.locator(`[data-square="${to}"]`));
};

/**
 * Send `game.move` through the page's connected GameClient.
 *
 * Used by T83/all_on_red turn-driving to avoid occasional drag
 * flake when the source square locator races UI updates between
 * two contexts.
 */
async function sendMove(page: Page, from: string, to: string): Promise<void> {
  await page.evaluate(
    async (a) => {
      type Client = {
        send: (msg: { type: string; payload: unknown }) => void;
        sendMove?: (from: string, to: string) => void;
        readonly isConnected?: boolean;
      };
      const getClient = (): Client | undefined =>
        (globalThis as { __paratypeChessClient?: Client }).__paratypeChessClient;
      const deadline = Date.now() + 3000;
      let client = getClient();
      while (Date.now() < deadline) {
        client = getClient();
        if (client && client.isConnected === true) break;
        await new Promise((r) => setTimeout(r, 50));
      }
      if (!client || client.isConnected !== true) {
        throw new Error('sendMove: GameClient never became connected');
      }
      if (typeof client.sendMove === 'function') {
        client.sendMove(a.from, a.to);
        return;
      }
      client.send({
        type: 'game.move',
        payload: { from: a.from, to: a.to },
      });
    },
    { from, to },
  );
}

/**
 * Read a session attr via the page's PredictionManager. Returns
 * the engine's current attr value at `GAME_ENTITY` (or any entity
 * id) — used to verify trigger-fired writes that don't surface in
 * the DOM (e.g. `BlockAllExceptKing`).
 */
async function readGameAttr(
  page: Page,
  attr: string,
  entityId: number = -1, // GAME_ENTITY
): Promise<unknown> {
  return page.evaluate(
    (a) => {
      const mgr = (
        globalThis as {
          __paratypeChessPrediction?: {
            getCurrentEngine: () => {
              session: {
                get: (id: unknown, attr: string) => unknown;
              };
            };
          };
        }
      ).__paratypeChessPrediction;
      if (!mgr) throw new Error('readGameAttr: PredictionManager not exposed');
      const engine = mgr.getCurrentEngine();
      return engine.session.get(a.entityId, a.attr);
    },
    { attr, entityId },
  );
}

// ---------------------------------------------------------------------------
// Test 1 — all_on_red
// ---------------------------------------------------------------------------

test('T83/all_on_red: probabilistic on-turn-start arm seeds BlockAllExceptKing eventually', async ({
  browser,
}) => {
  const ctx = await browser.newContext();
  const page = await ctx.newPage();
  const room = await joinAsHost(page);
  expect(room.color).toBe('white');

  // Use a deterministic p=1.0 variant of the descriptor so the
  // cascade fires on EVERY turn-start (no RNG flake). seed=42 is
  // defensive only (keeps draw stream pinned if a future fixture
  // tweak restores p<1.0).
  //
  // Apply target = white king at e1 (square 4). The descriptor's
  // root is `on-turn-start`, which is a per-piece trigger — the
  // dispatcher iterates pieces and only fires hooks attached to
  // them, never to GAME_ENTITY. The seed-attribute write inside
  // the inner arm targets `ctx.pieceId` (the per-iteration
  // piece), so the resulting `BlockAllExceptKing` fact lands on
  // the white king.
  await applyDescriptor(page, {
    code: room.code,
    descriptor: allOnRedAlwaysFires(),
    rngSeed: 42,
    targetSquare: 4, // e1 — white king
  });
  await snapshot(page, 'all-on-red-pre-moves');

  // Pre-move sanity: the flag isn't set yet (the on-turn-start
  // hook seeds it but only fires on the first applyMove). We
  // probe GAME_ENTITY here just to confirm the apply didn't
  // accidentally write to GAME_ENTITY — the seed-attribute is
  // ctx.pieceId-scoped, so the post-fire flag lands on whichever
  // piece the dispatcher iterates (the e1 king, in our setup).
  expect(await readGameAttr(page, 'BlockAllExceptKing')).toBeUndefined();

  // Drive a sequence of quiet moves and poll for the flag. We
  // alternate trivial pawn nudges so the engine ticks
  // `applyMove` → fireOnTurnStartHooks each half-move. We don't
  // need both clients here — single-context driving (host plays
  // all moves) is fine because the descriptor's fire-arm
  // doesn't depend on which color moved (the flag is
  // GAME_ENTITY-scoped).
  //
  // The host is white. Black's moves can be sent through the
  // same client (the server's NOT_YOUR_TURN gate would reject
  // them, so we only drive white moves AND hop via a-pawn /
  // h-pawn alternation that lets white reasonably "self-play"
  // — actually we can't, the server enforces turn alternation).
  //
  // Simpler: open a SECOND context as black guest, then drive
  // alternating moves. Re-using the multiplayer setup avoids
  // contortions.
  const ctxB = await browser.newContext();
  const pageB = await ctxB.newPage();
  await pageB.goto('http://localhost:5173/');
  await pageB.evaluate((c) => {
    const ws = new WebSocket('ws://localhost:7357/ws');
    return new Promise<void>((resolve, reject) => {
      const t = setTimeout(() => reject(new Error('join timeout')), 5000);
      ws.onopen = () =>
        ws.send(
          JSON.stringify({
            v: 1,
            seq: 1,
            ts: Date.now(),
            type: 'room.join',
            payload: { code: c },
          }),
        );
      ws.onmessage = (e: MessageEvent) => {
        const msg = JSON.parse(e.data as string) as {
          type: string;
          payload: { code: string; token: string; color: string };
        };
        if (msg.type === 'room.joined') {
          clearTimeout(t);
          sessionStorage.setItem('room-code', msg.payload.code);
          sessionStorage.setItem('room-token', msg.payload.token);
          sessionStorage.setItem('player-color', msg.payload.color);
          ws.close();
          resolve();
        } else if (msg.type === 'error') {
          clearTimeout(t);
          ws.close();
          reject(new Error('join error'));
        }
      };
      ws.onerror = () => {
        clearTimeout(t);
        reject(new Error('ws error'));
      };
    });
  }, room.code);
  await pageB.goto('http://localhost:5173/game');
  await expect(pageB.locator('[data-testid="my-color"]')).toContainText('black');

  // Drive ~20 half-moves alternating white (pageA) / black (pageB)
  // along the a-file and h-file. After each half-move check the
  // flag. The descriptor's lifetime is `turns/5` so the flag will
  // also DECAY eventually — we only need to catch ONE positive
  // observation across the run.
  const whiteMoves: Array<[string, string]> = [
    ['a2', 'a3'],
    ['b2', 'b3'],
    ['c2', 'c3'],
    ['d2', 'd3'],
    ['e2', 'e3'],
    ['f2', 'f3'],
    ['g2', 'g3'],
    ['h2', 'h3'],
    ['a3', 'a4'],
    ['b3', 'b4'],
  ];
  const blackMoves: Array<[string, string]> = [
    ['a7', 'a6'],
    ['b7', 'b6'],
    ['c7', 'c6'],
    ['d7', 'd6'],
    ['e7', 'e6'],
    ['f7', 'f6'],
    ['g7', 'g6'],
    ['h7', 'h6'],
    ['a6', 'a5'],
    ['b6', 'b5'],
  ];

  // Find the e1 king's piece-id so we can probe `BlockAllExceptKing`
  // on the right entity. The descriptor's `seed-attribute` writes
  // to `ctx.pieceId` (the dispatcher's per-iteration target), NOT
  // to GAME_ENTITY (see all_on_red-real.test.ts § "V1 sharp edge").
  // The hook is seeded on the white king (e1) and fires when it's
  // white's turn-start (i.e. AFTER black moves).
  const kingId = await page
    .locator('[data-square="e1"] [data-piece-id]')
    .first()
    .getAttribute('data-piece-id');
  expect(kingId).not.toBeNull();
  const kingNumeric = Number(kingId);

  // Pre-flight: verify the OnTurnStartHooks fact landed on the
  // king (the apply target). Without this, the dispatcher won't
  // fire the inner arm at all and the test would fail later in
  // a less informative way.
  const onTurnHooks = await readGameAttr(
    page,
    'OnTurnStartHooks',
    kingNumeric,
  );
  expect(Array.isArray(onTurnHooks)).toBe(true);
  expect((onTurnHooks as unknown[]).length).toBeGreaterThan(0);

  let observed = false;
  for (let i = 0; i < whiteMoves.length; i++) {
    const [wf, wt] = whiteMoves[i]!;
    await sendMove(page, wf, wt);
    // brief settle for game.delta round-trip
    await page.waitForTimeout(80);
    const flagOnKing = await readGameAttr(
      page,
      'BlockAllExceptKing',
      kingNumeric,
    );
    if (flagOnKing === true) {
      observed = true;
      break;
    }
    // Black reply.
    const [bf, bt] = blackMoves[i]!;
    await sendMove(pageB, bf, bt);
    await pageB.waitForTimeout(80);
    const flagOnKing2 = await readGameAttr(
      page,
      'BlockAllExceptKing',
      kingNumeric,
    );
    if (flagOnKing2 === true) {
      observed = true;
      break;
    }
  }

  await snapshot(page, 'all-on-red-post-moves');

  // The flag MUST have fired at least once across these turns.
  // p=0.1 over ~20 fires has Pr(no fire) = 0.9^20 ≈ 0.12 — a
  // genuine flake risk if RNG seeding doesn't happen. With
  // seed=1 pinned the draw stream is deterministic and the
  // unit test confirms hits land in this window.
  expect(observed).toBe(true);

  await ctx.close();
  await ctxB.close();
});

// ---------------------------------------------------------------------------
// Test 2 — ice_physics
// ---------------------------------------------------------------------------

test('T83/ice_physics: SlideMustBeMaxDistance forces sliders to max-distance ray step', async ({
  browser,
}) => {
  const ctx = await browser.newContext();
  const page = await ctx.newPage();
  const room = await joinAsHost(page);
  expect(room.color).toBe('white');

  // Open black side so we can give black a quiet move between
  // white's setup and the bishop probe (the engine enforces turn
  // alternation).
  const ctxB = await browser.newContext();
  const pageB = await ctxB.newPage();
  await pageB.goto('http://localhost:5173/');
  await pageB.evaluate((c) => {
    const ws = new WebSocket('ws://localhost:7357/ws');
    return new Promise<void>((resolve, reject) => {
      const t = setTimeout(() => reject(new Error('join timeout')), 5000);
      ws.onopen = () =>
        ws.send(
          JSON.stringify({
            v: 1,
            seq: 1,
            ts: Date.now(),
            type: 'room.join',
            payload: { code: c },
          }),
        );
      ws.onmessage = (e: MessageEvent) => {
        const msg = JSON.parse(e.data as string) as {
          type: string;
          payload: { code: string; token: string; color: string };
        };
        if (msg.type === 'room.joined') {
          clearTimeout(t);
          sessionStorage.setItem('room-code', msg.payload.code);
          sessionStorage.setItem('room-token', msg.payload.token);
          sessionStorage.setItem('player-color', msg.payload.color);
          ws.close();
          resolve();
        } else if (msg.type === 'error') {
          clearTimeout(t);
          ws.close();
          reject(new Error('join error'));
        }
      };
      ws.onerror = () => {
        clearTimeout(t);
        reject(new Error('ws error'));
      };
    });
  }, room.code);
  await pageB.goto('http://localhost:5173/game');
  await expect(pageB.locator('[data-testid="my-color"]')).toContainText('black');

  // Apply ice_physics. The on-rule-activated arm fires
  // immediately — every slider on the board now carries
  // `SlideMustBeMaxDistance = true`.
  await applyDescriptor(page, {
    code: room.code,
    descriptor: ICE_PHYSICS_DESCRIPTOR,
  });

  // Verify the attr landed on the c1 white bishop (id resolved
  // via the rendered DOM). The bishop's piece id is exposed via
  // `data-piece-id` on the piece element.
  await page.waitForTimeout(150); // settle for game.state
  const bishopId = await page
    .locator('[data-square="c1"] [data-piece-id]')
    .first()
    .getAttribute('data-piece-id');
  expect(bishopId).not.toBeNull();
  const slideMax = await readGameAttr(
    page,
    'SlideMustBeMaxDistance',
    Number(bishopId),
  );
  expect(slideMax).toBe(true);

  // Open the bishop's diagonal: 1.b3 vacates b2, opening the
  // c1 → {b2, a3} diagonal (a3 is empty pre-move). Black plays
  // a quiet pawn nudge so we can drive white's bishop next.
  await drag(page, 'b2', 'b3');
  await expect(
    page.locator('[data-square="b3"] [data-piece="white-pawn"]'),
  ).toBeVisible({ timeout: 5000 });
  await drag(pageB, 'a7', 'a6');
  await expect(
    page.locator('[data-square="a6"] [data-piece="black-pawn"]'),
  ).toBeVisible({ timeout: 5000 });

  await snapshot(page, 'ice-physics-pre-bishop-probe');

  // ── Probe 1: drag bishop c1 → b2 (a non-max-distance step on
  // the a3-c1 diagonal). With ice_physics the move-gen filter
  // rejects the step because b2 is not the max-distance reach
  // along the ray (a3 is). Pre-physics this would be legal.
  // The drag silently no-ops (PredictionManager.tryMove returns
  // false; no game.delta is sent).
  await drag(page, 'c1', 'b2');
  await page.waitForTimeout(150);
  // Bishop still on c1.
  await expect(
    page.locator('[data-square="c1"] [data-piece="white-bishop"]'),
  ).toBeVisible();
  // b2 is empty (b-pawn moved to b3 earlier; bishop didn't land).
  await expect(page.locator('[data-square="b2"] [data-piece]')).toHaveCount(0);

  // ── Probe 2: drag bishop c1 → a3 (max-distance step on the
  // same ray). Move-gen accepts.
  await drag(page, 'c1', 'a3');
  await expect(
    page.locator('[data-square="a3"] [data-piece="white-bishop"]'),
  ).toBeVisible({ timeout: 5000 });
  await expect(page.locator('[data-square="c1"] [data-piece]')).toHaveCount(0);

  await snapshot(page, 'ice-physics-post-bishop-probe');

  await ctx.close();
  await ctxB.close();
});