// Real-server browser E2E of user playtest #2 item 10 (+ item 6 on the real flow): the boss round's prep shows the
// player's own half of the boss field (tiles, gates, objective) and placing works — solo (标准: R9 最终攻势; 险境:
// R15 隐秘核心) and co-op (two humans: the host prepares on the LEFT half, the guest on the mirrored RIGHT half) — then
// the Final Assault starts with the placed units on the boss field. Along the way (item 6): the pen stays hidden with
// the board (🔍▶▶ shows it, 🔍◀◀ "返回战场" hides it again), scouting a teammate (前往查看) and coming back, and in
// the boss battle.
//
//   SP_E2E=1 node --test test/ui/playtest2.real.e2e.test.js
//   SP_E2E=1 SP_P2_REAL=solo|hidden|coop|observe node --test test/ui/playtest2.real.e2e.test.js
//
// Item 6 on the playtest's own flow ('observe'): co-op with an AI teammate (fastServer SP_IDLE_BOTS: the AI places
// nothing, so its battle lasts the enemies' whole walk), the human's battle ends first → 前往查看 the AI's running battle
// → 返回战场: the camera frames the own battlefield again, no enemy pen (figures, 2D rows, 3D area).
//
// The server is test/e2e/fastServer.mjs with its test hook SP_START_ROUND ('boss' / 'hidden': the first round of the
// match is the boss round, every human gets a few operators and funds) — everything else is the real match engine
// and the real UI driven by real mouse input. Screenshots: test/e2e/out/fix-boss-*.png.

import { test, describe } from 'node:test';
import assert from 'node:assert/strict';
import { existsSync } from 'node:fs';
import path from 'node:path';
import { Client, ROOT, sleep, hasChrome, startRealServer, problemsOf, waitForFunctionLong } from '../e2e/client.mjs';

const ENABLED = process.env.SP_E2E === '1' && hasChrome() && existsSync(path.join(ROOT, 'public/assets'));
const ONLY = process.env.SP_P2_REAL || '';
const only = (k) => (ONLY && ONLY !== k ? `SP_P2_REAL=${ONLY}` : false);

let puppeteer = null;
const pptr = async () => { if (!puppeteer) puppeteer = (await import('puppeteer-core')).default; return puppeteer; };

/** Field view state: camera, prep field, drawn rows, 3D area, pen figures, the boss field's gates / objective on screen. */
function viewState(c) {
  return c.page.evaluate(() => {
    const v = globalThis.__SP_VIEW__;
    const raw = v?.raw;
    const d = raw?.debug;
    const s = globalThis.__SP__.store.get();
    const st = globalThis.__SP__.data.lookup('stages', s.match.public?.stageId);
    const pens = d ? [...d.penViews.values()] : [];
    const onScreen = (row, col) => {
      if (!d?.cam) return false;
      const p = d.cam.project(col, row, 0);
      const cr = d.app.view.getBoundingClientRect();
      return p.x > 0 && p.y > 0 && p.x < cr.width && p.y < cr.height;
    };
    // the boss field's own-half landmarks (research 05 §2.2: gates 'O', objective 'E' on rows 0–5)
    const marks = [];
    (st?.rows || []).forEach((line, r) => { if (r > 5) return; [...line].forEach((ch, cc) => { if (ch === 'O' || ch === 'E') marks.push({ ch, r, c: cc }); }); });
    return {
      kind: v?.kind, camera: document.querySelector('.gm')?.dataset.camera, camKind: d?.camKind ?? null,
      prepField: raw?.prepField?.() ?? null, band: d?.tiles.band ?? null,
      area3d: d?.board3d ? Math.max(...d.board3d.area.map((a) => a.r1)) : null,
      pen: pens.length, penVisible: pens.filter((x) => x.root && x.root.visible !== false).length,
      marks: marks.map((m) => ({ ...m, on: onScreen(m.r, m.c) })),
      // prep piece views: board uid → world y (FA prep: board row − 7)
      prepY: Object.fromEntries((s.match.private?.board || []).map((p) => [p.uid, d?.views.get('p:' + p.uid)?.y ?? null])),
    };
  });
}

