// Scenarios of INTERACTION: click → frame → check of the state. Half of pack S3.5 a still frame
// does not accept — tabs, the drag handle, modals and spoilers exist only in motion.
//
//   node scripts/scenes.mjs            every scenario, frames into .shots/scenes/
//   node scripts/scenes.mjs tabs drag  only the named ones
//
// A failing scenario fails the command: this is acceptance, not a demonstration.

import { mkdir } from 'node:fs/promises';
import { existsSync } from 'node:fs';
import { dirname, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';

const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
const shotsDir = resolve(root, '.shots/scenes');

const toolingRoot = resolve(root, '.tooling/root');
if (existsSync(toolingRoot)) {
  const libs = resolve(toolingRoot, 'usr/lib/x86_64-linux-gnu');
  process.env.LD_LIBRARY_PATH = [libs, process.env.LD_LIBRARY_PATH].filter(Boolean).join(':');
  process.env.XDG_DATA_HOME = resolve(toolingRoot, 'usr/share');
}

const { chromium } = await import('playwright');
const { default: AxeBuilder } = await import('@axe-core/playwright');
const { build, preview } = await import('vite');

// The words a scene clicks are the product's own: interface wording comes from the message
// catalogue, chapter headings and bank terms from the fixtures the fake server answers with. A copy
// pasted in here goes stale in silence, and a scene looking for a word nobody prints any more finds
// nothing.
//
// ⚠ The specifier is BUILT rather than written out: Node resolves a module only with its `.ts`
// extension, while `tsc` rejects that extension until `allowImportingTsExtensions` is on — and
// tsconfig.json is outside this zone. The JSDoc types below go through the extensionless path,
// which only TypeScript reads, so the keys and the shape of the fixtures are still checked.
const load = (/** @type {string} */ path) => import(new URL(path, import.meta.url).href);

/** @typedef {import('../src/api/schema').components['schemas']} Schemas */
/** @typedef {import('../src/i18n/ru').MessageKey} MessageKey */

/** @type {Record<MessageKey, string>} */
const ru = (await load('../src/i18n/ru.ts')).ru;
/** @type {(line: string, variables: Record<string, string | number> | undefined) => string} */
const fill = (await load('../src/i18n/fill.ts')).fill;
/**
 * @type {{
 *   book: Schemas['Book'],
 *   books: Schemas['Book'][],
 *   chapters: Schemas['Chapter'][],
 *   notes: Schemas['Note'][],
 * }}
 */
const { book, books, chapters, notes } = await load('../src/mock/book.ts');

/**
 * The book of a given status, by the fixture's own hand: a title written out here would go stale in
 * silence the moment the fixture is edited.
 * @param {Schemas['BookStatus']} status
 */
function bookOf(status) {
  const found = books.find((row) => row.status === status);
  if (!found) throw new Error(`the fixture has no book in status ${status}`);
  return found;
}

const uploadingBook = bookOf('uploading');
const rejectedBook = bookOf('rejected');
const pausedBook = bookOf('paused');
/** @type {{ terms: Schemas['BankTerm'][], bankTerms: Schemas['BankTerm'][] }} */
const { terms, bankTerms } = await load('../src/mock/bank.ts');
/** @type {{ scaleTerms: Schemas['BankTerm'][] }} */
const { scaleTerms } = await load('../src/mock/scale.ts');
/** @typedef {import('playwright').Page} Page */
/** @typedef {import('playwright').Locator} Locator */
/** @typedef {(name: string) => Promise<unknown>} Shot */

/**
 * Interface wording by catalogue key — a scene looks for exactly what the screen prints. An unknown
 * key throws: a locator built out of `undefined` matches ANY node of its role, and the scene would
 * go green having checked nothing.
 *
 * ⚠ The FILLING is the application's own (`src/i18n/fill.ts`), not a copy of it. S3.7 wrote a
 * second one right here, with a different rule for a place left without a variable, and its own
 * report claimed the module was shared — the acceptance found the claim false. A scene has to
 * build the phrase the screen prints, which means by the same code.
 * @param {MessageKey} key @param {Record<string, string | number>} [variables]
 */
function say(key, variables = {}) {
  const line = ru[key];
  if (line === undefined) throw new Error(`no such key in the message catalogue: ${key}`);
  return fill(line, variables);
}

/**
 * The heading a chapter carries in the fixture: the tree prints it, the scene clicks it. By id and
 * not by position — the fixture deliberately keeps a chapter with no heading at all and one with no
 * number, and both would shift under an index.
 * @param {string} id
 */
function heading(id) {
  const found = chapters.find((row) => row.id === id)?.heading;
  if (found === null || found === undefined || found === '') {
    throw new Error(`fixture chapter ${id} carries no heading`);
  }
  return found;
}

/**
 * The translated side of a bank term in the fixture. Terms are looked up by id rather than repeated
 * as a word: the fixture owns the wording, and a pasted copy goes stale in silence.
 * @param {Schemas['BankTerm'][]} bank @param {string} id
 */
function dstOf(bank, id) {
  const dst = bank.find((row) => row.id === id)?.dst;
  if (dst === undefined || dst === '') throw new Error(`fixture term ${id} carries no translation`);
  return dst;
}

/** @param {boolean} condition @param {string} what */
function check(condition, what) {
  if (!condition) throw new Error(`scenario failed: ${what}`);
  console.log(`  ✓ ${what}`);
}

/**
 * An axe run over the OPEN state. `npm run shot` checks routes only, that is, a screen that opens on
 * a click (the bank table, the modals) never saw the accessibility gate at all.
 * The policy is the same as in shot.mjs: contrast goes into the report, the rest fails the scenario.
 * @param {Page} page @param {string} what
 */
async function audit(page, what) {
  // Let the animations play out. Bought by the acceptance run of 10.08: axe, started in the middle
  // of the 220ms appearance of the card, was measuring SEMI-TRANSPARENT text and printing contrast
  // nodes that are not there on the settled frame.
  await settle(page);
  const axe = await new AxeBuilder({ page }).analyze();
  const blocking = axe.violations.filter((v) => v.id !== 'color-contrast');
  for (const v of axe.violations.filter((v) => v.id === 'color-contrast')) {
    console.log(`  contrast (accepted as is): ${v.nodes.length} node(s)`);
    // The NODE, not only the count: a bare number is a thing nobody can act on, and the same
    // omission cost the acceptance of S3.6 a hunt by hand.
    for (const node of v.nodes)
      console.log(`     ${node.target.join(' ')} — ${node.html.slice(0, 120)}`);
  }
  if (blocking.length > 0) {
    for (const v of blocking) {
      console.error(`  ✖ ${v.id}: ${v.help} — ${v.nodes.length} node(s)`);
      // The node is printed right away: without it a "single violation" has to be hunted by hand.
      for (const node of v.nodes)
        console.error(`     ${node.target.join(' ')} — ${node.html.slice(0, 160)}`);
    }
    throw new Error(`Accessibility: ${blocking.length} violation(s) — ${what}`);
  }
  console.log(`  ✓ accessibility gate: ${what}`);
}

/** @type {Record<string, (page: Page, shot: Shot) => Promise<void>>} */
const scenes = {
  // Remark 2 plus the prompt's acceptance: five single clicks — one preview tab.
  /** @param {Page} page @param {Shot} shot */
  async tabs(page, shot) {
    await open(page, '/showcase');
    const tabs = page.locator('[role="tab"]');
    // Tree rows are looked for INSIDE the left panel: the same chapter names stand in the summary
    // of notes on the right as well, and with no area to search in the locator points at two things
    // at once.
    /** @param {string} name */
    const chapter = (name) => page.locator('nav').getByText(name, { exact: true });
    for (const name of [
      heading('ch_1'),
      heading('ch_3'),
      heading('ch_5'),
      heading('ch_7'),
      heading('ch_6'),
    ]) {
      await chapter(name).click();
    }
    await shot('tabs-preview');
    check(
      (await page.locator('[role="tab"][data-preview="true"]').count()) === 1,
      'after five single clicks exactly one preview tab',
    );
    const before = await tabs.count();

    await chapter(heading('ch_7')).dblclick();
    check(
      (await page.locator('[role="tab"][data-preview="true"]').count()) === 0,
      'a double click on a chapter pins the tab — no preview is left',
    );

    await chapter(heading('ch_8')).click();
    await shot('tabs-pinned');
    check(
      (await tabs.count()) === before + 1 &&
        (await page.locator('[role="tab"][data-preview="true"]').count()) === 1,
      'the next single click opens a NEW preview tab beside the pinned one',
    );

    // A double click on the tab itself — the second way of pinning, from the VS Code model.
    await page.locator('[role="tab"][data-preview="true"]').dblclick();
    check(
      (await page.locator('[role="tab"][data-preview="true"]').count()) === 0,
      'a double click on the preview tab pins it',
    );

    // ⚠ A double click PAST a chapter row must pin nothing. The previous implementation took the
    // "current selection", and neither the book nor empty space moves the selection — so somebody
    // else's tab got pinned (found by an adversarial review with a measurement, not by reasoning).
    await chapter(heading('ch_10')).click();
    const pinnedBefore = await tabs.count();
    await page.locator('nav').getByText(book.title, { exact: true }).dblclick();
    check(
      (await tabs.count()) === pinnedBefore &&
        (await page.locator('[role="tab"][data-preview="true"]').count()) === 1,
      'a double click on the row of the BOOK does not touch the tabs',
    );

    // The keyboard twin of the double click: Enter on the selected row pins it.
    await page.keyboard.press('Enter');
    check(
      (await page.locator('[role="tab"][data-preview="true"]').count()) === 1,
      'Enter on the row of the book does not touch the tabs either',
    );
    await chapter(heading('ch_10')).click();
    await page.keyboard.press('Enter');
    check(
      (await page.locator('[role="tab"][data-preview="true"]').count()) === 0,
      'Enter on the selected chapter row pins the tab',
    );

    // ⚠ Opening a chapter must not flash a card. Watch OPACITY, not the DOM: the card is held back
    // until the wait is worth explaining. The press is held 80ms, as a hand holds it — that is the
    // window the chapter is read in, before the click completes.
    await page.evaluate(() => {
      /** @type {number[]} */
      const seen = [];
      Object.assign(window, { __cards: seen });
      const tick = () => {
        const card = document.querySelector('main h2')?.closest('div');
        if (card && Number(getComputedStyle(card).opacity) > 0.02) seen.push(1);
        if (seen.length < 1) requestAnimationFrame(tick);
      };
      requestAnimationFrame(tick);
    });
    const row = await chapter(heading('ch_9')).boundingBox();
    if (!row) throw new Error('chapter row not found');
    await page.mouse.move(row.x + row.width / 2, row.y + row.height / 2);
    await page.mouse.down();
    await page.waitForTimeout(80);
    await page.mouse.up();
    await page.waitForTimeout(900);
    check(
      (await page.evaluate(() => Reflect.get(window, '__cards'))).length === 0,
      'opening a chapter does not flash a waiting card before the text',
    );

    // Second-round remark 4: a short title was clipped before its longer neighbour, because the tabs
    // shared the shortage of space in proportion to their width. The row scrolls now, and clipping
    // happens ONLY to a tab that has run into its own limit.
    const clipped = await page.locator('[role="tab"]').evaluateAll((nodes) =>
      nodes
        .map((node) => {
          const title = node.querySelector('span');
          // ⚠ Without this the guard would go green in silence: let the title stop being a `span`,
          // and `title` becomes null, `cut` becomes false, and "none is clipped" a truth about
          // nothing.
          if (!title) throw new Error('the tab has no span title — the clipping guard went blind');
          const max = parseFloat(getComputedStyle(node).maxWidth);
          return {
            text: title.textContent ?? '',
            cut: title.scrollWidth > title.clientWidth + 1,
            atMax: node.getBoundingClientRect().width >= max - 1,
          };
        })
        .filter((tab) => tab.cut && !tab.atMax),
    );
    check(
      clipped.length === 0,
      `no tab is clipped without having run into its width limit (clipped: ${clipped.length})`,
    );

    // Acceptance finding 8.2: the selected row has a blue ground and the state is PERMANENT (an open
    // chapter is selected always), while its content is drawn in quiet greys. axe does not catch
    // this — the contrast of non-text it does not check at all, and the row with the counter it
    // never saw.
    // The row picked is the one that has EVERYTHING: the notes counter, the icon and the progress
    // track — otherwise the guard would silently leave half of the pairs unchecked.
    await chapter(heading('ch_2')).click();
    const faint = await contrastInSelectedRow(page);
    check(
      faint.length === 0,
      `everything on the selected row is readable: ${faint.map((part) => `${part.what} ${part.ratio}:1 < ${part.floor}`).join(' · ') || 'not a single pair below the floor'}`,
    );
  },

  // Ф-19: switching a tab no longer unmounts the panel, the scroll lives on.
  /** @param {Page} page @param {Shot} shot */
  async scroll(page, shot) {
    await open(page, '/scale');

    // The long tail folds by hundreds (Ф-12): 2284 sections stand as 23 folds, and a click on a fold
    // is a fold — not a row that answers with nothing. Checked here because this scene already opens
    // the book that has the tail. The FIRST fold is the one in the DOM: the tree is virtualized, so
    // a fold a thousand rows down is not drawn at all.
    const fold = page
      .locator('nav [role="row"]')
      .filter({ hasText: say('library.chapterRange', { from: 1, to: 100 }) });
    check((await fold.count()) === 1, 'the tree of 2284 sections is folded by hundreds');
    const opened = await page.locator('nav [role="row"]').count();
    await fold.first().click();
    await page.waitForTimeout(300);
    const closed = await page.locator('nav [role="row"]').count();
    check(
      closed < opened,
      `a click on a fold closes it (${String(opened)} → ${String(closed)} rows in the DOM)`,
    );
    await fold.first().click();
    await page.waitForTimeout(300);
    check(
      (await page.locator('nav [role="row"]').count()) === opened,
      'and a second click opens it again',
    );

    const bank = page.locator(`[role="grid"][aria-label="${say('bank.tableLabel')}"]`);
    await bank.evaluate((node) => node.scrollTo(0, 9000));
    const before = await bank.evaluate((node) => node.scrollTop);
    check(before > 8000, `the bank scroll came to rest at ${String(before)}px`);

    await page.getByRole('tab', { name: say('about.tab') }).click();
    await page.getByRole('tab', { name: say('bank.tab') }).click();
    await shot('scroll-kept');
    const after = await bank.evaluate((node) => node.scrollTop);
    check(
      after === before,
      `after leaving for the neighbouring tab and coming back the offset is the same (${String(after)})`,
    );
  },

  // Remark 18: the resize strip does not stick after the drag is released.
  /** @param {Page} page @param {Shot} shot */
  async drag(page, shot) {
    await open(page, '/showcase');
    const separator = page.locator('[role="separator"]').first();
    const box = await separator.boundingBox();
    if (!box) throw new Error('separator not found');
    const y = box.y + box.height / 2;
    await page.mouse.move(box.x + box.width / 2, y);
    await page.mouse.down();
    await page.mouse.move(box.x + 90, y, { steps: 12 });
    await shot('drag-active');
    const dragging = await handleStyle(separator);
    // The numbers come from vojo (style.css.ts): 0.55 in the drag and the pill growing to 48px.
    check(
      dragging.opacity === '0.55',
      `in the drag the pill shows through at ${dragging.opacity}, as in vojo`,
    );
    check(
      dragging.height === '48px',
      `in the drag the pill grows to ${dragging.height}, as in vojo`,
    );

    await page.mouse.up();
    await page.mouse.move(box.x + 400, y + 200);
    await shot('drag-released');
    const released = await handleStyle(separator);
    check(
      released.opacity === '0',
      `after the release the pill went out (opacity ${released.opacity}), the strip did not stick`,
    );
    check(
      (await page.locator('[role="separator"]').first().getAttribute('data-separator')) === 'focus',
      'the library HOLDS data-separator="focus" meanwhile — sticking is cured by style, not by luck',
    );
  },

  // Remarks 7, 8, 13, 20: the context panel — the summary of notes, the bank with spoilers, an
  // honest state instead of a stub button.
  /** @param {Page} page @param {Shot} shot */
  async context(page, shot) {
    await open(page, '/showcase');
    const panel = page.locator('aside');

    await panel.getByRole('tab', { name: say('notes.tab') }).click();
    await shot('context-notes');
    // Looked for in ITS OWN list: with keep-alive the neighbouring tab is in the DOM too, and
    // `[role="option"]` over the whole panel counts the rows of the bank along with it.
    const summary = panel.locator(
      `[role="listbox"][aria-label="${say('notes.listLabel')}"] [role="option"]`,
    );
    // Exactly as many as there are notes in the book's fixture. The check is not cosmetic: a row key
    // built out of the chapter collapsed three notes of one chapter into a single row.
    check(
      (await summary.count()) === notes.length,
      'the summary shows ALL the notes of the book, several in one chapter included',
    );
    await summary.first().click();
    check(
      (await page.locator('[role="tab"][data-preview="true"]').count()) === 1,
      'a row of the summary opens its chapter as a preview tab',
    );

    // S4: a click on a BOOK opens its state (the zone's §2), and the states that have something to
    // say beyond a word say it on the card. The fixture holds every one of the eleven; these three
    // are the ones with a sentence attached, and each is reached by choosing its book.
    await panel.getByRole('tab', { name: say('about.tab') }).click();
    for (const { title, phrase, what } of [
      { title: uploadingBook.title, phrase: say('about.uploading'), what: 'a book still arriving' },
      {
        title: rejectedBook.title,
        phrase: say('rejected.sourceUnreadable'),
        what: 'a book that could not be parsed',
      },
      {
        title: pausedBook.title,
        phrase: say('paused.creditExhausted'),
        what: 'a run halted on its ceiling',
      },
    ]) {
      await page.locator('nav').getByText(title, { exact: true }).click();
      // The wait is the assertion's own timeout, and its verdict is what `check` prints: a bare
      // `check(true, …)` after a wait reads as a tautology to whoever comes next.
      const said = await page
        .waitForFunction(
          (want) => document.querySelector('aside')?.textContent?.includes(want) === true,
          phrase,
          { timeout: 10_000 },
        )
        .then(
          () => true,
          () => false,
        );
      check(said, `${what}: the card says so in words, not by colour alone («${phrase}»)`);
    }
    await shot('context-book-state');
    await audit(page, 'the card of a book in an intake state');
  },

  // Second-round remark 7: the bank is a TABLE in the right panel (not a tab in the centre), with
  // columns, a search, a filter by kind and a spoiler on the description, not on the translation.
  /** @param {Page} page @param {Shot} shot */
  async bank(page, shot) {
    await open(page, '/showcase');
    const panel = page.locator('aside');
    await panel.getByRole('tab', { name: say('bank.tab') }).click();
    await shot('bank-table');
    const table = panel.getByRole('grid', { name: say('bank.tableLabel') });
    check(await table.isVisible(), 'the bank lives in the right panel and is shown as a table');

    check(
      (await page.getByRole('grid', { name: say('bank.tableLabel') }).count()) === 1,
      'there is exactly one bank table in the application — no duplicate in the centre',
    );
    // The WHOLE set is asserted at once: a check for "no «state» column" would pass on a «signature»
    // column just as well, that is, it would guard a word and not the make-up of the screen.
    // Compared in lower case: the headings are set in small caps by CSS means, and `innerText`
    // returns them already upper-cased — what has to be checked is the SET of columns, not the
    // typesetting.
    const columns = (await table.getByRole('columnheader').allInnerTexts()).map((name) =>
      name.toLowerCase(),
    );
    const expected = [
      say('bank.columnTerm'),
      say('bank.columnTranslation'),
      say('bank.columnKind'),
      say('bank.columnSense'),
    ].map((name) => name.toLowerCase());
    check(
      JSON.stringify(columns) === JSON.stringify(expected),
      `the columns of the table are exactly those: ${columns.join(' · ')} — no signing state among them`,
    );

    // Owner's report, 10.08: the header's ground sat on a rowgroup of ZERO height and so painted
    // nothing — scrolled rows read straight through the column titles. Ask what is drawn there.
    await table.evaluate((node) => {
      node.scrollTop = 400;
    });
    // What catches the defect is the GROUND'S OPACITY: `elementsFromPoint` follows paint order, not
    // transparency (checked against the counterfactual). The hit test is only a gate — while a
    // scroll runs the virtualizer takes the pointer off the content and the grid itself answers.
    const header = await page
      .waitForFunction(
        () => {
          const node = document.querySelector('[role="grid"]');
          const th = node?.querySelector('[role="columnheader"]');
          if (!th) return null;
          const box = th.getBoundingClientRect();
          const [top] = document.elementsFromPoint(
            box.left + box.width / 2,
            box.top + box.height / 2,
          );
          if (top === node) return null; // the pointer is still off — the scroll has not settled
          const parts = getComputedStyle(th).backgroundColor.match(/[\d.]+/g) ?? [];
          return { role: top?.getAttribute('role'), opacity: Number(parts[3] ?? 1) };
        },
        null,
        { timeout: 5000 },
      )
      .then((handle) => handle.jsonValue());
    check(
      header?.role === 'columnheader' && header.opacity === 1,
      `a scrolled row does not show through the header (on top ${String(header?.role)}, ground opacity ${String(header?.opacity)})`,
    );
    await table.evaluate((node) => {
      node.scrollTop = 0;
    });

    // Owner's report, 10.08: a panel squeezed to its stop and let back out left the table
    // squeezed, with a gap down its right side. Columns must fill the table at ANY width.
    const filled = async (/** @type {string} */ what) => {
      const spread = await columnSpread(table);
      // Against the CONTENT width, not the window: the latter holds arithmetically whenever there
      // is room to spare, so on its own it guards almost nothing.
      check(
        Math.abs(spread.sum - spread.content) <= 1,
        `${what}: the columns fill the table whole (${spread.sum} of ${spread.content}, window ${spread.grid})`,
      );
      // ⚠ And it does not run past the panel: columns MUST give way when space runs short. A narrow
      // panel catches it (before the fix: content 555, window 520).
      check(
        spread.content <= spread.grid + 1,
        `${what}: the table does not run past the edge of the panel (content ${spread.content}, window ${spread.grid})`,
      );
      return spread.cut;
    };
    /** @param {string} what @param {string[]} cut */
    const fits = (what, cut) =>
      check(
        cut.length === 0,
        `${what}: the columns sized by content show it whole (clipped: ${cut.join(' · ') || 'nothing'})`,
      );
    fits('at its own width', await filled('at its own width'));
    // At its stop the columns are cramped, and it shows whether they give way. Clipping is legitimate
    // here, running past the panel is not.
    // ⚠ Each drag's offsets count from ITS OWN start: letting the panel back out needs a second drag.
    await pull(page, [400]);
    await filled('the panel squeezed to its stop');
    await pull(page, [-200]);
    fits(
      'after being squeezed to the stop and let back out',
      await filled('after being squeezed to the stop and let back out'),
    );

    // The spoiler covers the DESCRIPTION, the translation stays readable.
    const spoilered = dstOf(terms, 't_13');
    const row = table.getByRole('row').filter({ hasText: spoilered });
    // The colour is taken apart into numbers rather than compared with a string: a literal colour in
    // the code is forbidden by the gate, and the comparison has to be against the property anyway,
    // not against the way the browser prints it.
    const covered = await row.locator('[data-sense]').evaluate((node) => {
      const style = getComputedStyle(node);
      return { blur: style.filter, clips: style.overflow !== 'visible' };
    });
    // ⚠ The second half guards the square edge: a blur mixes in what lies BEYOND the ink, so
    // anything clipping at the glyphs turns it into a rectangle.
    check(
      covered.blur.startsWith('blur(') && !covered.clips,
      `the description is covered by a real blur and clipped by nothing (${covered.blur}, clipping ${String(covered.clips)})`,
    );
    check(
      await row.getByText(spoilered, { exact: true }).isVisible(),
      'the translation itself is visible meanwhile',
    );
    await row.locator('[data-sense]').hover();
    await page.waitForTimeout(250); // the colour transition is 140ms — else we read mid-animation
    check(
      !(await isCovered(row.locator('[data-sense]'))),
      'hovering the cell reveals the description',
    );

    // A blur covers nothing from a screen reader, so the description is taken out of the
    // accessibility tree, and what reveals it is a toggle — the only way that works for the mouse,
    // and for the keyboard, and for the reader.
    check(
      (await row.locator('[data-sense]').getAttribute('aria-hidden')) === 'true',
      'while it is not revealed, the description is out of the accessibility tree',
    );
    await panel.getByRole('button', { name: say('bank.showSenses') }).click();
    await page.waitForTimeout(300);
    const revealed = await row.locator('[data-sense]').evaluate((node) => {
      const parts = getComputedStyle(node).color.match(/[\d.]+/g) ?? [];
      return {
        hidden: node.getAttribute('aria-hidden'),
        filter: getComputedStyle(node).filter,
        // A revealed line does NOT fade out: a tail mask read as the end of the line going dark
        // (owner's report, 10.08), and over a blur it clipped the whole thing into a rectangle.
        mask: getComputedStyle(node).maskImage,
        opacity: Number(parts[3] ?? 1),
        pressed: document.querySelector('[aria-pressed]')?.getAttribute('aria-pressed'),
      };
    });
    check(
      revealed.hidden === null &&
        revealed.opacity === 1 &&
        revealed.filter === 'none' &&
        revealed.mask === 'none',
      `the toggle reveals the descriptions for the eyes and for the reader alike (${JSON.stringify(revealed)})`,
    );
    await panel.getByRole('button', { name: say('bank.hideSenses') }).click();
    await page.waitForTimeout(250);

    // Walking with the arrows does NOT reveal the descriptions: the spoiler would otherwise be
    // opened one row per keypress, while the keyboard is served by the toggle above.
    await page.mouse.move(0, 0);
    // The CELL is clicked: `role="row"` itself is a container of zero height, there is nothing on it
    // to click, and a person lands in a cell as well.
    await table.getByRole('rowheader').first().click();
    await page.keyboard.press('ArrowDown');
    await page.waitForTimeout(250);
    const walked = await page.evaluate(() => {
      const cell = document.activeElement?.closest('[role="row"]')?.querySelector('[data-sense]');
      return cell ? getComputedStyle(cell).filter !== 'none' : null;
    });
    check(
      walked === true,
      `walking the rows from the keyboard does not open the descriptions (covered: ${walked})`,
    );

    // ⚠ The spoiler must hold in FORCED COLOURS too: the glyph-shadow version vanished there
    // outright — the system drops `text-shadow` — and printed every description in plain text.
    await page.emulateMedia({ forcedColors: 'active' });
    await page.waitForTimeout(200);
    const forced = await row
      .locator('[data-sense]')
      .evaluate((node) => ({ filter: getComputedStyle(node).filter }));
    check(
      forced.filter.startsWith('blur('),
      `in high-contrast mode the description stays covered (${JSON.stringify(forced)})`,
    );
    await page.emulateMedia({ forcedColors: 'none' });
    await page.waitForTimeout(200);

    // The spoiler must not leak past the blur. Tooltips on the term and on the translation are
    // legal — what is checked is exactly what is covered: the text of the description occurs in no
    // `title` of the row, and a mouse selection does not copy it — the text of a covered description
    // remains text of the page.
    const titles = await row
      .locator('[title]')
      .evaluateAll((nodes) => nodes.map((node) => node.getAttribute('title') ?? ''));
    // Against the row's ACTUAL description, not a literal from the fixture: a nailed-down word
    // turns the check silently vacuous the moment the fixture changes.
    const hidden = (await row.locator('[data-sense]').innerText()).trim();
    check(
      titles.length > 0 && hidden.length > 0 && titles.every((title) => !title.includes(hidden)),
      `the tooltips of the row (${String(titles.length)}) do not print the covered description «${hidden}»`,
    );
    const copied = await row.locator('[data-sense]').evaluate((node) => {
      const range = document.createRange();
      range.selectNodeContents(node);
      const selection = getSelection();
      selection?.removeAllRanges();
      selection?.addRange(range);
      const text = selection?.toString() ?? '';
      selection?.removeAllRanges();
      return text;
    });
    check(copied === '', `selecting a covered description copies nothing (taken: «${copied}»)`);

    // A narrow panel drops columns instead of squeezing them: the kind column comes only on a wide
    // one. The description is covered on ALL rows, not on the selected ones: the spoiler is a
    // property of the column. Both the cursor and the FOCUS are taken away: the row they stand on
    // would otherwise stay revealed.
    await page.mouse.move(0, 0);
    await page.getByRole('searchbox', { name: say('bank.search') }).focus();
    await page.waitForTimeout(250);
    const senses = await table
      .locator('[role="row"] [data-sense]')
      .evaluateAll((nodes) => nodes.map((node) => getComputedStyle(node).filter !== 'none'));
    check(
      senses.length > 3 && senses.every(Boolean),
      `the description is covered in all ${String(senses.length)} rows, not in single ones`,
    );

    const rows = () => table.getByRole('row').count();
    const all = await rows();
    await page.getByRole('radio', { name: new RegExp(`^${say('kind.name')}`) }).click();
    const names = await rows();
    check(names < all, `the filter by kind narrows the table (${String(all)} → ${String(names)})`);
    check(
      (await table.getByRole('columnheader', { name: say('bank.columnKind') }).count()) === 0,
      'on a tab of one kind the kind column goes: it would repeat the name of that tab in every row',
    );
    await shot('bank-kind');

    // ⚠ Every frame of the return, not just where it settles: a hidden column whose width was
    // dropped comes back as a plain share for one frame — the neighbour jumped 13px.
    await page.evaluate(() => {
      /** @type {string[]} */
      const seen = [];
      Object.assign(window, { __layouts: seen });
      const tick = () => {
        seen.push(
          [...document.querySelectorAll('aside [role="columnheader"]')]
            .map((head) => ({ x: head.getBoundingClientRect().left, head }))
            .sort((a, b) => a.x - b.x)
            .map(
              ({ head }) => `${head.textContent}=${Math.round(head.getBoundingClientRect().width)}`,
            )
            .join(' '),
        );
        if (seen.length < 90) requestAnimationFrame(tick);
      };
      requestAnimationFrame(tick);
    });
    await page.getByRole('radio', { name: new RegExp(`^${say('bank.kindAll')}`) }).click();
    await page.waitForTimeout(1600);
    check(
      await table.getByRole('columnheader', { name: say('bank.columnKind') }).isVisible(),
      'on "all" the kind column comes back — there it is the only way to see the kind of a row',
    );
    const layouts = await page.evaluate(() => {
      const seen = /** @type {string[]} */ (Reflect.get(window, '__layouts'));
      return [...new Set(seen.filter((row) => row.split(' ').length === 4))];
    });
    check(
      layouts.length === 1,
      `the return to "all" does not jerk the columns: layouts over 90 frames ${layouts.length} (${layouts.join(' | ')})`,
    );
    await page.getByRole('searchbox', { name: say('bank.search') }).fill(dstOf(terms, 't_9'));
    // We wait for the SETTLING (the table's repaint is deferred), while the number is asserted by
    // the check itself.
    await page.waitForTimeout(700);
    await shot('bank-search');
    check((await rows()) === 2, `the search left the header and one row (${await rows()} in all)`);
    check(
      await panel
        .getByText(say('bank.shown', { shown: 1, total: bankTerms.length }), { exact: false })
        .isVisible(),
      'the foot says how many rows of the bank are left after the narrowing',
    );

    // Nothing found: the table KEEPS its head, and the message stands right under it rather than at
    // the foot of the panel (an empty collection makes the library reserve the whole height).
    await page.getByRole('searchbox', { name: say('bank.search') }).fill('zzz');
    await page.waitForTimeout(700);
    await shot('bank-empty');
    const nothing = await panel.evaluate((node) => {
      const head = node.querySelector('[role="columnheader"]');
      const message = node.querySelector('[role="grid"]')?.parentElement?.querySelector('p');
      return {
        heads: node.querySelectorAll('[role="columnheader"]').length,
        rows: node.querySelectorAll('[role="grid"] [role="row"]').length,
        gap: Math.round(
          (message?.getBoundingClientRect().top ?? 0) - (head?.getBoundingClientRect().bottom ?? 0),
        ),
      };
    });
    check(
      nothing.heads === 4 && nothing.rows === 1,
      `on an empty result the head and its ${String(nothing.heads)} columns remain, with no data rows`,
    );
    check(
      nothing.gap >= 0 && nothing.gap < 40,
      `the message stands right under the head, not at the foot of the panel (gap ${String(nothing.gap)}px)`,
    );
    await page.getByRole('searchbox', { name: say('bank.search') }).fill('');
    await page.waitForTimeout(700);
    await audit(page, 'the bank table');
  },

  // Acceptance finding 8.1, kept as a GUARD rather than as a fix: a table mounted inside a hidden
  // keep-alive tab was reported to lose its measured widths. Measured here instead of believed, and
  // it does not happen — a layout query inside a `content-visibility: hidden` subtree forces the
  // layout it needs, so the virtualizer has its rows and `read()` has its columns (probe: 116 cells
  // while hidden, widths 121·122·133·232, identical to the tab that was never left). The scene
  // stays because the scenario is real and nothing else covers it.
  /** @param {Page} page @param {Shot} shot */
  async hidden(page, shot) {
    await page.goto(`${origin}/scale`, { waitUntil: 'load' });
    const panel = page.locator('aside');
    // We leave the bank BEFORE it has answered: the tabs are drawn at once, the data are not.
    await panel.getByRole('tab', { name: say('about.tab') }).click();
    // ⚠ The PRECONDITION is asserted and not hoped for (acceptance of S3.7, finding 5): if the bank
    // had already arrived by the time the tab was left, this scene would be measuring an ordinary
    // table and going green about nothing.
    check(
      (await panel.getByRole('grid', { name: say('bank.tableLabel') }).count()) === 0,
      'the bank had not arrived by the time its tab was left — which is what this scene is about',
    );
    await page.waitForFunction(() => document.documentElement.dataset.screen === 'ready', null, {
      timeout: 15_000,
    });
    await page.evaluate(() => document.fonts.ready);

    await panel.getByRole('tab', { name: say('bank.tab') }).click();
    await page.waitForTimeout(600);
    await shot('hidden-bank');
    const table = panel.getByRole('grid', { name: say('bank.tableLabel') });
    const hiddenThenShown = await columnSpread(table);

    // The same table that was never left, for comparison. Checking "nothing is clipped" alone would
    // not do: the fallback the defect would leave behind is equal shares, and equal shares clip
    // nothing in a panel this wide — the guard has to compare the WIDTHS with the ones the same
    // content produces when the tab was visible all along.
    await open(page, '/scale');
    await page.waitForTimeout(600);
    const neverHidden = await columnSpread(
      page.locator('aside').getByRole('grid', { name: say('bank.tableLabel') }),
    );
    // ⚠ Three checks and not one, because the differential alone is a guard a SYMMETRIC regression
    // walks straight through (acceptance of S3.7, finding 5): two tables that both fell back to
    // equal shares — or both drew nothing at all — measure the same as each other.
    check(
      hiddenThenShown.widths.length === 4 && hiddenThenShown.sum > 0,
      `the table is drawn at all: ${String(hiddenThenShown.widths.length)} columns, ` +
        `${String(hiddenThenShown.sum)}px`,
    );
    check(
      new Set(hiddenThenShown.widths.slice(0, 3)).size > 1,
      `and its columns are sized by their CONTENT rather than by equal shares ` +
        `(${hiddenThenShown.widths.join('·')})`,
    );
    check(
      hiddenThenShown.widths.join('·') === neverHidden.widths.join('·'),
      `a table mounted in a hidden tab measures the same as one that was never left ` +
        `(${hiddenThenShown.widths.join('·')} against ${neverHidden.widths.join('·')})`,
    );
    check(
      hiddenThenShown.cut.length === 0,
      `and it clips nothing (${hiddenThenShown.cut.join(' · ') || 'nothing'})`,
    );
  },

  // Debt S3.6: zoom at 125/150/200% and the narrow panel were measured by hand, and no guard was
  // left. For the layout, browser zoom is the same viewport in CSS pixels: 1440 at 150% gives 960.
  /** @param {Page} page @param {Shot} shot */
  async zoom(page, shot) {
    const base = page.viewportSize() ?? { width: 1440, height: 900 };
    // The panel library persists its layout, so a scene that squeezes the window would hand the
    // next one a shell it never asked for — and `perf`, which runs after this, measures a drag.
    await open(page, '/showcase');
    const stored = await page.evaluate(() => JSON.stringify(localStorage));
    /** @type {{percent: number, width: number, height: number}[]} */
    const steps = [
      { percent: 125, width: 1152, height: 720 },
      { percent: 150, width: 960, height: 600 },
      { percent: 200, width: 720, height: 450 },
    ];
    for (const { percent, width, height } of steps) {
      await page.setViewportSize({ width, height });
      await open(page, '/showcase');
      await page
        .locator('aside')
        .getByRole('tab', { name: say('bank.tab') })
        .click();
      await page.waitForTimeout(400);
      await shot(`zoom-${percent}`);

      const layout = await page.evaluate(() => {
        const footer = document.querySelector('footer');
        const gaps = document.querySelectorAll('[role="separator"]').length;
        return {
          overflow: document.documentElement.scrollWidth - document.documentElement.clientWidth,
          panels: [...document.querySelectorAll('nav, main, aside')].map((node) =>
            Math.round(node.getBoundingClientRect().width),
          ),
          edges: [...document.querySelectorAll('nav, main, aside')].map((node) => ({
            left: Math.round(node.getBoundingClientRect().left),
            right: Math.round(node.getBoundingClientRect().right),
          })),
          // How much of the centre its own slot cuts off: the reader's second column goes first.
          centreCut: Math.max(
            0,
            Math.round(
              (document.querySelector('main')?.getBoundingClientRect().right ?? 0) -
                (document.querySelector('aside')?.getBoundingClientRect().left ?? 0) +
                gaps * 0,
            ),
          ),
          statusCut: [...(footer?.querySelectorAll('span') ?? [])].reduce(
            (worst, span) => Math.max(worst, span.scrollWidth - span.clientWidth),
            0,
          ),
        };
      });
      check(
        layout.overflow <= 0,
        `${percent}%: the window does not run sideways (overflow ${layout.overflow}px)`,
      );
      // Not "each is wider than zero" — the library cannot give a panel a negative width, so that
      // form would hold on any layout at all. What is asked is that the three still stand side by
      // side inside the window, in order and without lying on top of one another.
      // ⚠ STRICTLY to the right, not "no further left": equal lefts are exactly what a stack has,
      // and the check passed on one (acceptance of S3.7, finding 8).
      //
      // The stronger form — each panel begins where the previous one ENDS — is deliberately NOT a
      // gate: from 125% the centre already runs under the right panel by the number printed below,
      // and that is Ф-54, an open question of interface density that belongs to the owner (В-7).
      // A gate red by construction teaches people to skip the command, so the overlap is printed
      // and the order is asserted.
      check(
        layout.edges.length === 3 &&
          layout.edges.every(({ left, right }) => left >= 0 && right <= width + 1) &&
          layout.edges.every(
            ({ left }, index) => index === 0 || left > (layout.edges[index - 1]?.left ?? 0),
          ),
        `${percent}%: the three panels stand side by side inside the window ` +
          `(${layout.edges.map(({ left, right }) => `${left}‥${right}`).join(' · ')})`,
      );
      // The centre keeps a floor of its own and its CONTENT is cut by it long before the window is:
      // printed rather than asserted, because the floor is the owner's question of interface density
      // (BACKLOG Ф-36/Ф-54) and a gate red by design would only teach people to skip the command.
      console.log(`  centre content cut by ${String(layout.centreCut)}px at ${percent}%`);
      // Not "the strip is inside the window" — the footer's bottom is the window's by construction.
      // What zoom actually threatens is the TEXT in it: it is the first thing to be cut.
      check(
        layout.statusCut === 0,
        `${percent}%: the text of the status strip is not cut (${String(layout.statusCut)}px past its box)`,
      );
      const table = page.locator('aside').getByRole('grid', { name: say('bank.tableLabel') });
      const spread = await columnSpread(table);
      // The width check alone would go green on a table that drew nothing (0 <= anything), so the
      // columns are counted first.
      check(
        spread.sum > 0,
        `${percent}%: the bank table is drawn at all (${spread.sum}px of columns)`,
      );
      check(
        spread.content <= spread.grid + 1,
        `${percent}%: the bank table does not run past the edge of the panel (${spread.content} at window ${spread.grid})`,
      );
      await audit(page, `the shell at ${percent}%`);
    }

    await page.setViewportSize(base);
    await page.evaluate((was) => {
      localStorage.clear();
      for (const [key, value] of Object.entries(JSON.parse(was))) localStorage.setItem(key, value);
    }, stored);
  },

  // The table's performance on the long tail: 1200 terms, scrolling and search. The numbers are
  // printed into the report; the thresholds are coarse and catch a collapse, not a wobble
  // (measurement, not belief).
  /** @param {Page} page @param {Shot} shot */
  async perf(page, shot) {
    await open(page, '/scale');
    const panel = page.locator('aside');
    await panel.getByRole('tab', { name: say('bank.tab') }).click();
    const table = panel.getByRole('grid', { name: say('bank.tableLabel') });

    const scroll = await table.evaluate(async (node) => {
      const startedAt = node.scrollTop;
      /** @type {number[]} */
      const frames = [];
      let last = performance.now();
      let running = true;
      const tick = (/** @type {number} */ now) => {
        frames.push(now - last);
        last = now;
        if (running) requestAnimationFrame(tick);
      };
      requestAnimationFrame(tick);
      for (let step = 0; step < 40; step += 1) {
        node.scrollTop += 400;
        await new Promise((done) => requestAnimationFrame(done));
      }
      running = false;
      frames.sort((a, b) => a - b);
      return {
        median: Math.round(frames[Math.floor(frames.length / 2)] ?? 0),
        worst: Math.round(frames.at(-1) ?? 0),
        rows: node.querySelectorAll('[role="row"]').length,
        nodes: node.querySelectorAll('*').length,
        // The distance travelled: without it "cheap frames" and "the scroll did not move" are
        // indistinguishable, and any breakage would make the measurement GREENER.
        travelled: node.scrollTop - startedAt,
      };
    });
    await shot('perf-scrolled');
    console.log(
      `  scrolling 1200 terms: frame median ${scroll.median}ms, worst ${scroll.worst}ms; ` +
        `${scroll.rows} rows / ${scroll.nodes} nodes in the DOM`,
    );
    check(scroll.travelled > 5000, `the table really scrolled by ${scroll.travelled}px`);
    check(
      scroll.rows > 10,
      `and the rows are drawn meanwhile (${scroll.rows}) — we measured no emptiness`,
    );
    check(
      scroll.median <= 34,
      `the median frame while scrolling is ${scroll.median}ms (threshold 34)`,
    );
    check(
      scroll.rows <= 80,
      `${scroll.rows} rows out of 1200 are held in the DOM — the virtualizer is alive`,
    );

    // Two DIFFERENT quantities, and they must not be confused: the response of the field is what a
    // person feels with their fingers, while the settling of the table lags on purpose
    // (useDeferredValue), so that typing does not wait for the collection.
    const search = page.getByRole('searchbox', { name: say('bank.search') });
    await search.click();
    const rowsSelector = '[role="grid"] [role="row"]';
    // The query MUST narrow the result SHARPLY: a single syllable is in almost every term of this
    // fixture, the number of rows in the DOM would not change — the measurement would be timing the
    // wait and not the repaint. A whole translated term is specific enough. Taken out of the fixture
    // BEFORE the stopwatch starts: nothing of ours belongs inside the window being measured.
    const query = dstOf(scaleTerms, 't_5');

    // FIVE rounds and the MEDIAN, not one round divided by its length. The quantity is the same —
    // milliseconds per keystroke — but a single round is an instrument the machine's own load moves:
    // measured 43·49 ms on a quiet machine and 64·79 ms with a dozen agents running, on a build that
    // an A/B against the pre-session one showed to be FASTER (39·41·43·44·47 against 42·43·44·46·48).
    // The threshold below has not moved; what moved is the noise of the reading.
    /** @type {number[]} */
    const echoes = [];
    let settled = 0;
    for (let round = 0; round < 5; round += 1) {
      await search.fill('');
      // ⚠ The round starts from a table that has SETTLED, and the number it settled at is measured
      // here rather than inherited: the count of rows in the DOM belongs to the virtualizer and
      // depends on where the list stands, so the one taken before the scrolling above is not the
      // one this round narrows from. With a fixed pause instead, the rows could still be missing
      // when the stopwatch started — "fewer rows than before" would be true on arrival and the
      // settling would be measured as nothing (acceptance of S3.7, finding 7).
      const full = await rowsSettled(page, rowsSelector);
      await search.click();
      const typed = Date.now();
      await page.keyboard.type(query);
      await page.waitForFunction(
        (want) =>
          /** @type {HTMLInputElement | null} */ (document.querySelector('input[type="search"]'))
            ?.value === want,
        query,
        { timeout: 5000 },
      );
      echoes.push(Math.round((Date.now() - typed) / query.length));
      await page.waitForFunction(
        ({ was, selector }) => document.querySelectorAll(selector).length < was,
        { was: full, selector: rowsSelector },
        { timeout: 5000 },
      );
      settled = Date.now() - typed;
    }
    echoes.sort((a, b) => a - b);
    const echo = echoes[Math.floor(echoes.length / 2)] ?? 0;
    console.log(
      `  search over 1200 terms: the field answers in ${echo}ms (of ${echoes.join('·')}), ` +
        `the table settles in ${settled}ms`,
    );
    // The threshold comes from a measurement, not out of the head: before the fix it was ~150 ms per
    // character (the whole shell repainted), after it 40–45. 60 separates one from the other.
    check(echo <= 60, `the input field answers in ${echo}ms per character (threshold 60)`);
    check(settled <= 700, `the table settles in ${settled}ms (threshold 700)`);

    // Dragging the panel with the bank open — what the owner complained about in the words
    // "fucking lags".
    await search.fill('');
    const drag = await dragFrames(page);
    console.log(
      `  dragging the panel with the bank: median ${drag.median}ms, p90 ${drag.p90}ms, worst ${drag.worst}ms, ` +
        `frames longer than 50ms — ${drag.janky} of ${drag.frames}`,
    );
    check(
      drag.moved > 100,
      `the panel really travelled during the drag (by ${drag.moved}px at the peak)`,
    );
    check(drag.p90 <= 34, `the p90 frame during the drag is ${drag.p90}ms (threshold 34)`);
    check(drag.janky <= 3, `long frames over the drag ${drag.janky} (threshold 3)`);
  },

  // S4: the path the product begins with — a file becomes a book, the book is parsed, the book is
  // translated. Everything here runs against the mock network by the form of the contract; the
  // fixture's own rules (the file last, the caps) are the platform's, so a client that broke one
  // would fail here rather than in production.
  /** @param {Page} page @param {Shot} shot */
  async intake(page, shot) {
    await open(page, '/intake');
    // The precondition is ASSERTED and not assumed: this world starts empty, and every count below
    // is a count of what the form put there.
    check(
      (await page.locator('nav [role="row"]').count()) === 0,
      'the intake world starts with an empty library',
    );

    await page.getByRole('button', { name: say('library.addBook') }).click();
    const modal = page.getByRole('dialog');
    await shot('intake-form');
    await audit(page, 'the add-a-book form');

    // The pair of languages is a real choice with a real keyboard: the whole path has to be
    // passable without a mouse.
    const source = modal.getByLabel(say('addBook.sourceLangLabel'));
    const before = (await source.innerText()).trim();
    await source.focus();
    await page.keyboard.press('Enter');
    await page.keyboard.press('ArrowDown');
    await page.keyboard.press('Enter');
    const after = (await source.innerText()).trim();
    // ⚠ A CHANGE, not "there is a value": the control shows one before a key is ever pressed, so
    // the first version of this check was true of a keyboard that did nothing (found by the
    // adversarial review).
    check(
      after !== before && after !== '',
      `the language of the original is chosen from the keyboard (${before} → ${after})`,
    );

    await modal.locator('input[type="file"]').setInputFiles({
      name: 'gu-zhen-ren.txt',
      mimeType: 'text/plain',
      buffer: Buffer.alloc(300_000, 'a'),
    });
    await modal.getByRole('textbox', { name: say('addBook.titleLabel') }).fill(book.title);
    check(
      await modal.getByText(say('addBook.titleHintManual'), { exact: false }).isVisible(),
      'a title entered by hand differs from the automatic parse',
    );

    await modal.getByRole('button', { name: say('addBook.submit') }).click();
    // The sending is a STATE and not a flash. ⚠ WHAT IS CHECKED HERE is what the browser world can
    // show: under the mock network the request is answered by a service worker, and Chromium reports
    // no upload progress for such a request at all (probe: `loadstart` with the right total, then
    // nothing). So the screen honestly says the size going out and draws NO share — the determinate
    // bar and the "all sent" line belong to the real platform and are proved by src/api/upload.test.ts.
    // The line is found by the part of the catalogue string that stands BEFORE the place: the size
    // itself is formatted by `Intl` for the interface's locale, and a scene that spelled it out
    // would be a second copy of that formatting.
    const sending = modal.getByText(say('addBook.sendingUnknown').split('{')[0]?.trim() ?? '', {
      exact: false,
    });
    await sending.waitFor({ state: 'visible', timeout: 5000 });
    await shot('intake-sending');
    const said = await sending.innerText();
    check(/\d/.test(said), `the form says how much is going out («${said.trim()}»)`);
    check(
      (await modal.getByRole('progressbar').count()) === 0,
      'and draws no share while the browser reports none — a bar at zero would be a number that means nothing',
    );

    // 201 carries `parsing` — the confirmation shows what came back, from the contract's own
    // fields and not from what the form typed in.
    await modal.getByText(say('addBook.acceptedTitle')).waitFor({ timeout: 10_000 });
    await shot('intake-accepted');
    const confirmation = await modal.innerText();
    check(
      confirmation.includes(book.title) && confirmation.includes(say('status.parsing')),
      'the confirmation names the book and says it is being parsed',
    );
    await audit(page, 'the confirmation of the upload');

    await modal.getByRole('button', { name: say('action.done') }).click();
    // Parsing is a visible step of its own, with no number on it: the contract has no counter for
    // it, so the screen says the state and invents no percentage.
    const badge = page.locator('nav [role="row"]').first();
    check(
      (await badge.innerText()).includes(say('status.parsing')),
      'the book stands in the library while it is being parsed',
    );
    check(
      !/\d+\s*%/.test(await badge.innerText()),
      'and no percentage of the parsing is invented anywhere on that row',
    );
    await shot('intake-parsing');

    // Nothing PUSHES the end of the parse — a book being parsed has no run and therefore no
    // stream — so this waits for the poll to bring it.
    await page.waitForFunction(
      (want) => document.querySelector('nav [role="row"]')?.textContent?.includes(want) === true,
      say('status.notStarted'),
      { timeout: 20_000 },
    );
    // Waited for and not counted on the spot: the tree is read AGAIN when the poll finds the parse
    // over, and the answer to that read is a round trip behind the status.
    const grown = await page
      .waitForFunction(() => document.querySelectorAll('nav [role="row"]').length > 1, null, {
        timeout: 15_000,
      })
      .then(
        () => true,
        () => false,
      );
    const chapters = await page.locator('nav [role="row"]').count();
    check(grown, `the sections of the parsed book are in the tree (${String(chapters)} rows)`);
    await shot('intake-parsed');

    // The run: the scale is in CHAPTERS, and there is no money on the screen in any form (§4.8).
    const panel = page.locator('aside');
    await panel.getByRole('tab', { name: say('about.tab') }).click();
    await panel.getByRole('button', { name: say('run.action') }).click();
    const scale = modal.getByRole('slider');
    await scale.waitFor({ timeout: 5000 });
    await shot('intake-run-form');
    await audit(page, 'the run form');
    // The scale is a native range under the hood (that is what gives it the keyboard and the
    // screen reader for free), so its bounds live on the input and not in aria-* attributes.
    const boundsOf = () =>
      scale.evaluate((node) =>
        node instanceof HTMLInputElement
          ? { now: node.value, min: node.min, max: node.max }
          : {
              now: node.getAttribute('aria-valuenow'),
              min: node.getAttribute('aria-valuemin'),
              max: node.getAttribute('aria-valuemax'),
            },
      );
    const bounds = await boundsOf();
    check(
      bounds.now === '4' && bounds.min === '1' && bounds.max === '8',
      `the scale is built from the platform's bounds, preset included (${JSON.stringify(bounds)})`,
    );
    check(
      !/[$₽€]|\d+[.,]\d{2}\b/.test(await modal.innerText()),
      'not a sum, not a currency and not a price anywhere on the run form',
    );
    // The scale is a real control for the keyboard, not a decoration for the mouse.
    await scale.focus();
    await page.keyboard.press('ArrowRight');
    check((await boundsOf()).now === '5', 'the ceiling moves from the keyboard');

    // ⚠ THE FIRST PRESS MEETS A 409, and the fixture produces it the way the platform does rather
    // than by a marker: the bounds moved between the read and the call (the contract's own case — a
    // hold taken for another book lowers what is left). This is the one refusal a correct client
    // can meet on a correct form, and §11 of the assignment asks for every branch to be SHOWN.
    await modal.getByRole('button', { name: say('run.action') }).click();
    const refused = modal.getByText(say('run.conflictAdvice'), { exact: false });
    await refused.waitFor({ timeout: 10_000 });
    await shot('intake-run-conflict');
    check(
      await refused.isVisible(),
      'a ceiling that no longer fits is refused, and the form says so',
    );
    // The same shape as the intake refusals: the client's OWN phrase for this class must be absent,
    // which is what says the sentence on the screen came from the platform.
    check(
      !(await modal.innerText()).includes(say('run.conflict')),
      "and the phrase is the platform's own, not the client's fallback",
    );
    // The scale was re-read, so the value now standing on it is the platform's NEW preset — not the
    // one the person picked against bounds that no longer exist.
    await page.waitForFunction(
      () =>
        (document.querySelector('[role="dialog"] input[type="range"]')?.getAttribute('max') ??
          '') === '2',
      null,
      { timeout: 10_000 },
    );
    check((await boundsOf()).now === '2', 'and the scale comes back with the bounds that are left');

    await modal.getByRole('button', { name: say('run.action') }).click();
    // The run goes, and it ends where the contract says a ceiling stop ends: `paused`, with a
    // machine reason, never `failed`. The phrase is the owner's (В-6) and the client only picks it.
    await page.waitForFunction(
      (want) => document.querySelector('footer')?.textContent?.includes(want) === true,
      say('paused.creditExhausted'),
      { timeout: 20_000 },
    );
    await shot('intake-paused');
    // The halt is a LIVED state and not a toast: the strip carries it, the card carries it, and both
    // are still there a minute later — which a message that fades would not be.
    check(
      (await page.locator('footer').innerText()).includes(say('paused.creditExhausted')),
      'the halt on the ceiling is named in the status strip, in the owner’s own words',
    );
    check(
      (await panel.innerText()).includes(say('paused.creditExhausted')),
      'and on the card of the book, where the action for it would be',
    );
    // ⚠ What the card offers is a NEW run — which carries a new ceiling — and never "continue":
    // after a ceiling stop `resume` does not move the run at all (contract §resumeRun).
    check(
      (await panel.innerText()).includes(say('run.action')),
      'the way on from a halt is a new run with a ceiling of its own, and it is offered',
    );
  },

  // The other half of the same path: everything that can go wrong with an intake, each as a state
  // of the form rather than an alert over it (§3.8). The class is asked for by a marker in the name
  // of the file — the fixture's own switch (src/mock/intake.ts), because a correct client cannot
  // produce these answers and the screens for them would otherwise be checked by nothing.
  /** @param {Page} page @param {Shot} shot */
  async refusals(page, shot) {
    await open(page, '/intake');
    const modal = page.getByRole('dialog');

    /** @param {string} name @param {number} size */
    const send = async (name, size) => {
      await page.getByRole('button', { name: say('library.addBook') }).click();
      await modal.locator('input[type="file"]').setInputFiles({
        name,
        mimeType: 'text/plain',
        buffer: Buffer.alloc(size, 'a'),
      });
      await modal.getByRole('button', { name: say('addBook.submit') }).click();
      // Any of the advices the form can end on: which one it is, is what the checks below ask.
      await modal
        .getByText(say('upload.retryAdvice'), { exact: false })
        .or(modal.getByText(say('upload.badRequestAdvice'), { exact: false }))
        .or(modal.getByText(say('upload.tooLargeAdvice'), { exact: false }))
        .or(modal.getByText(say('upload.notAcceptedAdvice'), { exact: false }))
        .waitFor({ timeout: 10_000 });
      return modal.innerText();
    };

    // The body over the cap — the one refusal the fixture takes from the FILE itself and not from
    // a marker, because that rule is real on both sides of the wire.
    const tooLarge = await send('gu-zhen-ren.txt', 2_400_000);
    await shot('refusal-413');
    check(
      tooLarge.includes(say('upload.tooLargeAdvice')),
      'a file over the cap is refused with the advice to take a smaller one',
    );
    await audit(page, 'the refusal of an oversized file');
    await closeModal(page);

    for (const { marker, advice, ours, what } of [
      {
        marker: 'refuse-400',
        advice: say('upload.badRequestAdvice'),
        ours: say('upload.badRequest'),
        what: 'a form that did not arrive whole',
      },
      {
        marker: 'refuse-404',
        advice: say('upload.notAcceptedAdvice'),
        ours: say('upload.notAccepted'),
        what: 'a deployment that accepts no books',
      },
      {
        marker: 'refuse-408',
        advice: say('upload.retryAdvice'),
        ours: say('upload.timeout'),
        what: 'a body that missed the deadline',
      },
    ]) {
      const shown = await send(`${marker}.txt`, 1000);
      await shot(`refusal-${marker}`);
      check(shown.includes(advice), `${what}: the form says what to do next`);
      // ⚠ The CLIENT'S OWN phrase for this very class must be absent: it is the fallback used when
      // the platform sends no problem body, so it is reachable — and its absence therefore says the
      // phrase on the screen came from the server. The first version of this check looked for a
      // phrase no path can print at all and so could never fail (found by the adversarial review).
      check(
        !shown.includes(ours),
        `${what}: the phrase shown is the platform's, not the client's own («${ours}»)`,
      );
      await closeModal(page);
    }

    // And the other end of the intake: a book that was accepted and could not be turned into
    // chapters. Three reasons, three different next actions.
    for (const { marker, reason, advice } of [
      {
        marker: 'reject-source',
        reason: say('rejected.sourceUnreadable'),
        advice: say('rejected.sourceUnreadableAdvice'),
      },
      {
        marker: 'reject-config',
        reason: say('rejected.notConfigured'),
        advice: say('rejected.notConfiguredAdvice'),
      },
      {
        marker: 'reject-parser',
        reason: say('rejected.parserUnavailable'),
        advice: say('rejected.parserUnavailableAdvice'),
      },
    ]) {
      await page.getByRole('button', { name: say('library.addBook') }).click();
      await modal.locator('input[type="file"]').setInputFiles({
        name: `${marker}.txt`,
        mimeType: 'text/plain',
        buffer: Buffer.alloc(1000, 'a'),
      });
      await modal.getByRole('button', { name: say('addBook.submit') }).click();
      await modal.getByText(say('addBook.acceptedTitle')).waitFor({ timeout: 10_000 });
      await modal.getByRole('button', { name: say('action.done') }).click();
      // The book just uploaded is CHOSEN in the tree — the library holds the ones before it, and a
      // card that went on showing the first book would make every reason below read the same.
      // (The title is the name of the file: the form left it to the parse.)
      await page.locator('nav').getByText(marker, { exact: true }).click();
      const panel = page.locator('aside');
      await panel.getByRole('tab', { name: say('about.tab') }).click();
      await page.waitForFunction(
        (want) => document.querySelector('aside')?.textContent?.includes(want) === true,
        reason,
        { timeout: 20_000 },
      );
      await shot(`refusal-${marker}`);
      // The row of a book can be SELECTED since S4, so the pairs on the blue ground are checked
      // here as well: axe does not see the contrast of a badge it considers decorative, and the
      // rule that recolours it had been removed in S3.7 as dead code.
      const faint = await contrastInSelectedRow(page);
      check(
        faint.length === 0,
        `${marker}: everything on the selected row of the book is readable ${faint
          .map((part) => `${part.what} ${part.ratio}:1 < ${part.floor}`)
          .join(' · ')}`,
      );
      check(
        (await panel.innerText()).includes(advice),
        `${marker}: the card names the reason and what to do about it`,
      );
    }
    await audit(page, 'a rejected book on the card');
  },

  // Remarks 11, 12, 4: three modal windows instead of stub tabs and a second search button.
  /** @param {Page} page @param {Shot} shot */
  async overlays(page, shot) {
    await open(page, '/showcase');
    // ⚠ Everything is looked for INSIDE the window. Because of keep-alive the unselected panels stay
    // in the DOM (that is the whole point of Ф-19), so a global locator by role finds the hidden row
    // of the neighbouring tab and waits for it to be visible until the timeout.
    const modal = page.getByRole('dialog');

    await page.getByRole('button', { name: say('shell.settingsAction') }).click();
    await shot('modal-settings');
    check(await modal.isVisible(), 'the settings opened as a modal window');
    await audit(page, 'the settings modal window');
    await page.keyboard.press('Escape');

    await page.getByRole('button', { name: say('library.addBook') }).click();
    await modal.locator('input[type="file"]').setInputFiles({
      name: 'gu-zhen-ren.txt',
      mimeType: 'text/plain',
      buffer: Buffer.from('sample'),
    });
    await shot('modal-add-book');
    check(
      await modal.getByText(say('addBook.titleHintAuto'), { exact: false }).isVisible(),
      'an empty title field honestly says that the title will be given by parsing the file',
    );
    // By NAME and not by position: the form has gained the pair of languages and the genre since
    // this scene was written, and `.last()` had quietly become the genre field.
    await modal.getByRole('textbox', { name: say('addBook.titleLabel') }).fill(book.title);
    check(
      await modal.getByText(say('addBook.titleHintManual'), { exact: false }).isVisible(),
      'a title entered by hand differs from the automatic parse',
    );
    await page.keyboard.press('Escape');

    await page.getByRole('button', { name: say('shell.gotoAction') }).click();
    await page.keyboard.type(heading('ch_7'));
    await shot('modal-goto');
    const results = modal.locator('[role="option"]');
    check(
      (await results.count()) === 1 &&
        (await results.first().innerText()).includes(heading('ch_7')),
      'the jump palette finds exactly the chapter that was named',
    );
    await results.first().click();
    // ⚠ Counting preview tabs here is pointless: one of them is open in the showcase always, and the
    // check would pass even if picking in the palette did NOTHING. We ask for the NAME.
    check(
      (await page.locator('[role="tab"][data-preview="true"]').innerText()).includes(
        heading('ch_7'),
      ),
      'the chapter picked in the palette is the one that opened — as a preview tab',
    );

    // Escape closes the palette on the FIRST press: the search primitive clears its line on the
    // first press.
    await page.getByRole('button', { name: say('shell.gotoAction') }).click();
    await page.keyboard.type(heading('ch_7'));
    await page.keyboard.press('Escape');
    check(!(await modal.isVisible()), 'Escape closes the palette on the first press');

    // ⚠ The price of that fix: intercepting Escape stops the field from clearing itself, and the
    // palette opened with the OLD query — the next letter was appended to it (found by an
    // adversarial review).
    await page.getByRole('button', { name: say('shell.gotoAction') }).click();
    check(
      (await modal.getByRole('searchbox').inputValue()) === '',
      'a palette opened anew starts from a clean line',
    );
    await page.keyboard.press('Escape');

    // A request from the palette outweighs the filter by kind: it otherwise leads into the bank and
    // shows emptiness there.
    const panel = page.locator('aside');
    await panel.getByRole('tab', { name: say('bank.tab') }).click();
    await panel.getByRole('radio', { name: new RegExp(`^${say('kind.place')}`) }).click();
    await page.getByRole('button', { name: say('shell.gotoAction') }).click();
    await page.keyboard.type(dstOf(terms, 't_1'));
    await modal.locator('[role="option"]').first().click();
    await page.waitForTimeout(700);
    const table = panel.getByRole('grid', { name: say('bank.tableLabel') });
    check(
      (await table
        .getByRole('row')
        .filter({ hasText: dstOf(terms, 't_1') })
        .count()) === 1,
      'the term picked in the palette is visible in the bank, though a filter of another kind was on',
    );

    // The same term, asked for a SECOND time, is a request as well.
    await panel.getByRole('searchbox', { name: say('bank.search') }).fill('zzz');
    await page.getByRole('button', { name: say('shell.gotoAction') }).click();
    await page.keyboard.type(dstOf(terms, 't_1'));
    await modal.locator('[role="option"]').first().click();
    await page.waitForTimeout(700);
    check(
      (await table
        .getByRole('row')
        .filter({ hasText: dstOf(terms, 't_1') })
        .count()) === 1,
      'a repeated request for the same term works the same way',
    );
  },
};

/**
 * How the columns of a table lie in their panel: the sum of their widths, the width of the content
 * and of the window, and what is clipped. One measurement for three scenarios — the bank, the hidden
 * tab, the zoom.
 * @param {Locator} table
 */
function columnSpread(table) {
  return table.evaluate((node) => {
    const heads = [...node.querySelectorAll('[role="columnheader"]')].sort(
      (a, b) => a.getBoundingClientRect().left - b.getBoundingClientRect().left,
    );
    const sum = heads.reduce((total, th) => total + th.getBoundingClientRect().width, 0);
    // The prose column — the last one — stretches and clips legitimately: no width fits a
    // description. The REST are sized off their own content, so clipping there is a defect.
    const prose = Math.round(heads.at(-1)?.getBoundingClientRect().left ?? 0);
    /** @type {string[]} */
    const cut = [];
    for (const cell of node.querySelectorAll('[role="gridcell"],[role="rowheader"]')) {
      const inner = cell.firstElementChild;
      if (!inner || Math.round(cell.getBoundingClientRect().left) === prose) continue;
      if (inner.scrollWidth > inner.clientWidth) cut.push(inner.textContent ?? '');
    }
    return {
      sum: Math.round(sum),
      grid: Math.round(node.getBoundingClientRect().width),
      content: node.scrollWidth,
      widths: heads.map((th) => Math.round(th.getBoundingClientRect().width)),
      cut,
    };
  });
}

/**
 * Pairs of «content ↔ ground of the selected row» that did not reach the WCAG floor. Computed INSIDE
 * the page over the computed colours and not over the tokens: what has to be guarded is what is seen
 * on the screen.
 *
 * The floor is taken by role: text 4.5:1, an icon and a surface (the track of the indicator) 3:1.
 * ⚠ One pair is deliberately not in here — «fill ↔ track» inside the indicator itself: above 2.07:1
 * it cannot be raised on a blue ground with the owner's palette, and that is named in
 * Library.module.css.
 * @param {Page} page
 */
function contrastInSelectedRow(page) {
  return page.evaluate(() => {
    const luminance = (/** @type {string} */ color) => {
      const [r = 0, g = 0, b = 0] = (color.match(/[\d.]+/g) ?? []).map(Number);
      const lin = (/** @type {number} */ c) =>
        c / 255 <= 0.04045 ? c / 255 / 12.92 : ((c / 255 + 0.055) / 1.055) ** 2.4;
      return 0.2126 * lin(r) + 0.7152 * lin(g) + 0.0722 * lin(b);
    };
    // ⚠ NOT rounded before the comparison: two places would accept 2.995 as three, which is the
    // hole the token gate closed on its own copy of this arithmetic (adversarial review). The
    // rounding that remains is for the MESSAGE and happens after the verdict.
    const ratio = (/** @type {string} */ a, /** @type {string} */ b) => {
      const [high = 0, low = 0] = [luminance(a), luminance(b)].sort((x, y) => y - x);
      return (high + 0.05) / (low + 0.05);
    };

    const row = document.querySelector('nav [role="row"][data-selected]');
    if (!row) throw new Error('there is no selected row in the tree — nothing to guard');
    const ground = getComputedStyle(row).backgroundColor;
    const parts = [];
    for (const node of row.querySelectorAll('*')) {
      const style = getComputedStyle(node);
      const label = (node.textContent ?? '').trim().slice(0, 24);
      // The label for the reader is cut out of the frame (clip-path) — no contrast is asked of it.
      const printed = [...node.childNodes].some(
        (child) => child.nodeType === 3 && (child.textContent ?? '').trim() !== '',
      );
      if (printed && style.clipPath === 'none') {
        parts.push({ what: `text «${label}»`, floor: 4.5, ratio: ratio(style.color, ground) });
      }
      if (node.tagName === 'svg') {
        parts.push({ what: 'icon', floor: 3, ratio: ratio(style.color, ground) });
      }
      // By the ALPHA, and not by a comparison with the string of a transparent colour: the browser
      // prints it in different ways, and a literal colour in the code is forbidden by the gate — and
      // rightly so, the comparison has to be against the property.
      const opaque = Number((style.backgroundColor.match(/[\d.]+/g) ?? [])[3] ?? 1) > 0;
      if (opaque && style.clipPath === 'none') {
        parts.push({
          what: `surface «${label}»`,
          floor: 3,
          ratio: ratio(style.backgroundColor, ground),
        });
      }
    }
    return parts
      .filter((part) => part.ratio < part.floor)
      .map((part) => ({ ...part, ratio: Math.round(part.ratio * 100) / 100 }));
  });
}

/**
 * The number of rows the table has come to rest at. The repaint of the collection is deferred on
 * purpose (`useDeferredValue`), so "how many rows are there" has no answer until it stops changing —
 * and a fixed pause in its place is a number that is either too short to be true or too long to be
 * a measurement.
 * @param {Page} page @param {string} selector
 */
async function rowsSettled(page, selector) {
  // THREE readings in a row, not two: the deferred repaint has plateaus of its own, and two equal
  // samples 50 ms apart can both land on one (found by the adversarial review).
  let previous = -1;
  let steady = 0;
  for (let attempt = 0; attempt < 60; attempt += 1) {
    const now = await page.locator(selector).count();
    steady = now === previous ? steady + 1 : 0;
    if (steady >= 2 && now > 0) return now;
    previous = now;
    await page.waitForTimeout(50);
  }
  throw new Error('the table never settled on a number of rows');
}

/**
 * Drags the right separator through a list of offsets from where it started, then lets go.
 * @param {Page} page @param {number[]} offsets
 */
async function pull(page, offsets) {
  const separator = page.locator('[role="separator"]').nth(1);
  const box = await separator.boundingBox();
  if (!box) throw new Error('the right separator was not found');
  const y = box.y + box.height / 2;
  await page.mouse.move(box.x + box.width / 2, y);
  await page.mouse.down();
  for (const x of offsets) await page.mouse.move(box.x + x, y, { steps: 10 });
  await page.mouse.up();
  await page.waitForTimeout(300);
}

/**
 * A drag of the right separator there and back with the frames measured. What is measured is EXACTLY
 * what a person complains about: not an abstract render, but dragging the window with the table
 * open.
 * @param {Page} page
 */
async function dragFrames(page) {
  const panel = page.locator('aside');
  const widthBefore = (await panel.boundingBox())?.width ?? 0;
  await page.evaluate(() => {
    /** @type {{frames: number[], last: number, running: boolean}} */
    const state = { frames: [], last: performance.now(), running: true };
    Object.assign(window, { __frames: state });
    const tick = (/** @type {number} */ now) => {
      state.frames.push(now - state.last);
      state.last = now;
      if (state.running) requestAnimationFrame(tick);
    };
    requestAnimationFrame(tick);
  });

  const separator = page.locator('[role="separator"]').nth(1);
  const box = await separator.boundingBox();
  if (!box) throw new Error('the right separator was not found');
  const y = box.y + box.height / 2;
  await page.mouse.move(box.x + box.width / 2, y);
  await page.mouse.down();
  let widthPeak = widthBefore;
  for (const x of [-60, -140, -220, -300, -220, -140, -60, 0]) {
    await page.mouse.move(box.x + x, y, { steps: 8 });
    // The width is taken DURING the drag: by the end the mouse comes back where it was, and a
    // "before/after" comparison would show zero — that is, the measurement would pass on a panel
    // stuck dead as well.
    const width = (await panel.boundingBox())?.width ?? 0;
    if (width > widthPeak) widthPeak = width;
  }
  await page.mouse.up();
  const stats = await page.evaluate(() => {
    const state = /** @type {{frames: number[], running: boolean}} */ (
      Reflect.get(window, '__frames')
    );
    state.running = false;
    const frames = [...state.frames].sort((a, b) => a - b);
    return {
      median: Math.round(frames[Math.floor(frames.length / 2)] ?? 0),
      p90: Math.round(frames[Math.floor(frames.length * 0.9)] ?? 0),
      worst: Math.round(frames.at(-1) ?? 0),
      // A person feels the LONG frames, not the median: it held at 17 ms even where the drag was
      // torn to shreds. We count them by the piece.
      janky: frames.filter((frame) => frame > 50).length,
      frames: frames.length,
    };
  });
  return { ...stats, moved: Math.round(widthPeak - widthBefore) };
}

/**
 * Whether the description is covered. The spoiler is `filter: blur()`: a filter is applied AFTER
 * the element is drawn and only an ancestor can cut it, whereas `text-shadow` is the element's own
 * ink and its own `overflow` cuts it at the glyphs (owner, 10.08: "square on the left").
 * @param {Locator} sense
 */
const isCovered = (sense) => sense.evaluate((node) => getComputedStyle(node).filter !== 'none');

/** @param {Locator} separator */
const handleStyle = (separator) =>
  separator
    .locator('span')
    .first()
    .evaluate((node) => {
      const style = getComputedStyle(node);
      return { opacity: style.opacity, background: style.backgroundColor, height: style.height };
    });

/**
 * Closes the modal that is open and WAITS for it to be gone.
 *
 * Escape alone is a race: the window plays a transition, and the next click lands on the overlay
 * that is still there — which is how this scene began failing once in every few runs, with the
 * pointer intercepted by `_overlay_`. Waiting for the dialog to detach is the only honest signal.
 * @param {Page} page
 */
async function closeModal(page) {
  const modal = page.getByRole('dialog');
  if ((await modal.count()) === 0) return;
  await page.keyboard.press('Escape');
  await modal.waitFor({ state: 'detached', timeout: 5000 });
}

/** @param {Page} page @param {string} route */
async function open(page, route) {
  await page.goto(`${origin}${route}`, { waitUntil: 'load' });
  await page.waitForFunction(() => document.documentElement.dataset.screen === 'ready', null, {
    timeout: 15_000,
  });
  await page.evaluate(() => document.fonts.ready);
  await settle(page);
}

/**
 * Waits for the animations to play out: the frame and the measurement are bound to land on a settled
 * state and not in the middle of a transition. Infinite animations we have none — should any appear,
 * the wait will honestly run into its timeout instead of taking a blinking frame for a settled one.
 * @param {Page} page
 */
const settle = (page) =>
  page.waitForFunction(
    () => document.getAnimations().every((animation) => animation.playState !== 'running'),
    null,
    { timeout: 5000 },
  );

const requested = process.argv.slice(2);
const names = requested.length > 0 ? requested : Object.keys(scenes);
const unknown = names.filter((name) => !(name in scenes));
if (unknown.length > 0) {
  throw new Error(
    `No such scenario: ${unknown.join(', ')}. Known ones: ${Object.keys(scenes).join(', ')}`,
  );
}

await mkdir(shotsDir, { recursive: true });
await build({ logLevel: 'warn' });
const server = await preview({ preview: { open: false } });
const origin = server.resolvedUrls?.local[0]?.replace(/\/$/, '');
if (!origin) throw new Error('vite preview did not give back a local address');

const browser = await chromium.launch();
const context = await browser.newContext({
  viewport: { width: 1440, height: 900 },
  deviceScaleFactor: 2,
});
const page = await context.newPage();

for (const name of names) {
  console.log(`\n${name}`);
  /** @param {string} file */
  const shot = (file) => page.screenshot({ path: resolve(shotsDir, `${file}.png`) });
  await scenes[name]?.(page, shot);
}

await browser.close();
await server.close();
console.log('\nevery scenario passed');