// Browser E2E of the client leftovers (puppeteer-core + system Chrome; opt-in: SP_E2E=1, ~3 min):
//
//   SP_E2E=1 node --test test/ui/leftovers.e2e.test.js
//
// Mock harness (public/dev/game-mock.html, in-process server):
//   1. a third item dropped on a full operator opens the equip-replace dialog (both equipped items with icon / name /
//      effect); 取消 and Esc send nothing and change nothing; picking the 2nd item + 确认替换 sends g.equip {replaceUid};
//   2. 最终攻势: the countdown gauge counts the level's 120 s; the red DOT warning shows the drain start once the level time
//      ran out and a live indicator while the team LP drains (m.public.overtimeAt);
//   4. solo battle: the pause button sends g.pause {on}, m.public.paused shows the overlay and freezes the countdown,
//      Space resumes; no pause control in co-op or in prep.
// Real server (test/e2e/fastServer.mjs, real clicks and canvas drags):
//   1+4. a solo run: equip two items on an operator, drop a third → dialog → 取消 (nothing sent, the item drawn back on its
//        bench slot) → pick the OLDER item →
//        the real engine destroys exactly that one; then ready → the real local battle → pause (the battle clock and the
//        countdown stand still) → 继续作战;
//   3. the server restarts while the briefing is on screen → 「服务器会话已重置，上一局模拟已结束」 and the lobby.
// Screenshots: test/e2e/out/leftover-*.png. Every page must end without console / page / request errors (the restart
// test tolerates only the socket errors of the server's downtime).

import { test, describe, before, after } from 'node:test';
import assert from 'node:assert/strict';
import { existsSync, mkdirSync, readFileSync } from 'node:fs';
import path from 'node:path';
import { Client, ROOT, OUT, CHROME, sleep, hasChrome, startRealServer, problemsOf } from '../e2e/client.mjs';

const ENABLED = process.env.SP_E2E === '1' && hasChrome() && existsSync(path.join(ROOT, 'public/assets'));
const ITEMS = (() => {
  const raw = JSON.parse(readFileSync(path.join(ROOT, 'data/items.json'), 'utf8'));
  const list = Array.isArray(raw) ? raw : Object.values(raw.items || raw);
  return new Map(list.filter((x) => x && x.id).map((x) => [x.id, x]));
})();
const attaches = (id) => !String(ITEMS.get(id)?.kind || '').startsWith('consume_on_equip');
/** Three distinct plain equipment items (attach, mergeable pairs never complete: all different). */
const KIT_ITEMS = [...ITEMS.values()].filter((i) => i.itemType === 'EQUIP' && !i.isGolden && attaches(i.id) && i.tier === 1).map((i) => i.id).sort().slice(0, 3);