async function soloToPrep(c, diff) {
  await c.open();
  await c.enter('煌');
  await c.click('.mode-card', '独立模拟');
  await c.click('.diff-card', diff);
  await c.click('.create-box button', '开始独立模拟');
  await c.waitFor((s) => !!s.room, 'solo room');
  if (!(await c.st()).phase) await c.click('.room-bar__right button', '开始模拟', { timeout: 20000 });
  await c.waitFor((s) => s.phase === 'INFO_CHECK', 'briefing', 30000);
  await c.click('.brief__foot .btn--primary', '准备就绪');
  await c.waitFor((s) => s.phase === 'BAND_DRAFT', 'band draft', 30000);
  await c.click('.dband', null, { nth: 1 });
  await c.click('.draft-detail__btns .btn--primary', '确认选择');
  const s = await c.waitFor((x) => x.phase === 'PREP' && !x.ready, 'boss-round prep', 60000);
  await sleep(1800); // camera flight + pieces
  return s;
}

/** Hand → board through the direction wheel; returns the placed { uid, row, col }. */
async function placeOne(c, dir = 'RIGHT') {
  await c.hookRequests();
  const hand = (await c.handPieces('chess'));
  assert.ok(hand.length, `${c.label}: the starter kit is in the hand`);
  for (const p of hand) {
    const tile = await c.freeTileFor(p.uid);
    if (!tile) continue;
    const from = await c.piecePoint(p.uid);
    const to = await c.tilePoint(tile.row, tile.col);
    assert.ok(from && to, `${c.label}: piece and tile on screen`);
    await c.drag(from, to);
    await c.page.waitForSelector('.fwheel__dia', { timeout: 4000 });
    await c.swipe(dir);
    const placed = await c.waitFor((x) => x.board > 0, 'placed', 8000).then(() => c.boardPiece(p.uid), () => null);
    if (placed) {
      assert.deepEqual([placed.row, placed.col], [tile.row, tile.col], `${c.label}: landed on the board tile`);
      assert.equal(placed.dir, dir, `${c.label}: with the chosen direction`);
      return { uid: p.uid, ...placed };
    }
  }
  throw new Error(`${c.label}: nothing could be placed`);
}

/** The boss-round prep checks shared by every variant. */
async function checkBossPrep(c, side, tag) {
  const v = await viewState(c);
  assert.equal(v.kind, 'engine', `${tag}: the render engine is mounted`);
  assert.equal(v.camera, 'bossPrep', `${tag}: the prep camera is the boss field's`);
  assert.equal(v.camKind, 'bossPrep');
  assert.deepEqual(v.prepField, { kind: 'bossPrep', side, mirror: side === 'R' }, `${tag}: own ${side} half`);
  assert.deepEqual(v.band, [0, 13], `${tag}: the boss field rows are drawn (no pen rows)`);
  if (v.area3d != null) assert.ok(v.area3d <= 6, `${tag}: the 3D board builds the boss field (${v.area3d})`);
  const own = v.marks.filter((m) => (side === 'R' ? m.c >= 10 : m.c <= 10));
  assert.ok(own.length >= 2, `${tag}: boss-field gates / objective exist (${JSON.stringify(v.marks)})`);
  assert.ok(own.every((m) => m.on), `${tag}: the own half's gates and objective are on screen (${JSON.stringify(own)})`);
  assert.equal(v.penVisible, 0, `${tag}: no pen figure with the board`);
  return v;
}