describe('client leftovers — mock harness', { skip: !ENABLED && 'set SP_E2E=1 (Chrome + public/assets)' }, () => {
  let srv;
  let browser;
  let base;
  before(async () => {
    const { startServer } = await import('../../server/index.js');
    const puppeteer = (await import('puppeteer-core')).default;
    srv = await startServer({ port: 0, host: '127.0.0.1', quiet: true });
    base = `http://127.0.0.1:${srv.port}`;
    browser = await puppeteer.launch({ executablePath: CHROME, headless: true, args: ['--no-sandbox', '--force-device-scale-factor=1'] });
    mkdirSync(OUT, { recursive: true });
  });
  after(async () => { await browser?.close(); await srv?.close(); });

  async function open(query, { w = 1920, h = 1080 } = {}) {
    const page = await browser.newPage();
    await page.setViewport({ width: w, height: h });
    const problems = [];
    page.on('console', (m) => { if (m.type() === 'error') problems.push(`console: ${m.text()}`); });
    page.on('pageerror', (e) => problems.push(`pageerror: ${e.message}`));
    page.on('requestfailed', (r) => { if (!/fonts\.(googleapis|gstatic)/.test(r.url())) problems.push(`requestfailed: ${r.url()} ${r.failure()?.errorText}`); });
    page.on('response', (r) => { if (r.status() >= 400) problems.push(`http ${r.status()}: ${r.url()}`); });
    await page.goto(`${base}/dev/game-mock.html?shot=1&${query}`, { waitUntil: 'networkidle0' });
    await page.waitForFunction(() => !!document.querySelector('.screen:not(.gload)'), { timeout: 15000 });
    await sleep(900);
    return { page, problems };
  }
  const mockPriv = (page) => page.evaluate(() => JSON.parse(JSON.stringify(globalThis.__MOCK__.S().priv)));
  const mockReqs = (page, t) => page.evaluate((t) => globalThis.__MOCK__.S().requests.filter((r) => r[0] === t), t);
  const center = (page, sel) => page.$eval(sel, (el) => { const r = el.getBoundingClientRect(); return { x: r.left + r.width / 2, y: r.top + r.height / 2 }; });
  const drag = async (page, from, to) => {
    await page.mouse.move(from.x, from.y);
    await page.mouse.down();
    for (let i = 1; i <= 8; i++) await page.mouse.move(from.x + ((to.x - from.x) * i) / 8, from.y + ((to.y - from.y) * i) / 8);
    await sleep(80);
    await page.mouse.up();
    await sleep(500);
  };

  test('1. equip-replace dialog: lists both equipped items, cancel / Esc change nothing, the pick is sent as replaceUid', async () => {
    // DOM drag targets exist in the fallback view (the engine's own drag is covered by the real-server test below)
    const { page, problems } = await open('phase=PREP&render=fallback');
    let s = await mockPriv(page);
    const target = s.board.find((p) => p.kind === 'chess' && (p.items || []).length === 2);
    const item = s.hand.find((p) => p && p.kind === 'item' && attaches(p.id) && !target.items.some((x) => x.id === p.id));
    assert.ok(target && item, 'the mock has a full operator and an attachable hand item');
    const dropOnTarget = async () => {
      await drag(page, await center(page, `.ff-piece[data-uid="${item.uid}"]`), await center(page, `.ff-piece[data-uid="${target.uid}"]`));
      await page.waitForSelector('.eqr .eqr__opt', { timeout: 4000 });
    };

    await dropOnTarget();
    const dlg = await page.evaluate(() => ({
      opts: [...document.querySelectorAll('.eqr__opt')].map((el) => ({
        uid: Number(el.dataset.uid), name: el.querySelector('.eqr__name')?.textContent, desc: (el.querySelector('.eqr__desc')?.textContent || '').length,
        icon: !!el.querySelector('.uthumb'), checked: el.getAttribute('aria-checked'),
      })),
      incoming: document.querySelector('.eqr__card--new .eqr__name')?.textContent,
      okDisabled: document.querySelector('.eqr__ok')?.disabled,
      lead: document.querySelector('.eqr__lead')?.textContent || '',
    }));
    assert.deepEqual(dlg.opts.map((o) => o.uid), target.items.map((x) => x.uid), 'both equipped items, oldest first');
    assert.deepEqual(dlg.opts.map((o) => o.name), target.items.map((x) => ITEMS.get(x.id).name));
    assert.ok(dlg.opts.every((o) => o.icon && o.desc > 0 && o.checked === 'false'), 'icons + effects, nothing preselected');
    assert.equal(dlg.incoming, ITEMS.get(item.id).name);
    assert.equal(dlg.okDisabled, true, '确认替换 needs a pick');
    assert.match(dlg.lead, /被替换的装备将被销毁/);
    assert.equal(await page.$('.uframe__btn--destroy'), null, 'no 销毁 anywhere for equipped items');
    await page.screenshot({ path: path.join(OUT, 'leftover-replace-mock.png') });

    // 取消: nothing sent, nothing changed
    await page.click('.eqr__cancel');
    await page.waitForFunction(() => !document.querySelector('.eqr'), { timeout: 3000 });
    // Esc: same
    await dropOnTarget();
    await page.click('.eqr__opt:nth-child(1)');
    await page.keyboard.press('Escape');
    await page.waitForFunction(() => !document.querySelector('.eqr'), { timeout: 3000 });
    await sleep(300);
    assert.deepEqual(await mockReqs(page, 'g.equip'), [], 'cancel / Esc: no g.equip');
    s = await mockPriv(page);
    assert.deepEqual(s.board.find((p) => p.uid === target.uid).items.map((x) => x.uid), target.items.map((x) => x.uid));
    assert.ok(s.hand.some((p) => p && p.uid === item.uid), 'the item stays in the hand');

    // pick the SECOND (newer) item → 确认替换
    await dropOnTarget();
    await page.click('.eqr__opt:nth-child(2)');
    await page.waitForFunction(() => document.querySelector('.eqr__opt:nth-child(2)')?.getAttribute('aria-checked') === 'true' && !document.querySelector('.eqr__ok').disabled, { timeout: 2000 });
    await sleep(350); // the 将被销毁 flag slides in
    await page.screenshot({ path: path.join(OUT, 'leftover-replace-mock-picked.png') });
    await page.click('.eqr__ok');
    await page.waitForFunction(() => !document.querySelector('.eqr'), { timeout: 3000 });
    await sleep(400);
    assert.deepEqual(await mockReqs(page, 'g.equip'), [['g.equip', { itemUid: item.uid, targetUid: target.uid, replaceUid: target.items[1].uid }]]);
    s = await mockPriv(page);
    assert.deepEqual(s.board.find((p) => p.uid === target.uid).items.map((x) => x.uid), [target.items[0].uid, item.uid], 'the picked one is destroyed');
    // a loose item still offers 销毁 (tap → underframe)
    const loose = s.hand.find((p) => p && p.kind === 'item');
    if (loose) {
      await page.click(`.ff-piece[data-uid="${loose.uid}"]`);
      await page.waitForSelector('.uframe__btn--destroy', { timeout: 3000 });
    }
    assert.deepEqual(problems, []);
    await page.close();
  });

  test("2. 最终攻势: the 120 s countdown gauge, then the red DOT overtime warning (drain start + live drain)", async () => {
    // start of the round: 95 s of 120 left → 4 of 5 bars, no warning yet
    let { page, problems } = await open('phase=FINAL_ASSAULT');
    const lit = await page.$$eval('.gtop__right .countdown__gauge i.on', (els) => els.length);
    assert.equal(lit, 4, 'gauge counts the 120 s level time');
    assert.equal(await page.$('.otwarn'), null);
    assert.deepEqual(problems, []);
    await page.close();

    // the level time ran out: the drain starts in ~18 s
    ({ page, problems } = await open('phase=FINAL_ASSAULT&variant=overtime'));
    await page.waitForSelector('.otwarn[data-state="pending"]', { timeout: 3000 });
    const pend = await page.$eval('.otwarn', (el) => el.textContent);
    assert.match(pend, /DOT/);
    assert.match(pend, /\d+\s*秒后全队生命值开始流失/);
    const secs = Number(pend.match(/(\d+)\s*秒后/)[1]);
    assert.ok(secs > 10 && secs <= 18, `drain in ${secs} s`);
    assert.equal(await page.$eval('.gtop__right .countdown', (el) => el.getAttribute('aria-label')), '剩余0秒');
    await page.screenshot({ path: path.join(OUT, 'leftover-fa-overtime.png') });
    assert.deepEqual(problems, []);
    await page.close();

    // draining: live indicator, the team LP turns red, the lost counter moves every second
    ({ page, problems } = await open('phase=FINAL_ASSAULT&variant=drain'));
    await page.waitForSelector('.otwarn[data-state="drain"]', { timeout: 3000 });
    const d1 = await page.$eval('.otwarn', (el) => el.textContent);
    assert.match(d1, /超时 · 生命值 −1\/秒/);
    assert.ok(await page.$('.gtop__center .lp--danger'), 'the team LP tower turns red');
    const lost = async () => Number((await page.$eval('.otwarn__lost b', (el) => el.textContent)) || 0);
    const l1 = await lost();
    await sleep(2100);
    const l2 = await lost();
    assert.ok(l2 >= l1 + 2, `the drain counter is live (${l1} → ${l2})`);
    await page.screenshot({ path: path.join(OUT, 'leftover-fa-drain.png') });
    assert.deepEqual(problems, []);
    await page.close();

    ({ page, problems } = await open('phase=HIDDEN_CORE&variant=drain'));
    await page.waitForSelector('.otwarn[data-state="drain"]', { timeout: 3000 });
    assert.deepEqual(problems, []);
    await page.close();
  });

  test('4. solo battle: pause button → g.pause, paused overlay freezes the clock, Space resumes; hidden in co-op / prep', async () => {
    let { page, problems } = await open('phase=COMBAT&variant=solo');
    await page.waitForSelector('[data-testid="pause"]', { timeout: 3000 });
    await page.click('[data-testid="pause"]');
    await page.waitForSelector('.pauseov', { timeout: 3000 });
    assert.deepEqual(await mockReqs(page, 'g.pause'), [['g.pause', { on: true }]]);
    const cd = () => page.$eval('.gtop__right .countdown', (el) => el.getAttribute('aria-label'));
    const c1 = await cd();
    await sleep(1600);
    assert.equal(await cd(), c1, 'the countdown stands still while paused');
    assert.equal(await page.$eval('[data-testid="pause"]', (el) => el.getAttribute('aria-pressed')), 'true');
    await page.screenshot({ path: path.join(OUT, 'leftover-pause-mock.png') });
    await page.keyboard.press('Space');
    await page.waitForFunction(() => !document.querySelector('.pauseov'), { timeout: 3000 });
    assert.deepEqual(await mockReqs(page, 'g.pause'), [['g.pause', { on: true }], ['g.pause', { on: false }]]);
    // the overlay's 继续作战 resumes too
    await page.keyboard.press('Space');
    await page.waitForSelector('.pauseov', { timeout: 3000 });
    await page.click('.pauseov .btn--primary');
    await page.waitForFunction(() => !document.querySelector('.pauseov'), { timeout: 3000 });
    assert.equal((await mockReqs(page, 'g.pause')).length, 4);
    assert.deepEqual(problems, []);
    await page.close();

    for (const q of ['phase=COMBAT', 'phase=FINAL_ASSAULT', 'phase=PREP&variant=solo']) {
      ({ page, problems } = await open(q));
      assert.equal(await page.$('[data-testid="pause"]'), null, `${q}: no pause control`);
      if (q !== 'phase=PREP&variant=solo') {
        await page.keyboard.press('Space');
        await sleep(300);
        assert.deepEqual(await mockReqs(page, 'g.pause'), [], `${q}: Space does not pause`);
      }
      assert.deepEqual(problems, []);
      await page.close();
    }
  });
});

describe('client leftovers — real server', { skip: !ENABLED && 'set SP_E2E=1 (Chrome + public/assets)' }, () => {
  test('1+4. solo: equip-replace dialog on the real engine, then pause / resume the real local battle', { timeout: 6 * 60 * 1000 }, async () => {
    assert.equal(KIT_ITEMS.length, 3);
    const CHESS = 'chess_char_1_01_a'; // a cheap ranged operator (any legal tile)
    const srv = await startRealServer({ fast: { timerScale: 0.5, combatSpeed: 2, startRound: 1, chess: [CHESS], items: KIT_ITEMS } });
    const P = (await import('puppeteer-core')).default;
    const c = new Client(P, srv.base, 'solo', { prefix: 'leftover' });
    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, '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', '确认选择');
      await c.waitFor((s) => s.phase === 'PREP' && !s.ready && s.hand >= 4, 'prep with the starter kit', 60000);
      await sleep(1800);
      await c.hookRequests();

      // the operator onto the board (drag → direction wheel)
      const [unit] = (await c.handPieces('chess')).filter((p) => p.id === CHESS);
      assert.ok(unit, 'the kit operator is in the hand');
      const tile = await c.freeTileFor(unit.uid);
      await c.drag(await c.piecePoint(unit.uid), await c.tilePoint(tile.row, tile.col));
      await c.page.waitForSelector('.fwheel__dia', { timeout: 4000 });
      await c.swipe('RIGHT');
      await c.waitFor((s) => s.board > 0, 'placed', 8000);
      await sleep(700);

      const itemsOf = () => c.page.evaluate((uid) => (globalThis.__SP__.store.get().match.private.board.find((p) => p.uid === uid)?.items || []).map((x) => ({ uid: x.uid, id: x.id })), unit.uid);
      const handItem = async (id) => (await c.handPieces('item')).find((p) => p.id === id) || null;
      // an item goes to the unit on the tile it is dropped on (user playtest #4 item 1): the operator's own tile
      const dropItem = async (it) => {
        for (let i = 0; i < 2; i++) {
          await c.drag(await c.piecePoint(it.uid, 0.5), await c.tilePoint(tile.row, tile.col));
          await sleep(500);
          if (await c.exists('.eqr') || !(await handItem(it.id))) return;
        }
      };
      // two items equipped normally (no dialog)
      for (const id of KIT_ITEMS.slice(0, 2)) {
        const it = await handItem(id);
        assert.ok(it, `${id} in the hand`);
        await dropItem(it);
        assert.equal(await c.exists('.eqr'), false, 'a free slot: no dialog');
        await c.page.waitForFunction((uid, id) => (globalThis.__SP__.store.get().match.private.board.find((p) => p.uid === uid)?.items || []).some((x) => x.id === id), { timeout: 5000 }, unit.uid, id);
      }
      const equipped = await itemsOf();
      assert.deepEqual(equipped.map((x) => x.id), KIT_ITEMS.slice(0, 2));
      const third = await handItem(KIT_ITEMS[2]);
      const benchSlot = await c.piecePoint(third.uid, 0.5); // where the view draws it in the hand

      // the third: dialog → 取消 → nothing sent / changed
      await dropItem(third);
      await c.page.waitForSelector('.eqr .eqr__opt', { timeout: 4000 });
      assert.deepEqual(await c.page.$$eval('.eqr__opt', (els) => els.map((el) => Number(el.dataset.uid))), equipped.map((x) => x.uid));
      assert.deepEqual(await c.page.$$eval('.eqr__opt .eqr__name', (els) => els.map((el) => el.textContent)), equipped.map((x) => ITEMS.get(x.id).name));
      await c.shot('replace-real');
      const sentBefore = (await c.requests('g.equip')).length;
      await c.click('.eqr__cancel');
      await c.page.waitForFunction(() => !document.querySelector('.eqr'), { timeout: 3000 });
      await sleep(500);
      assert.equal((await c.requests('g.equip')).length, sentBefore, '取消: no g.equip');
      assert.deepEqual(await itemsOf(), equipped, '取消: unchanged');
      assert.ok(await handItem(KIT_ITEMS[2]), '取消: the item stays in the hand');
      // ... and is drawn back on its bench slot before it is picked up again. The view keeps a dropped piece on the drop
      // tile for 1.3 s (render/app/tune.js DROP_PENDING_MS), then flies it back in a frame-timed tween: with few frames
      // (software-rendered headless Chrome on a loaded machine) the drag aimed where it stood a moment before grabbed the
      // operator under it, whose direction wheel then swallowed the retry (the 0.2.0 candidate's full pass).
      const back = await c.page.waitForFunction((uid, x, y) => {
        const r = globalThis.__SP_VIEW__?.pieceScreenRect(uid);
        return !!r && Math.abs(r.left + r.width / 2 - x) < 2 && Math.abs(r.top + r.height / 2 - y) < 2;
      }, { timeout: 15000, polling: 100 }, third.uid, benchSlot.x, benchSlot.y).then(() => true, () => false);
      assert.ok(back, '取消: the item is drawn back on its bench slot');

      // again → pick the OLDER item (not the server's default either way: explicit replaceUid) → 确认替换
      await dropItem(third);
      await c.page.waitForSelector('.eqr .eqr__opt', { timeout: 4000 });
      await c.click('.eqr__opt', null, { nth: 0 });
      await c.click('.eqr__ok');
      await c.page.waitForFunction((uid, id) => (globalThis.__SP__.store.get().match.private.board.find((p) => p.uid === uid)?.items || []).some((x) => x.id === id), { timeout: 5000 }, unit.uid, KIT_ITEMS[2]);
      const last = (await c.requests('g.equip')).pop();
      assert.deepEqual(last[1], { itemUid: third.uid, targetUid: unit.uid, replaceUid: equipped[0].uid });
      const after = await itemsOf();
      assert.deepEqual(after.map((x) => x.uid).sort(), [equipped[1].uid, third.uid].sort(), 'the engine destroyed exactly the picked item');
      assert.equal(await handItem(KIT_ITEMS[0]), null, 'the replaced item is not returned to the hand');
      await c.shot('replace-real-after');

      // 4) ready → the local battle → pause / resume
      await c.click('.readybtn');
      await c.waitFor((s) => s.phase === 'COMBAT', 'combat', 60000);
      await c.page.waitForSelector('[data-testid="pause"]', { visible: true, timeout: 15000 });
      await sleep(1500);
      const btime = () => c.page.evaluate(() => {
        const e = [...(globalThis.__SP_RUNNER__?._entries?.values() || [])].find((x) => x.own && x.battle);
        return e ? e.battle.time : null;
      });
      await c.click('[data-testid="pause"]');
      await c.page.waitForFunction(() => globalThis.__SP__.store.get().match.public?.paused === true, { timeout: 5000 });
      await c.page.waitForSelector('.pauseov', { timeout: 3000 });
      await sleep(400);
      const t1 = await btime();
      const cd1 = await c.page.$eval('.gtop__right .countdown', (el) => el.getAttribute('aria-label'));
      await sleep(2000);
      assert.equal(await btime(), t1, 'the local battle clock stands still');
      assert.equal(await c.page.$eval('.gtop__right .countdown', (el) => el.getAttribute('aria-label')), cd1, 'the countdown stands still');
      assert.deepEqual((await c.requests('g.pause')).map((r) => r[1]), [{ on: true }]);
      await c.shot('pause-real');
      await c.click('.pauseov .btn--primary', '继续作战');
      await c.page.waitForFunction(() => globalThis.__SP__.store.get().match.public?.paused === false, { timeout: 5000 });
      await c.page.waitForFunction(() => !document.querySelector('.pauseov'), { timeout: 3000 });
      await sleep(1200);
      const t2 = await btime();
      assert.ok(t2 == null || t2 > t1, `the battle runs again (${t1} → ${t2})`);
      assert.deepEqual((await c.requests('g.pause')).map((r) => r[1]), [{ on: true }, { on: false }]);
      await c.shot('pause-real-resumed');
      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('3. server restart while a match is on screen: toast + back to the lobby', { timeout: 3 * 60 * 1000 }, async () => {
    let srv = await startRealServer();
    const port = srv.port;
    const P = (await import('puppeteer-core')).default;
    const c = new Client(P, srv.base, 'restart', { prefix: 'leftover' });
    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, '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);
      const before = await c.st();
      await sleep(600);
      // an imperative dialog left open (the app's own module instance) must not survive onto the lobby
      await c.page.evaluate(() => { import('/js/ui/components.js').then((m) => { globalThis.__e2eDlg = m.confirmDialog({ title: '测试对话框', text: '服务器重启前打开' }); }); });
      await c.page.waitForSelector('.modal', { timeout: 3000 });

      // a crash / kill: no room.closed reaches the client — only the new session's welcome tells
      await srv.stop({ hard: true });
      await sleep(800);
      srv = await startRealServer({ port });
      await c.page.waitForFunction(() => [...document.querySelectorAll('.toast')].some((t) => t.textContent.includes('服务器会话已重置，上一局模拟已结束')), { timeout: 30000 });
      await c.page.waitForSelector('.lobby-screen', { timeout: 10000 });
      const s = await c.st();
      assert.notEqual(s.me, before.me, 'a new server session');
      assert.equal(s.room, null);
      assert.equal(s.phase, null);
      assert.equal(await c.exists('.modal'), false, 'no stale dialog');
      assert.equal(await c.page.evaluate(() => globalThis.__e2eDlg), false, 'the dismissed confirm resolved as cancelled');
      assert.equal(await c.exists('.awayov'), false);
      const restoring = await c.page.evaluate(() => globalThis.__SP__.store.get().ui.restoring);
      assert.equal(restoring, false);
      await c.shot('restart');
      // the lobby works on the new server: a new solo run starts
      await c.click('.mode-card', '独立模拟');
      await c.click('.diff-card', '标准模拟');
      await c.click('.create-box button', '开始独立模拟');
      await c.waitFor((x) => !!x.room, 'a new solo room on the restarted server');
      if (!(await c.st()).phase) await c.click('.room-bar__right button', '开始模拟', { timeout: 20000 });
      await c.waitFor((x) => x.phase === 'INFO_CHECK', 'briefing on the restarted server', 30000);
      // a graceful stop (Ctrl+C / SIGTERM): room.closed 'shutdown' says so first, the same clean way back — and only once
      const resetToast = () => c.page.evaluate(() => [...document.querySelectorAll('.toast')].some((t) => t.textContent.includes('服务器会话已重置')));
      await c.page.waitForFunction(() => ![...document.querySelectorAll('.toast')].some((t) => t.textContent.includes('服务器会话已重置')), { timeout: 20000 });
      await srv.stop();
      await c.page.waitForFunction(() => [...document.querySelectorAll('.toast')].some((t) => t.textContent.includes('服务器维护中')), { timeout: 15000 });
      await c.page.waitForSelector('.lobby-screen', { timeout: 10000 });
      srv = await startRealServer({ port });
      await c.waitFor((x) => x.room == null && x.phase == null, 'lobby after the graceful restart', 30000);
      await c.page.waitForFunction(() => globalThis.__SP__.net.status === 'online', { timeout: 30000 });
      await sleep(800);
      assert.equal(await resetToast(), false, 'the room was already closed by room.closed: no second notice');
      await c.shot('restart-graceful');
      // only the downtime's socket errors are expected
      const other = c.problems.filter((p) => !/WebSocket|ERR_CONNECTION_REFUSED|\/ws\b|net::ERR_/.test(p));
      assert.deepEqual(other, []);
    } finally {
      if (c.problems.length) console.log(c.problems.slice(0, 20).join('\n'));
      await c.close();
      await srv.stop();
    }
  });
});