/** 🔍▶▶ → the pen (the boss wave), 🔍◀◀ (返回战场) → back to the boss field, pen hidden again. */
async function penRoundTrip(c, tag) {
  await c.click('.enemybtn');
  await c.page.waitForFunction(() => document.querySelector('.gm')?.dataset.camera === 'pen', { timeout: 4000 });
  await sleep(700);
  const p = await viewState(c);
  assert.ok(p.pen > 0 && p.penVisible > 0, `${tag}: the pen shows the boss wave`);
  await c.shot('boss-pen');
  await c.click('.gtop__iconbtn');
  await c.page.waitForFunction(() => document.querySelector('.gm')?.dataset.camera === 'bossPrep', { timeout: 4000 });
  await sleep(900);
  const b = await viewState(c);
  assert.equal(b.penVisible, 0, `${tag}: back on the boss field (返回战场): no pen figure`);
  assert.deepEqual(b.band, [0, 13]);
}

/** The Final Assault / Hidden Core battle: the boss field with the placed unit on its boss row. */
async function checkBossBattle(c, placed, side, tag) {
  await c.waitFor((s) => s.phase === 'FINAL_ASSAULT' || s.phase === 'HIDDEN_CORE', 'boss battle', 60000);
  await c.page.waitForFunction(() => { const s = globalThis.__SP_VIEW__?.raw?.stats?.(); return !!s && s.mode === 'battle' && s.units > 0; }, { timeout: 30000 });
  await sleep(1500);
  // the unit's battle view (units deploy one after another at the start)
  await c.page.waitForFunction((uid) => [...globalThis.__SP_VIEW__.raw.debug.views.values()].some((x) => x?.info?.uid === uid), { timeout: 10000 }, placed.uid)
    .catch(async () => console.log(tag, 'views:', JSON.stringify(await c.page.evaluate(() => [...globalThis.__SP_VIEW__.raw.debug.views.values()].map((x) => [x.info?.uid, x.info?.defId, x.info?.side, x.info?.x, x.info?.y])))));
  const r = await c.page.evaluate((uid) => {
    const d = globalThis.__SP_VIEW__.raw.debug;
    const s = globalThis.__SP__.store.get();
    const view = [...d.views.values()].find((x) => x?.info?.uid === uid) || null;
    const u = view ? { x: view.info.x, y: view.info.y } : null;
    const pens = [...d.penViews.values()];
    return {
      camKind: d.camKind, field: s.match.field?.kind, band: d.tiles.band,
      area3d: d.board3d ? Math.max(...d.board3d.area.map((a) => a.r1)) : null,
      unit: u ? { x: u.x, y: u.y } : null, view: view ? { x: view.x, y: view.y } : null, penVisible: pens.filter((x) => x.root?.visible !== false).length,
    };
  }, placed.uid);
  assert.ok(r.field === 'boss' || r.field === 'hidden', `${tag}: the battle is on the boss field (${r.field})`);
  assert.equal(r.camKind, 'boss');
  assert.equal(r.penVisible, 0, `${tag}: no pen in the boss battle`);
  assert.ok(r.band[1] <= 13, `${tag}: no pen rows drawn (${r.band})`);
  if (r.area3d != null) assert.ok(r.area3d <= 6, `${tag}: boss area only`);
  assert.ok(r.unit, `${tag}: the placed unit fights (${JSON.stringify(r)})`);
  assert.equal(Math.round(r.unit.y), placed.row - 7, `${tag}: on its boss row (board row ${placed.row} − 7)`);
  assert.equal(Math.round(r.unit.x), side === 'R' ? 20 - placed.col : placed.col, `${tag}: on its ${side} column`);
  await c.shot('boss-battle');
}

/** Camera / pen state of the battle view (item 6). */
function battleViewState(c) {
  return c.page.evaluate(() => {
    const d = globalThis.__SP_VIEW__?.raw?.debug;
    const s = globalThis.__SP__.store.get();
    const pens = d ? [...d.penViews.values()] : [];
    const r = globalThis.__SP_RUNNER__?.state?.() || null;
    return {
      camera: document.querySelector('.gm')?.dataset.camera ?? null, camKind: d?.camKind ?? null, band: d?.tiles.band ?? null,
      area3d: d?.board3d ? Math.max(...d.board3d.area.map((a) => a.r1)) : null,
      penVisible: pens.filter((x) => x.root && x.root.visible !== false).length,
      penRowsDrawn: !!d && d.tiles.grid.some((row) => row.some((t) => t.r >= 14 && t.drawn)),
      field: s.match.field?.fieldId ?? null, runner: r ? { fieldId: r.fieldId, own: !!r.own, watch: !!r.watch, done: !!r.done } : null,
      // unit-layer sprites no view owns (a stale unit of the field shown before would stay drawn)
      orphans: d ? d.ctx.layers.units.children.filter((ch) => ch.visible !== false && ch.worldVisible !== false)
        .filter((ch) => ![...d.views.values()].some((v) => v && v.root === ch))
        .map((ch) => ch.getBounds()).filter((b) => b.width > 4 && b.height > 4).map((b) => `${Math.round(b.x)},${Math.round(b.y)}`) : [],
    };
  });
}

/**
 * Wait for a prep matching `pred`; a 机变 draft on the way is picked with its two taps (user playtest #4 item 2) —
 * a single human's 机变 is untimed (Match.soloUntimed, item 3): nothing picks it for them any more.
 */
async function untilPrep(c, pred, what, timeout = 90000) {
  const t0 = Date.now();
  for (;;) {
    const left = Math.max(2000, timeout - (Date.now() - t0));
    const s = await c.waitFor((x) => (x.phase === 'PREP' && pred(x)) || (x.phase === 'SP_DRAFT' && x.sp?.turn === x.me), what, left);
    if (s.phase === 'PREP') return s;
    await c.click('.spcard.is-pickable', null, { optional: true, timeout: 4000 });
    await c.click('.spcard.is-armed', null, { optional: true, timeout: 4000 });
    await c.waitFor((x) => x.phase !== 'SP_DRAFT' || x.sp?.turn !== x.me, '机变 picked', 15000);
  }
}

// The field's 3D area ends at its separator row 13 — the row-13 devices blow into the field (act2 m01's blowers, user
// playtest #5 item 6: render/app.js boardArea) — and the enemy preview pen starts at row 14.
const NO_PEN_R1 = 13;

function assertNoPen(v, tag) {
  assert.deepEqual(v.orphans, [], `${tag}: no stale unit sprite of another field`);
  assert.equal(v.penVisible, 0, `${tag}: no pen figure`);
  assert.equal(v.penRowsDrawn, false, `${tag}: no pen rows drawn (${v.band})`);
  assert.ok(v.band && v.band[1] <= 13, `${tag}: drawn rows ${v.band}`);
  if (v.area3d != null) assert.ok(v.area3d <= NO_PEN_R1, `${tag}: 3D area without the pen block (${v.area3d})`);
}

describe('user playtest #2 item 6 — 前往查看 → 返回战场 in combat (real server)', { skip: !ENABLED && 'set SP_E2E=1 (Chrome + public/assets)' }, () => {
  test('co-op with an AI: observing its battle and 返回战场 frame the battlefield only — never the enemy pen', { skip: only('observe'), timeout: 10 * 60 * 1000 }, async () => {
    const srv = await startRealServer({ fast: { timerScale: 0.5, combatSpeed: 2, startRound: 2, kit: 6, idleBots: true } });
    const c = new Client(await pptr(), srv.base, 'observe', { prefix: 'fix' });
    try {
      await c.open();
      await c.enter('煌');
      await c.click('.mode-card', '同盟模拟');
      await c.click('.diff-card', '标准模拟');
      await c.click('.create-box button', '创建同盟');
      await c.waitFor((s) => !!s.room?.code, 'room created');
      await c.click('button', '添加 AI 队友');
      await sleep(500);
      await c.click('.room-bar__right button', '开始模拟', { timeout: 20000 });
      await c.waitFor((s) => s.phase === 'INFO_CHECK', 'briefing', 30000);
      await c.click('.brief__foot .btn--primary', '准备就绪');
      await c.waitFor((s) => s.phase === 'BAND_DRAFT' && s.draft?.turn === s.me || s.phase === 'PREP', 'my band pick', 60000);
      if ((await c.st()).phase === 'BAND_DRAFT') {
        await c.click('.dband:not(.is-taken)', null, { nth: 1 });
        await c.click('.draft-detail__btns .btn--primary', '确认选择');
      }
      let observed = false;
      for (let tries = 0; tries < 3 && !observed; tries++) {
        const s0 = await untilPrep(c, (s) => !s.ready, 'prep');
        await sleep(1500);
        // the own field fights with everything the deploy cap allows: it clears its wave long before the idle AI's
        // enemies have walked their whole path
        for (let k = 0; k < 8; k++) {
          const s = await c.st();
          if (s.deployCount >= s.deployCap || !(await c.handPieces('chess')).length) break;
          try { await placeOne(c, 'RIGHT'); } catch { break; }
          await sleep(300);
        }
        const v0 = await battleViewState(c);
        assertNoPen(v0, `R${s0.round} prep`);
        await c.click('.readybtn');
        await c.waitFor((s) => s.phase === 'COMBAT', 'combat', 60000);
        await sleep(1500);
        assertNoPen(await battleViewState(c), `R${s0.round} own battle`);
        // own battle over while the AI's field still runs (sliced: longer than the browser's 90 s protocol timeout)
        const target = await waitForFunctionLong(c.page, () => {
          const s = globalThis.__SP__.store.get();
          const r = globalThis.__SP_RUNNER__?.state?.();
          const pub = s.match.public;
          if (pub?.phase !== 'COMBAT') return 'phase';
          if (!r || !r.own || !r.done) return false;
          const f = (pub.fields || []).find((x) => x.kind === 'normal' && x.live && !x.players.includes(s.me.playerId));
          return f ? f.fieldId : 'none';
        }, { timeout: 120000, polling: 200 }).then((h) => h.jsonValue(), () => 'timeout');
        if (!target || ['phase', 'none', 'timeout'].includes(target)) { c.note(`R${s0.round}: no running teammate field after the own battle (${target})`); continue; }
        await c.page.waitForSelector('.chud__wait', { timeout: 5000 });
        await c.click('.team__row:not(.is-self) .team__btn', null, { nth: 0 });
        if (!(await c.click('.team__ob', '前往查看', { optional: true, timeout: 3000 }))) { c.note(`R${s0.round}: no 前往查看`); continue; }
        const ok = await c.page.waitForFunction((fid) => { const r = globalThis.__SP_RUNNER__?.state?.(); return !!r && r.fieldId === fid && r.watch; }, { timeout: 15000 }, target).then(() => true, () => false);
        if (!ok || (await c.st()).phase !== 'COMBAT') { c.note(`R${s0.round}: the observed battle ended meanwhile`); continue; }
        await sleep(1300);
        const w = await battleViewState(c);
        assert.equal(w.camKind, 'normal', 'observing: the battle camera');
        assertNoPen(w, 'observing the teammate');
        await c.shot('observe-teammate');
        if ((await c.st()).phase !== 'COMBAT') { c.note(`R${s0.round}: combat ended before 返回战场`); continue; }
        await c.click('.team__back, .chud__back', '返回战场', { timeout: 4000 });
        await c.page.waitForFunction(() => { const r = globalThis.__SP_RUNNER__?.state?.(); return !r || (r.own && !r.watch); }, { timeout: 10000 });
        await sleep(1300); // the camera flight
        const b = await battleViewState(c);
        if ((await c.st()).phase === 'COMBAT') {
          assert.equal(b.camKind, 'normal', `返回战场: the own battle camera (${b.camKind})`);
          assert.ok(b.runner?.own && !b.runner.watch, '返回战场: the own field is shown');
          assertNoPen(b, '返回战场');
          await c.shot('observe-back');
          observed = true;
        }
      }
      assert.ok(observed, `observed a teammate's battle and came back (${c.log.join(' | ')})`);
      // and the next prep: the board without the pen, the pen only with 🔍▶▶
      const s1 = await untilPrep(c, () => true, 'next prep');
      await sleep(1500);
      assertNoPen(await battleViewState(c), `R${s1.round} prep after observing`);
      assert.deepEqual(problemsOf([c]), []);
    } finally {
      if (c.problems.length) console.log(c.problems.slice(0, 20).join('\n'));
      await c.close();
      await srv.stop();
    }
  });
});

describe('user playtest #2 item 10 — boss-round prep on the boss field (real server)', { skip: !ENABLED && 'set SP_E2E=1 (Chrome + public/assets)' }, () => {
  test('solo 标准 (R9 最终攻势): the own half of the boss field while preparing, placing works, the FA uses it', { skip: only('solo'), timeout: 8 * 60 * 1000 }, async () => {
    const srv = await startRealServer({ fast: { timerScale: 0.5, combatSpeed: 8, startRound: 'boss' } });
    const c = new Client(await pptr(), srv.base, 'solo', { prefix: 'fix' });
    try {
      const s = await soloToPrep(c, '标准模拟');
      assert.equal(s.round, s.bossRound, 'the boss round');
      await checkBossPrep(c, 'L', 'solo');
      await c.shot('boss-prep-solo');
      const placed = await placeOne(c, 'RIGHT');
      await sleep(600);
      const v = await viewState(c);
      assert.equal(Math.round(v.prepY[placed.uid]), placed.row - 7, 'the placed piece stands on its boss row');
      await c.shot('boss-prep-solo-placed');
      await penRoundTrip(c, 'solo');
      await c.click('.readybtn');
      await checkBossBattle(c, placed, 'L', 'solo');
      assert.deepEqual(problemsOf([c]), []);
    } finally {
      if (c.problems.length) console.log(c.problems.slice(0, 20).join('\n'));
      await c.close();
      await srv.stop();
    }
  });

  test('solo 险境 (R15 隐秘核心): the boss field prep of the Hidden Core round', { skip: only('hidden'), timeout: 8 * 60 * 1000 }, async () => {
    const srv = await startRealServer({ fast: { timerScale: 0.5, combatSpeed: 8, startRound: 'hidden' } });
    const c = new Client(await pptr(), srv.base, 'hidden', { prefix: 'fix', w: 1366, h: 768 });
    try {
      const s = await soloToPrep(c, '险境模拟');
      assert.equal(s.round, 15, 'the Hidden Core round');
      await checkBossPrep(c, 'L', 'hidden');
      const placed = await placeOne(c, 'UP');
      await c.shot('boss-prep-hidden');
      await c.click('.readybtn');
      await checkBossBattle(c, placed, 'L', 'hidden');
      assert.deepEqual(problemsOf([c]), []);
    } finally {
      if (c.problems.length) console.log(c.problems.slice(0, 20).join('\n'));
      await c.close();
      await srv.stop();
    }
  });

  test('co-op 险境 (R14): host on the left half, guest on the mirrored right half; scouting and 返回 keep the pen hidden', { skip: only('coop'), timeout: 10 * 60 * 1000 }, async () => {
    const srv = await startRealServer({ fast: { timerScale: 0.5, combatSpeed: 8, startRound: 'boss' } });
    const P = await pptr();
    const host = new Client(P, srv.base, 'host', { prefix: 'fix' });
    const guest = new Client(P, srv.base, 'guest', { prefix: 'fix', w: 1280, h: 720 });
    try {
      await host.open();
      await host.enter('凯尔希');
      await host.click('.mode-card', '同盟模拟');
      await host.click('.diff-card', '险境模拟');
      await host.click('.create-box button', '创建同盟');
      const room = (await host.waitFor((s) => !!s.room?.code, 'room created')).room;
      await guest.open(`?room=${room.code}`);
      await guest.enter('阿米娅');
      await guest.waitFor((s) => s.room?.code === room.code, 'guest joined');
      await guest.click('.room-bar__right button', '准备就绪');
      await sleep(400);
      await host.click('.room-bar__right button', '开始模拟', { timeout: 20000 });
      for (const c of [host, guest]) await c.waitFor((s) => s.phase === 'INFO_CHECK', 'briefing', 30000);
      for (const c of [host, guest]) await c.click('.brief__foot .btn--primary', '准备就绪');
      // the draft first (a client still in the briefing would count as done without picking: its turn then runs out —
      // Match.BAND_TURN_SECONDS, 30 s each since user playtest #4 item 4)
      for (const c of [host, guest]) await c.waitFor((s) => s.phase !== 'INFO_CHECK', 'band draft', 40000);
      // band draft: whoever's turn it is picks a free strategy
      const picked = new Set();
      const t0 = Date.now();
      while (picked.size < 2 && Date.now() - t0 < 120000) {
        for (const c of [host, guest]) {
          const s = await c.st();
          if (s.phase !== 'BAND_DRAFT') { picked.add(c.label); continue; }
          if (picked.has(c.label) || s.draft?.turn !== s.me) continue;
          await c.click('.dband:not(.is-taken)', null, { nth: c === host ? 2 : 5 });
          await sleep(200);
          await c.click('.draft-detail__btns .btn--primary', '确认选择');
          picked.add(c.label);
        }
        await sleep(250);
      }
      for (const c of [host, guest]) await c.waitFor((s) => s.phase === 'PREP' && !s.ready, 'boss-round prep', 60000);
      await sleep(1800);
      const hs = await host.st();
      assert.equal(hs.round, hs.bossRound, 'the boss round');
      await checkBossPrep(host, 'L', 'host');
      await checkBossPrep(guest, 'R', 'guest');
      const hp = await placeOne(host, 'RIGHT');
      const gp = await placeOne(guest, 'RIGHT');
      await sleep(600);
      const gv = await viewState(guest);
      assert.equal(Math.round(gv.prepY[gp.uid]), gp.row - 7, 'guest: on its boss row');
      await host.shot('boss-prep-coop-L');
      await guest.shot('boss-prep-coop-R');
      // scouting the teammate's board (前往查看) and coming back: no pen with the boards, the boss field again
      await host.click('.team__row:not(.is-self) .team__btn', null, { nth: 0 });
      assert.ok(await host.click('.team__ob', '前往查看', { optional: true, timeout: 3000 }), 'host: 前往查看 in the boss-round prep');
      {
        await host.page.waitForSelector('.gm__watching', { timeout: 6000 });
        await sleep(900);
        const w = await viewState(host);
        assert.equal(w.penVisible, 0, 'scouting: no pen figure with the teammate\'s board');
        assert.ok(w.band[1] <= 13, `scouting: no pen rows (${w.band})`);
        await host.click('.gm__watching button, .team__back', null, { timeout: 4000 });
        await host.page.waitForFunction(() => document.querySelector('.gm')?.dataset.camera === 'bossPrep', { timeout: 6000 });
        await sleep(900);
        const back = await viewState(host);
        assert.equal(back.penVisible, 0, '返回: no pen figure');
        assert.deepEqual(back.prepField, { kind: 'bossPrep', side: 'L', mirror: false }, '返回: the own boss half again');
      }
      await penRoundTrip(guest, 'guest');
      for (const c of [host, guest]) await c.click('.readybtn');
      await checkBossBattle(host, hp, 'L', 'host');
      await checkBossBattle(guest, gp, 'R', 'guest');
      assert.deepEqual(problemsOf([host, guest]), []);
    } finally {
      for (const c of [host, guest]) if (c.problems.length) console.log(c.label, c.problems.slice(0, 20).join('\n'));
      await host.close();
      await guest.close();
      await srv.stop();
    }
  });
});