hbengine 0.2.3

package/engine-conformance/run.mjs

@@ -0,0 +1,1217 @@
+#!/usr/bin/env node
+/**
+ * The conformance run: a studio bundle played headless inside our real shell
+ * against the sandbox engine, at the site's frame sizes, before any person
+ * looks at it. Same code in `hbengine test` and in the upload pipeline.
+ *
+ *   node run.mjs <bundle-dir> [--slug bad-cat] [--game-id N] [--rgs http://127.0.0.1:8090] [--json] [--dev]
+ *
+ * --json prints the checks as JSON (the portal reads it); --dev runs no
+ * checks: it serves the bundle inside the real shell and prints a URL to open
+ * and play against the sandbox, until stopped.
+ *
+ * The harness plays the site's part (the frame: column width × 720, as the
+ * site's frame for a House game, and the housegames bridge), serves the shell from its own origin
+ * and the bundle from another with the sandbox header, and launches a
+ * play-money player through the engine's real merchant flow.
+ *
+ * Checks, per frame size (desktop 1194×720, phone 364×720):
+ *   boot       the game asks for its config (hello) and says ready in time
+ *   idle       left untouched for 15 s, the game places no bet
+ *   errors     no uncaught error in any of the game's pages
+ *   network    no request leaves the bundle's own origin, the policy
+ *              refuses nothing (a refused worker, script or style is a code
+ *              path that does not work in production), and nothing is posted
+ *              to the policy's report path (only the browser reports there)
+ *   fit        the game fits the frame it is given, as a House Original does:
+ *              no page scrolls inside it and every visible control lies
+ *              within it, at 720 high and again in fullscreen (desktop
+ *              1920×1080, phone 390×844). The site never grows the frame.
+ *   bet        with the studio's hbtest.json: one bet placed through the
+ *              game's own UI reaches engine.play and is followed by
+ *              `revealed` (the site's round-end) within the reveal deadline.
+ *              The press is a real Playwright click: the shell takes a play
+ *              only on the player's activation (its click gate), so a game
+ *              whose Bet does not bet from the click handler fails here
+ *   currency   the bet above, under the player's display (desktop: EUR at a
+ *              rate, phone: the bare coin): the game sends exactly the stake
+ *              the Originals would for what was typed (engine.money /
+ *              <hb-bet-amount>), and the screen shows that currency
+ *   outage     the next bet meets an ambiguous wallet answer (engine-dev's
+ *              /dev/fault): the game does not break, the site is asked to
+ *              re-read the wallet
+ *
+ * The run plays against engine-dev (the offline sandbox, `--rgs`), never a
+ * platform: it needs no credential, and holds none. Chrome runs with its own
+ * sandbox on; ENGINE_RUN_UNSANDBOXED=1 turns it off on a machine that cannot
+ * give one, and the verdict says so. `--skip-outage` is for job-mode runs
+ * whose engine-dev has no wallet fault stub; it reports the outage check as
+ * skipped after the real round checks.
+ *
+ * Time travel (`--time-travel all|canary`, travel.mjs): instead of the two
+ * frame sizes, the matrix of variants, each a fresh context whose clock
+ * (Playwright's, installed before the page loads), time zone (on the context
+ * and on a Chrome process of its own, so Blink's own date formatting agrees)
+ * and language are set; one plays a long session of fast rounds (`--travel-rounds`, 300) with
+ * the outcomes forced through every pay tier of the mode and bet the game
+ * plays (`--manifest`), the game's own bet control pressed each time (and the
+ * SDK panel's Bet every other time when the game has one). A short variant
+ * plays one round, then walks the clock on: half an hour, then a day in
+ * hourly jumps, the page scanned after each. Each variant records the
+ * requests that left the bundle, the policy's refusals, errors, dialog
+ * attempts, workers and child frames started, inputs, text that reads like
+ * a credential prompt (in the DOM, in CSS generated content, drawn on a
+ * canvas), and screenshots (`travel-<id>.png` after boot and
+ * `travel-<id>-late.png` after the walk, in `--shots`), and is judged
+ * against the baseline variant: one check line per variant, rule
+ * `time-travel`. Every variant starts from the storage the one before it
+ * left (the long session right after the baseline, the dated variants in the
+ * order of their clocks, and never a storage written at a clock past the
+ * variant's own: travel.mjs handedStorage), so a counter kept in
+ * localStorage or IndexedDB carries over and a last-seen date never reads
+ * from the future; and from the storage an earlier run left when
+ * `--storage <file>` names one (written back from the last variant on the
+ * real clock: the daily canary carries it from one day to the next). The canary
+ * set compares each variant with the approved version's screenshot of the
+ * same variant too (`--baselines <dir>` holding `travel-<id>.png`), plays
+ * its baseline on the real clock, and a hidden copy of it under the fake
+ * clock right after, walked a day on, whose late frame stands as the
+ * baseline's for the dated variants' late frames. `--travel-total <s>` is
+ * the whole matrix's real time: a variant that no longer fits is skipped and
+ * says so, the ones still to come estimated from the short variants already
+ * played. The job runs this after the frame-size run.
+ *
+ * What the game is shown of the run is a player's browser as far as the run
+ * can make it, and the same browser on the frame sizes as in the matrix:
+ * Chrome without the automation flag (navigator.webdriver is false); the
+ * desktop frame under the desktop display, as the frame-size run plays it;
+ * every clock API behind a Proxy with the native's name and length in every
+ * run (travel.mjs clockShim: Date, the timers and their ids, performance and
+ * its entries, Intl, Event.timeStamp, document.timeline and the animations'
+ * start times, File.lastModified, Temporal, scheduler.postTask's delay,
+ * AbortSignal.timeout, Atomics.waitAsync's timeout), reading the fake clock
+ * when the variant travels and the real one otherwise, a timestamp taken
+ * before a jump keeping its time; the fake clock itself (Playwright's
+ * implementation, clock.mjs) installed from the init script with no global,
+ * started where the native monotonic clock stands, calling a timer's callback
+ * from a native task so its stack is production's, handing an animation
+ * frame the timeline's own reading, moving every running animation on with
+ * each jump, and driven through a message the frame hears before the game
+ * does; the instrumentation behind native-looking functions with nothing
+ * added to window; every file served with a Last-Modified of its own, so
+ * document.lastModified is the header and not the real clock; the sandbox's
+ * `forced` flag and zero draws rewritten and the server's timestamps and Date
+ * headers moved to the travelled clock and moved on with every jump of it;
+ * and every worker given a fake clock of its own with the same shim, moved
+ * with the page's and running its timers due in each jump (a same-origin
+ * script from the server, a blob from its remembered text), so its
+ * timeOrigin stands for its life as a browser's does. What it cannot move
+ * (the audio clock and media playback, which run on real time) is said in
+ * SECURITY-UPLOADS.md §6, with the daily canary's real-clock baseline as the
+ * answer to it. A variant whose run broke is still scanned once more, so a
+ * credential prompt shown before the break is in the report beside it.
+ *
+ * hbtest.json (shipped by the studio, sandbox only):
+ *   { "visit": [{"page", "selector"}, …], "open": [{"page", "selector"}, …],
+ *     "stake": {"page", "selector", "value"}, "bet": {"page", "selector"},
+ *     "then": [{"page", "selector"}, …], "shows": {"page", "selector", "path"} }
+ *   `visit` opens every other screen of the game before the bet (a bundle of
+ *   several games: each card, then back); an error or a scroll there fails
+ *   `errors` or `fit` as anywhere else. `open` reaches the page the bet is
+ *   on (a game behind a menu); time travel plays it before every variant.
+ *   `then` closes a ladder round the bet opened (Next, Cash out — each pressed
+ *   only if it is there: a bust can end the round first); `shows`
+ *   names an element whose text must carry a value of the round (data.0.side).
+ */
+import http from 'node:http';
+import { randomBytes } from 'node:crypto';
+import { readFileSync, existsSync, statSync, writeFileSync } from 'node:fs';
+import { flatShare } from './picture.mjs';
+import { join, extname, normalize } from 'node:path';
+import { moneyFor } from '../engine-sdk/money.js';
+import { walletFrom } from '../engine-shell/host/boot.js';
+import { bundleCSP, shellCSP, reportingEndpoints } from './csp.mjs';
+import { GRID, STORAGE_FILE_MAX, WALK, carriedStorage, checksFor, clockFor, clockShim, clockTrap, controlProblem, credentialHits, fitsBudget, forcedRows, handedStorage, inputSignature, lateShotName, medianGrid, shortVariantEstimate, shotName, startInstant, trapOptions, travelAnswer, variantsFor, visualDifference, workerShim } from './travel.mjs';
+import { clockSource, siteJump, startClock } from './clock.mjs';
+
+const args = process.argv.slice(2);
+const BUNDLE = args[0];
+const opt = (k, d) => { const i = args.indexOf('--' + k); return i >= 0 ? args[i + 1] : d; };
+const SLUG = opt('slug', 'bad-cat');
+const GAME_ID = Number(opt('game-id', '9974899'));
+const RGS = opt('rgs', 'http://127.0.0.1:8090');
+const SKIP_OUTAGE = args.includes('--skip-outage');
+// The time-travel matrix instead of the frame sizes: 'all' (the check job) or
+// 'canary' (the daily replay of a live version: the real date and the near future).
+const TRAVEL = opt('time-travel', '');
+const TRAVEL_ROUNDS = Math.max(1, Number(opt('travel-rounds', '300')) || 300);
+// The long session's share of real time (seconds): a game whose rounds are
+// long (a feature of free spins) plays fewer rounds inside it, and says so.
+const TRAVEL_BUDGET_MS = Math.max(10, Number(opt('travel-budget', '240')) || 240) * 1000;
+// The whole matrix's real time (seconds), when the caller has a deadline: a
+// variant that no longer fits is skipped with the reason, the long session
+// shortened to what is left for it. 0: no limit but the long session's own.
+const TRAVEL_TOTAL_MS = Math.max(0, Number(opt('travel-total', '0')) || 0) * 1000;
+// `--variants base,long`: a part of the matrix, for working on one variant (never the job's).
+const TRAVEL_ONLY = opt('variants', '') ? opt('variants').split(',') : null;
+// `--storage <file>`: the game's storage as an earlier run left it, read before
+// the first variant and written after the last (the daily canary carries it
+// from one day to the next, so a counter kept across visits counts the
+// canary's days as a player's). Missing or not the run's own: empty storage.
+const STORAGE_FILE = opt('storage', '');
+const UNSANDBOXED = process.env.ENGINE_RUN_UNSANDBOXED === '1';
+// Chrome: --chrome, CHROME_PATH, the Mac install; otherwise playwright-core's
+// own Chromium (`npx playwright-core install chromium`).
+const CHROME = opt('chrome', process.env.CHROME_PATH || (process.platform === 'darwin' ? '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome' : undefined));
+const PKG = new URL('..', import.meta.url).pathname; // packages/
+// Three origins on free ports, so any number of runs play at once: the
+// site on localhost, the shell and the studio on 127.0.0.1 (another site).
+const ORIGIN = { site: '', shell: '', studio: '' };
+const listen = (server, host) => new Promise((r) => server.listen(0, '127.0.0.1', () => r(`http://${host}:${server.address().port}`)));
+// The current variant's clock against the real one: the server's timestamps
+// and every Date header move with it, so nothing the game can read from the
+// network says the browser's clock is travelled. 0 outside time travel.
+let clockOffsetMs = 0;
+// Whether the current variant runs under the fake clock: a worker script
+// served meanwhile is given a fake clock of its own (travel.mjs workerShim).
+let travelling = false;
+// The run's token: what the pages' instrumentation reports under, and the
+// channel the fake clocks are driven through (clock.mjs). Minted here, never
+// in anything a page can read.
+const RUN_TOKEN = randomBytes(12).toString('hex');
+
+const MIME = { '.html': 'text/html; charset=utf-8', '.js': 'text/javascript', '.mjs': 'text/javascript', '.css': 'text/css', '.json': 'application/json', '.svg': 'image/svg+xml', '.webp': 'image/webp', '.png': 'image/png', '.jpg': 'image/jpeg', '.mp3': 'audio/mpeg', '.wav': 'audio/wav', '.ogg': 'audio/ogg', '.woff2': 'font/woff2', '.txt': 'text/plain', '.wasm': 'application/wasm', '.ktx2': 'image/ktx2', '.basis': 'application/octet-stream' };
+const send = (res, code, body, headers = {}) => {
+    res.sendDate = false;
+    res.writeHead(code, { 'Cache-Control': 'no-store', Date: new Date(Date.now() + clockOffsetMs).toUTCString(), ...headers });
+    res.end(body);
+};
+// When the run started: no file is said to be newer than that.
+const RUN_START = Date.now();
+// A file is served with its own Last-Modified (its mtime: the archive's, the
+// same in the frame-size run and the matrix, never after the run began), as a
+// static server would. Without one the browser dates the document itself by
+// the real clock (document.lastModified), which would say the page's clock is
+// travelled; with one, document.lastModified is this header.
+function file(res, root, rel, headers, prelude = '') {
+    const p = normalize(join(root, rel));
+    // The extension in lower case, as the CDN reads it (bundles.go): main.JS is JavaScript there and here.
+    if (!p.startsWith(normalize(root)) || !existsSync(p)) return send(res, 404, 'not found');
+    const st = statSync(p);
+    if (!st.isFile()) return send(res, 404, 'not found');
+    const body = readFileSync(p);
+    send(res, 200, prelude && /\.m?js$/.test(p) ? Buffer.concat([Buffer.from(prelude), body]) : body, { 'Content-Type': MIME[extname(p).toLowerCase()] || 'application/octet-stream', 'Last-Modified': new Date(Math.min(st.mtimeMs, RUN_START)).toUTCString(), ...headers });
+}
+
+// ---- the site: one frame, the house-game contract ---------------------------------
+const SITE_PAGE = `<!doctype html><meta charset="utf-8"><style>html,body{margin:0;background:#041015}#c{height:720px;width:100%}iframe{border:0;width:100%;height:100%;display:block}</style>
+<div id="c"><iframe id="g" allow="autoplay; fullscreen"></iframe></div><script>
+window.__log = []; const f = document.getElementById('g');
+addEventListener('message', (e) => { if (e.source !== f.contentWindow) return; const d = e.data || {};
+  window.__log.push({ at: Date.now(), d });
+});
+window.__launch = (u) => { f.src = u; };
+if (location.hash.length > 1) __launch(decodeURIComponent(location.hash.slice(1)));
+</script>`;
+
+// ---- the shell origin: our shell + SDK, /housegames proxied to the RGS ------------------
+// The long time-travel session forces each round's row (travel.mjs forcedRows)
+// the way the studio's sandbox launcher does: the sandbox RGS takes the row for
+// the session's next play. The shell alone holds the session, so the proxy,
+// which sees its Authorization header on the play, asks for the row just
+// before forwarding the play; the game knows nothing of it. The force's
+// answer is checked, and the play's answer read for whether the round was
+// forced, so a refused or ignored force shows in the report (forceLog).
+let forceNext = null;
+let forceLog = null; // { asked, applied, refused } while a long session runs
+let lastPlayBody = null; // the newest play as the game sent it: its mode and bet
+// Engine answers the game may read (through the shell) and that would betray
+// the run: a round's `forced`, a forced draw's raw 0, the server's real time.
+// travelAnswer rewrites them; the game's own state and telemetry are not touched.
+const rewritten = (path) => path.startsWith('/engine/v1/') && !path.startsWith('/engine/v1/state') && !path.startsWith('/engine/v1/telemetry');
+function proxy(req, res) {
+    const url = RGS + req.url.slice('/housegames'.length);
+    const path = req.url.slice('/housegames'.length).split('?')[0];
+    const chunks = [];
+    req.on('data', (c) => chunks.push(c));
+    req.on('end', async () => {
+        try {
+            const headers = {};
+            for (const k of ['content-type', 'authorization', 'x-token']) if (req.headers[k]) headers[k] = req.headers[k];
+            const isPlay = req.method === 'POST' && path === '/engine/v1/play';
+            if (isPlay && chunks.length) { try { lastPlayBody = JSON.parse(Buffer.concat(chunks).toString('utf8')); } catch { /* not the game's play */ } }
+            if (forceNext !== null && isPlay && headers.authorization) {
+                const row = forceNext;
+                forceNext = null;
+                if (forceLog) forceLog.asked++;
+                const f = await fetch(RGS + '/engine/v1/sandbox/force', { method: 'POST', headers: { 'Content-Type': 'application/json', authorization: headers.authorization }, body: JSON.stringify({ indices: [row] }) }).catch(() => null);
+                if (forceLog && !(f && f.ok)) forceLog.refused++;
+            }
+            const r = await fetch(url, { method: req.method, headers, body: chunks.length ? Buffer.concat(chunks) : undefined });
+            const h = { 'Content-Type': r.headers.get('content-type') || 'application/json' };
+            if (r.headers.get('retry-after')) h['Retry-After'] = r.headers.get('retry-after');
+            let body = Buffer.from(await r.arrayBuffer());
+            if (rewritten(path) && /json/.test(h['Content-Type'])) {
+                try {
+                    const parsed = JSON.parse(body.toString('utf8'));
+                    if (isPlay && forceLog && r.ok && parsed?.round?.forced) forceLog.applied++;
+                    body = Buffer.from(JSON.stringify(travelAnswer(parsed, clockOffsetMs)));
+                } catch { /* not JSON after all: passed as it came */ }
+            }
+            send(res, r.status, body, h);
+        } catch (e) { send(res, 502, JSON.stringify({ error: String(e) })); }
+    });
+}
+// The two origins' policies, as production serves them (SPEC §4), from the one
+// source (csp.json). Each origin takes its policy's violation reports as
+// production does: answered 204 and dropped, since the run reads refusals from
+// the console; a game's own request to the path is counted against it.
+const HARDEN = { 'Referrer-Policy': 'no-referrer', 'Cross-Origin-Opener-Policy': 'same-origin', 'Cross-Origin-Resource-Policy': 'same-origin', 'X-Content-Type-Options': 'nosniff', 'X-DNS-Prefetch-Control': 'off', 'Permissions-Policy': 'camera=(), microphone=(), geolocation=(), payment=(), usb=(), display-capture=()' };
+const SHELL_REPORT = '/housegames/engine/play/csp-report', STUDIO_REPORT = '/csp-report';
+const SHELL_HEADERS = () => ({ ...HARDEN, 'Content-Security-Policy': shellCSP({ frames: ORIGIN.studio, ancestors: ORIGIN.site, report: SHELL_REPORT }), 'Reporting-Endpoints': reportingEndpoints(SHELL_REPORT) });
+const STUDIO_HEADERS = () => ({ ...HARDEN, 'Content-Security-Policy': bundleCSP({ origin: ORIGIN.studio, ancestors: `'self' ${ORIGIN.shell} ${ORIGIN.site}`, report: STUDIO_REPORT }), 'Reporting-Endpoints': reportingEndpoints(STUDIO_REPORT) });
+
+const servers = [
+    http.createServer((req, res) => send(res, 200, SITE_PAGE, { 'Content-Type': 'text/html; charset=utf-8' })),
+    http.createServer((req, res) => {
+        const p = new URL(req.url, ORIGIN.shell).pathname;
+        const play = '/housegames/engine/play/';
+        if (p === SHELL_REPORT) return send(res, 204, '');
+        if (p.startsWith(play + 'core/')) return file(res, join(PKG, 'engine-shell'), p.slice(play.length), SHELL_HEADERS());
+        if (p.startsWith(play)) {
+            const rest = p.slice(play.length).split('/').slice(1).join('/') || 'index.html';
+            if (rest === 'descriptor.json') return send(res, 200, JSON.stringify({ catalogSlug: 'housebets-engine-' + SLUG, bundleUrl: ORIGIN.studio + '/index.html' }), { 'Content-Type': 'application/json' });
+            return file(res, join(PKG, 'engine-shell/host'), rest, SHELL_HEADERS());
+        }
+        if (p.startsWith('/housegames/engine/engine-sdk/')) return file(res, join(PKG, 'engine-sdk'), p.slice('/housegames/engine/engine-sdk/'.length));
+        if (p.startsWith('/housegames/')) return proxy(req, res);
+        send(res, 404, 'not found');
+    }),
+    http.createServer((req, res) => {
+        let p = decodeURIComponent(new URL(req.url, ORIGIN.studio).pathname).replace(/^\/+/, '') || 'index.html';
+        if ('/' + p === STUDIO_REPORT) return send(res, 204, '');
+        const headers = STUDIO_HEADERS();
+        // A script the browser fetches as a worker's own (Sec-Fetch-Dest, which
+        // no page can forge) is served with the worker prelude first (travel.mjs
+        // workerShim): its clocks at the run's instant, the trap for its own
+        // workers; its location and its relative imports stay its own. The same
+        // file fetched by a page, a <script> or importScripts comes as it is.
+        const dest = req.headers['sec-fetch-dest'];
+        const prelude = dest === 'worker' || dest === 'sharedworker' ? workerShim(Date.now() + clockOffsetMs, RUN_TOKEN, travelling ? CLOCK : null) : '';
+        if (p.startsWith('engine-sdk/')) return file(res, join(PKG, 'engine-sdk'), p.slice('engine-sdk/'.length), headers, prelude);
+        file(res, BUNDLE, p, headers, prelude);
+    }),
+];
+[ORIGIN.site, ORIGIN.shell, ORIGIN.studio] = await Promise.all([listen(servers[0], 'localhost'), listen(servers[1], '127.0.0.1'), listen(servers[2], '127.0.0.1')]);
+
+// ---- launch: engine-dev's play-money player ----------------------------------------------
+async function launch(display, lang = '') {
+    const dev = await fetch(RGS + '/dev/launch').then((r) => (r.ok ? r.json() : null)).catch(() => null);
+    if (!dev) throw new Error(`${RGS} is not an engine-dev sandbox (no /dev/launch): the run plays against engine-dev only`);
+    // The player's language goes on the launch as the site puts it (the shell reads `lang`).
+    return { url: `${ORIGIN.shell}/housegames/engine/play/${SLUG}/?otp=${dev.otp}&currency=1&currencyPayload=${encodeURIComponent(JSON.stringify({ code: 1, ...display }))}${lang ? '&lang=' + encodeURIComponent(lang) : ''}` };
+}
+
+// ---- the run ------------------------------------------------------------------------------
+if (args.includes('--dev')) {
+    const { url } = await launch({ symbol: 'USDT', name: 'USDT', isFiat: false, rate: 1, precision: 8 });
+    console.log(`playing ${SLUG} from ${BUNDLE}\nopen ${ORIGIN.site}/#${encodeURIComponent(url)}\n(edit the bundle and reload; Ctrl-C to stop)`);
+    await new Promise(() => {});
+}
+const hbtest = existsSync(join(BUNDLE, 'hbtest.json')) ? JSON.parse(readFileSync(join(BUNDLE, 'hbtest.json'), 'utf8')) : null;
+const results = [];
+const check = (size, rule, ok, detail, status) => results.push({ size, rule, ok, detail, ...(status ? { status } : {}) });
+const { chromium } = await import('playwright-core');
+// --disable-dev-shm-usage: in a container /dev/shm is small, and a big canvas (BAD CAT at
+// 1920×1080) hung Chrome there until the run's time ran out; it passes in 72 s on a Mac.
+// Chrome's own sandbox stays on (Playwright turns it off unless told): studio
+// code runs in a renderer the kernel confines. A machine that cannot give one
+// says so with ENGINE_RUN_UNSANDBOXED=1, and the verdict carries the fact.
+// Without --enable-automation (Playwright's default) and with the blink
+// AutomationControlled feature off, navigator.webdriver is false: a bundle
+// that behaves only for a browser nobody drives sees a player's.
+const launchEnv = { PATH: process.env.PATH, HOME: process.env.HOME || '/tmp', LANG: process.env.LANG || 'C.UTF-8', TMPDIR: process.env.TMPDIR || '/tmp' };
+// A variant's time zone is set two ways: on the context (timezoneId: what
+// Date and Intl say) and on the Chrome process itself (TZ), because Blink
+// formats some dates in the process's own zone (document.lastModified) and a
+// game comparing the two would see the emulation. So Chrome is launched once
+// per zone the variants name; the frame sizes run in the machine's own.
+// WebGL on the CPU: the run has no GPU, and since Chrome 137 WebGL no longer falls back to
+// SwiftShader on its own, so a WebGL game (Pixi, three.js) drew a black frame here. SwiftShader
+// is more code within reach of the bundle's WebGL calls, so it is on only with Chrome's own
+// sandbox (the job: one upload, no role, no egress); a run without the sandbox (a stand on a
+// machine that cannot give one) keeps WebGL off.
+const SOFTWARE_WEBGL = UNSANDBOXED ? [] : ['--use-angle=swiftshader', '--enable-unsafe-swiftshader'];
+const launchChrome = (tz) => chromium.launch({ executablePath: CHROME, headless: true, chromiumSandbox: !UNSANDBOXED, env: tz ? { ...launchEnv, TZ: tz } : launchEnv, ignoreDefaultArgs: ['--enable-automation'], args: ['--autoplay-policy=no-user-gesture-required', '--disable-dev-shm-usage', '--disable-blink-features=AutomationControlled', ...SOFTWARE_WEBGL] });
+const browsers = new Map();
+const browserFor = async (tz) => { if (!browsers.has(tz)) browsers.set(tz, await launchChrome(tz)); return browsers.get(tz); };
+let browser;
+try {
+    browser = await launchChrome('');
+    browsers.set('', browser);
+} catch (e) {
+    console.error(`Chrome did not start${UNSANDBOXED ? '' : ' with its sandbox on (ENGINE_RUN_UNSANDBOXED=1 turns it off, knowingly)'}: ${e.message.split('\n')[0]}`);
+    process.exit(3);
+}
+
+// The currency matrix: each size plays under another of the player's displays,
+// a fiat at a rate and the bare coin. A game must show that currency and send
+// the stake the Originals would (engine-sdk money.js on the shell's wallet).
+const DISPLAYS = {
+    desktop: { symbol: 'EUR', name: 'USDT', isFiat: true, currentFiat: 'EUR', rate: 0.92, precision: 8, shows: '€' },
+    phone: { symbol: 'USDT', name: 'USDT', isFiat: false, rate: 1, precision: 8, shows: 'USDT' },
+};
+const FULLSCREEN = { desktop: { width: 1920, height: 1080 }, phone: { width: 390, height: 844 } };
+const SESSION_CURRENCY = { code: 1, symbol: 'USDT', decimals: 8 };
+
+const network = (size, outside, refused, rtc = 0, workers = 0, reports = 0) => check(size, 'network', !outside.length && !refused.length && !rtc && !workers && !reports,
+    outside.length ? 'left the bundle: ' + [...new Set(outside)].slice(0, 3).join(', ')
+        : refused.length ? 'the policy refused: ' + [...new Set(refused)].slice(0, 2).join(' | ')
+            : rtc ? `opened ${rtc} peer connection(s) (WebRTC): the game has no network of its own`
+                : workers ? `registered ${workers} service worker(s)`
+                    : reports ? `posted ${reports} request(s) to the policy's report path: the policy refused something, or the game posts there itself`
+                        : 'only its own origin, nothing refused');
+
+// What every frame learns before its own code runs, from one init script
+// (initScript), in this order:
+//   natives  the frame's own clock functions and descriptors, before anything
+//            replaces them (travel.mjs clockShim with `capture`)
+//   clock    under time travel, the fake clock (clock.mjs: Playwright's own
+//            implementation, installed with no global and driven through the
+//            run's channel), set to the variant's instant
+//   shim     every clock API behind a native-shaped Proxy, the same in every
+//            run (clockShim): what the game sees of the clocks has one shape
+//            on the frame sizes, in the matrix and in the canary
+//   page     the instrumentation below (INSTRUMENT_PAGE), with nothing added
+//            to window and every replaced function behind a Proxy of the
+//            native one (so Function.prototype.toString says native code):
+//            what it records goes out through console.debug, bound before the
+//            game can replace it, under a token the page never sees in the DOM
+//     dialogs  alert / confirm / prompt / print / window.open attempts: the
+//              frame has no allow-modals, so a dialog never shows and Chrome
+//              never says it was asked for; the page counts the attempts itself
+//     rtc      a peer connection is a network of the game's own that no CSP
+//              directive but `webrtc` governs: the attempts are counted and refused
+//     text     every string drawn on a 2D canvas (a Pixi text is one): a prompt
+//              drawn, not typed, is read like the DOM's words
+//   trap     the worker trap and the clock channel (travel.mjs clockTrap):
+//            every Worker and SharedWorker started is reported; a blob script
+//            is started from a wrapper carrying the worker prelude, a
+//            same-origin script gets it from the run's server; a jump of the
+//            clock reaches the frame here and goes on to its workers
+// The script is built as text from the functions travel.mjs and clock.mjs
+// export and test, not from copies of them.
+const INSTRUMENT_PAGE = (scope, token) => {
+    const say = scope.console.debug.bind(scope.console);
+    const fix = (obj, name, value) => { try { Object.defineProperty(obj, name, { value, configurable: false, writable: false }); } catch { /* already fixed */ } };
+    const answer = { alert: undefined, confirm: false, prompt: null, print: undefined, open: null };
+    for (const name of Object.keys(answer)) {
+        const orig = scope[name];
+        if (typeof orig !== 'function') continue;
+        fix(scope, name, new Proxy(orig, { apply() { say(token + ':dialog:' + name); return answer[name]; } }));
+    }
+    for (const name of ['RTCPeerConnection', 'webkitRTCPeerConnection', 'mozRTCPeerConnection']) {
+        const orig = scope[name];
+        if (typeof orig !== 'function') continue;
+        const deny = () => { say(token + ':rtc:' + name); throw new DOMException('WebRTC is not available to a studio game', 'NotSupportedError'); };
+        fix(scope, name, new Proxy(orig, { apply: deny, construct: deny }));
+    }
+    const drawn = new Set();
+    for (const C of [scope.CanvasRenderingContext2D, scope.OffscreenCanvasRenderingContext2D]) {
+        for (const m of ['fillText', 'strokeText']) {
+            const orig = C && C.prototype && C.prototype[m];
+            if (typeof orig !== 'function') continue;
+            C.prototype[m] = new Proxy(orig, { apply(t, self, a) { const s = String(a[0] ?? '').trim(); if (s && drawn.size < 2000 && !drawn.has(s)) { drawn.add(s); say(token + ':text:' + s.slice(0, 200)); } return Reflect.apply(t, self, a); } });
+        }
+    }
+};
+// Playwright's clock source, read once; only a travelling run needs it, and
+// refuses to travel without it (clock.mjs). With startClock as text, it is
+// what a travelling page's workers are started with too (trapOptions).
+const CLOCK_SOURCE = TRAVEL ? clockSource() : null;
+const CLOCK = CLOCK_SOURCE ? { source: CLOCK_SOURCE, start: String(startClock) } : null;
+// The init script of every frame: the natives, the fake clock when the
+// variant travels (`at`: its instant), the shim, the instrumentation, the trap
+// (given the fake clock's text when the variant travels, for the workers).
+const initScript = ({ travel, at }) => `(() => {
+    const scope = globalThis;
+    const natives = (${String(clockShim)})(scope, { capture: true });
+    let fake = null, jump = null;
+    ${travel ? `{
+        const module = { exports: {} };
+        ${CLOCK_SOURCE}
+        const started = (${String(startClock)})(scope, ${JSON.stringify({ at: new Date(at).getTime(), wall: Date.now() })}, module.exports, natives);
+        fake = started.fake; jump = started.jump;
+    }` : ''}
+    const setAt = (${String(clockShim)})(scope, { natives, fake });
+    (${String(INSTRUMENT_PAGE)})(scope, ${JSON.stringify(RUN_TOKEN)});
+    (${String(clockTrap)})(scope, ${JSON.stringify(trapOptions(RUN_TOKEN, travel ? CLOCK : null))}, { setAt, jump, realNow: natives.Date.now });
+})();\n`;
+// A frame of the game's: the bundle's own pages, and every frame they make,
+// whatever its URL (srcdoc, about:blank, a data URL): same-origin to the game,
+// under its sandbox, and able to show anything the game can.
+const isGameFrame = (f) => { for (let x = f; x; x = x.parentFrame()) if (x.url().startsWith(ORIGIN.studio)) return true; return false; };
+const studioFrames = (page) => page.frames().filter(isGameFrame);
+const sumIn = async (page, expr) => (await Promise.all(studioFrames(page).map((f) => f.evaluate(expr).catch(() => 0)))).reduce((a, b) => a + b, 0);
+const listIn = async (page, expr) => (await Promise.all(studioFrames(page).map((f) => f.evaluate(expr).catch(() => [])))).flat();
+
+// What a page records while it plays: uncaught errors, requests that left
+// the bundle, the policy's refusals, the plays that reached the engine, posts
+// to the policy's report path, and what the pages' instrumentation says
+// through the console (dialogs, peer connections, workers, canvas text). The
+// same for every run.
+function instrument(page) {
+    const errors = [], outside = [], refused = [], plays = [], consoleErrors = [], dialogs = [], workers = [], canvasText = [];
+    let reports = 0, rtc = 0, unshimmed = 0;
+    page.on('pageerror', (e) => errors.push(e.message.slice(0, 160)));
+    page.on('console', (m) => {
+        const text = m.text();
+        if (text.startsWith(RUN_TOKEN + ':')) {
+            const rest = text.slice(RUN_TOKEN.length + 1);
+            const i = rest.indexOf(':');
+            const kind = rest.slice(0, i), payload = rest.slice(i + 1);
+            if (kind === 'dialog') dialogs.push(payload);
+            else if (kind === 'rtc') rtc++;
+            else if (kind === 'worker') workers.push(payload);
+            else if (kind === 'unshimmed') unshimmed++;
+            else if (kind === 'text') canvasText.push(payload);
+            else if (kind === 'uncaught') errors.push(payload.slice(0, 160)); // a timer's exception under the fake clock: uncaught in production
+            return;
+        }
+        if (m.type() !== 'error') return;
+        if (text.includes('Content Security Policy')) refused.push(text.slice(0, 120));
+        else consoleErrors.push(text.slice(0, 160));
+    });
+    page.on('request', (r) => {
+        const u = r.url();
+        // A request no page of the game made (a worker's) names no frame.
+        let f = null;
+        try { f = r.frame(); } catch { f = null; }
+        if (f && isGameFrame(f)) {
+            // The report path is the browser's to post to, on a refusal; a game
+            // posting there itself is a game spending its player's report allowance.
+            if (u.startsWith(ORIGIN.studio) && new URL(u).pathname === STUDIO_REPORT) reports++;
+            else if (!u.startsWith(ORIGIN.studio) && !u.startsWith('data:') && !u.startsWith('blob:')) outside.push(u.slice(0, 120));
+        }
+        if (u.includes('/engine/v1/play')) plays.push(r.postData() || '');
+    });
+    return { errors, outside, refused, plays, consoleErrors, workers, canvasText, reports: () => reports, rtcCount: () => rtc, dialogs: () => [...dialogs], unshimmed: () => unshimmed };
+}
+
+// The site's log of the shell's messages, and the hbtest steps on the game's own pages.
+function helpers(page) {
+    const log = () => page.evaluate(() => window.__log);
+    const waitFor = async (pred, ms) => { for (let t = 0; t < ms; t += 250) { if (pred(await log())) return true; await page.waitForTimeout(250); } return false; };
+    // A control below the window is scrolled to first: Playwright's own scroll
+    // through the site's and the shell's frames (two sites) can miss it.
+    // 'nearest' moves nothing for a control already in view.
+    const press = async (control) => {
+        await control.evaluate((e) => e.scrollIntoView({ block: 'nearest' }));
+        await control.click({ timeout: 5000 });
+    };
+    // A step names one of the game's own pages, never the shell's or the site's.
+    const gameFrame = (name) => page.frames().find((x) => x.url().startsWith(ORIGIN.studio) && x.url().includes(name));
+    const act = async (step) => {
+        const f = gameFrame(step.page);
+        if (!f) throw new Error('no page ' + step.page);
+        // Selectors reach into shadow roots (the engine's panel is one); an
+        // open dialog of the game's is closed first so it cannot cover the click.
+        await f.evaluate(() => document.querySelectorAll('dialog[open]').forEach((d) => d.close()));
+        if (step.value !== undefined) await f.locator(step.selector).first().fill(String(step.value));
+        else await press(f.locator(step.selector).first());
+    };
+    // A `then` step (Next, Cash out) is pressed only when its control is there to press.
+    const thenSteps = async (steps) => {
+        for (const s of steps || []) {
+            const f = gameFrame(s.page);
+            const control = f && f.locator(s.selector).first();
+            if (control && await control.isVisible().catch(() => false) && await control.isEnabled().catch(() => false)) await press(control);
+        }
+    };
+    const roundEnds = (l) => l.filter((m) => m.d.type === 'housebets-game-round-end').length;
+    // A player's hand: the pointer wanders over the game and the wheel turns a
+    // little, so a path armed by pointer activity (a game that waits for a
+    // human's moves) is armed here too, and hover states are the same in every
+    // screenshot. The frame is 1194×720 at the top left of the page.
+    const wander = async () => {
+        let x = 300 + Math.random() * 500, y = 150 + Math.random() * 350;
+        for (let i = 0; i < 60; i++) {
+            x = Math.max(20, Math.min(1170, x + (Math.random() - 0.5) * 140));
+            y = Math.max(20, Math.min(700, y + (Math.random() - 0.5) * 100));
+            await page.mouse.move(x, y, { steps: 2 }).catch(() => {});
+        }
+        await page.mouse.wheel(0, 40).catch(() => {});
+        await page.mouse.wheel(0, -40).catch(() => {});
+    };
+    return { log, waitFor, press, gameFrame, act, thenSteps, roundEnds, wander };
+}
+
+// ---- the frame sizes: desktop and phone -------------------------------------------------
+// The console errors of each size, for the JSON (`console`): a test bundle's
+// own report of what it saw (travel.browser.test.mjs) is read from here.
+const frameConsole = {};
+for (const [size, width] of TRAVEL ? [] : [['desktop', 1194], ['phone', 364]]) {
+    const { shows, ...display } = DISPLAYS[size];
+    const money = moneyFor(walletFrom(JSON.stringify(display), SESSION_CURRENCY));
+    const context = await browser.newContext({ viewport: { width, height: 900 } });
+    const page = await context.newPage();
+    await page.addInitScript(initScript({ travel: false }));
+    const { errors, outside, refused, plays, reports, rtcCount, consoleErrors } = instrument(page);
+    // Kept for the JSON once the size is done: the first distinct lines, bounded
+    // (a test bundle's report of what it saw runs to some sixty lines).
+    const keepConsole = () => { frameConsole[size] = [...new Set(consoleErrors)].slice(0, 200); };
+    const { log, waitFor, act, press, gameFrame, roundEnds } = helpers(page);
+    await page.goto(ORIGIN.site + '/');
+    const { url } = await launch(display);
+    await page.evaluate((u) => window.__launch(u), url);
+    const ready = await waitFor((l) => l.some((m) => m.d.message === 'gameLoaded'), 25000);
+    check(size, 'boot', ready, ready ? 'hello answered, ready reported' : 'no ready within 25 s (the game never connected, or never called engine.ready())');
+    if (!ready) {
+        // Nothing after boot means anything when the game never started.
+        for (const rule of ['idle', 'fit', 'bet', 'currency', 'outage']) check(size, rule, false, 'not reached: the game did not boot');
+        check(size, 'errors', errors.length === 0, errors.length ? [...new Set(errors)].slice(0, 4).join(' | ') : 'none');
+        network(size, outside, refused, rtcCount(), context.serviceWorkers().length, reports());
+        keepConsole();
+        await page.close();
+        continue;
+    }
+    // Nobody touches the game for a while: it must not bet on its own. A
+    // bet is the player's act; a bundle that plays unprompted is refused.
+    const idleFrom = plays.length;
+    await page.waitForTimeout(Number(opt('idle-ms', '15000')));
+    check(size, 'idle', plays.length === idleFrom, plays.length === idleFrom ? 'no bet without the player' : `${plays.length - idleFrom} bet(s) placed while nobody touched the game`);
+
+    // fit: every page of the game at its frame size, now and after each page
+    // the test opens
+    // A control outside the frame cannot be pressed (an overflow the layout
+    // clips scrolls nowhere), unless a scroller holds it; what is not shown
+    // (hidden, a closed <details>, aria-hidden, inert) is not there to press.
+    const scrolling = new Set();
+    const measure = async (at = '') => {
+        for (const f of studioFrames(page)) {
+            const d = await f.evaluate(() => {
+                const cut = [];
+                const scroller = (el) => { for (let e = el.parentElement; e && e !== document.documentElement && e !== document.body; e = e.parentElement) { const o = getComputedStyle(e); if (/auto|scroll/.test(o.overflowX + o.overflowY)) return true; } return false; };
+                const walk = (root) => {
+                    for (const el of root.querySelectorAll('button, input, select, a[href]')) {
+                        const r = el.getBoundingClientRect();
+                        if (r.width && r.height && (r.right > innerWidth + 1 || r.left < -1 || r.bottom > innerHeight + 1 || r.top < -1) && !scroller(el) && el.checkVisibility({ visibilityProperty: true }) && !el.closest('[aria-hidden="true"], [inert]')) cut.push((el.id ? '#' + el.id : el.tagName.toLowerCase()) + ' ' + (el.textContent || el.getAttribute('aria-label') || '').trim().slice(0, 16) + ` at ${Math.round(r.left)},${Math.round(r.top)}`);
+                    }
+                    for (const host of root.querySelectorAll('*')) if (host.shadowRoot) walk(host.shadowRoot);
+                };
+                walk(document);
+                // Content (text, canvas, images) the frame's edge cuts through. A clip
+                // inside the frame (a reel window, a ticker) is the game's own; a clip
+                // that reaches the frame's edge is the frame's, so it does not count.
+                const art = [];
+                const up = (e) => e.assignedSlot || e.parentElement || e.getRootNode().host;
+                const shown = (el) => {
+                    const r = el.getBoundingClientRect();
+                    let [L, T, R, B] = [r.left, r.top, r.right, r.bottom];
+                    for (let e = up(el); e && e !== document.body && e !== document.documentElement; e = up(e)) {
+                        const o = getComputedStyle(e);
+                        if (o.overflowX === 'visible' && o.overflowY === 'visible') continue;
+                        const q = e.getBoundingClientRect();
+                        if (q.left <= 1 || q.top <= 1 || q.right >= innerWidth - 1 || q.bottom >= innerHeight - 1) continue;
+                        if (o.overflowX !== 'visible') { L = Math.max(L, q.left); R = Math.min(R, q.right); }
+                        if (o.overflowY !== 'visible') { T = Math.max(T, q.top); B = Math.min(B, q.bottom); }
+                    }
+                    return { L, T, R, B };
+                };
+                const content = (root) => {
+                    for (const el of root.querySelectorAll('*')) {
+                        if (el.shadowRoot) content(el.shadowRoot);
+                        const media = /^(CANVAS|IMG|VIDEO)$/.test(el.tagName) || (el.tagName === 'svg' && !el.parentElement?.closest('svg'));
+                        if (!media && ![...el.childNodes].some((n) => n.nodeType === 3 && n.textContent.trim())) continue;
+                        const { L, T, R, B } = shown(el);
+                        if (R - L < 2 || B - T < 2 || R <= 0 || B <= 0 || L >= innerWidth || T >= innerHeight) continue; // nothing of it on screen
+                        // Text may not be cut at all; a canvas or picture may lose a margin (a tenth of it).
+                        const sx = media ? (R - L) / 10 : 1, sy = media ? (B - T) / 10 : 1;
+                        if ((R > innerWidth + sx || L < -sx || B > innerHeight + sy || T < -sy) && !scroller(el) && el.checkVisibility({ visibilityProperty: true, opacityProperty: true }) && !el.closest('[aria-hidden="true"], [inert]'))
+                            art.push(el.tagName.toLowerCase() + (el.id ? '#' + el.id : '') + (media ? '' : ' "' + el.textContent.trim().slice(0, 12) + '"') + ` at ${Math.round(L)},${Math.round(T)}`);
+                    }
+                };
+                content(document);
+                return { h: innerHeight, w: innerWidth, cut, art, content: document.documentElement.scrollHeight, path: location.pathname, clip: getComputedStyle(document.documentElement).overflowY === 'hidden' && getComputedStyle(document.body).overflowY === 'hidden' };
+            }).catch(() => null);
+            if (d && !d.clip && d.content > d.h + 1) scrolling.add(`${at}${d.path} is ${d.content}px in a ${d.h}px frame`);
+            if (d && d.cut.length) scrolling.add(`${at}${d.path} controls outside the ${d.w}×${d.h} frame: ${d.cut.slice(0, 4).join(', ')}`);
+            if (d && d.art.length) scrolling.add(`${at}${d.path} content cut by the ${d.w}×${d.h} frame's edge (mark decoration aria-hidden): ${d.art.slice(0, 4).join(', ')}`);
+        }
+    };
+    await measure();
+
+    // bet + outage through the studio's own UI
+    if (!hbtest) check(size, 'bet', false, 'no hbtest.json: the run cannot place a bet through the game');
+    else {
+        try {
+            for (const s of [...(hbtest.visit || []), ...(hbtest.open || [])]) { await act(s); await page.waitForTimeout(2500); await measure(); }
+            if (hbtest.stake) await act(hbtest.stake);
+            const before = plays.length, ends = roundEnds(await log());
+            await act(hbtest.bet);
+            // A ladder's bet opens a round: the test's `then` steps close it.
+            // A ladder is random — a bust ends it before Cash out exists — so a
+            // `then` step is played only when its control is there to press.
+            for (const s of hbtest.then || []) {
+                await page.waitForTimeout(1500);
+                const f = gameFrame(s.page);
+                const control = f && f.locator(s.selector).first();
+                if (control && await control.isVisible().catch(() => false) && await control.isEnabled().catch(() => false)) await press(control);
+            }
+            const revealed = await waitFor((l) => roundEnds(l) > ends, 10000);
+            // One press, one bet: a game that sends two plays per press charges the player twice.
+            const placed = plays.length - before;
+            check(size, 'bet', placed === 1 && revealed, placed === 0 ? 'the bet never reached engine.play' : placed > 1 ? `${placed} bets reached engine.play for one press` : revealed ? 'engine.play, then revealed → site round-end' : 'engine.play, but no revealed within 10 s');
+            // And nothing after it on its own: the next 10 s untouched bring no bet.
+            if (revealed) {
+                const settled = plays.length;
+                await page.waitForTimeout(10000);
+                if (plays.length !== settled) check(size, 'idle', false, `${plays.length - settled} bet(s) placed on their own after the round`);
+            }
+            // What the game shows is the row the server drew: `shows` names an
+            // element and a path into the round (data.0.side); the text must carry it.
+            if (hbtest.shows && revealed) {
+                const round = await page.frames().find((x) => x.url().includes('/housegames/engine/play/')).evaluate(() => (window.__rounds || []).at(-1)?.round);
+                const value = hbtest.shows.path.split('.').reduce((v, k) => (v == null ? v : v[k]), round);
+                const f = gameFrame(hbtest.shows.page);
+                const text = f ? await f.locator(hbtest.shows.selector).first().innerText().catch(() => '') : '';
+                const ok = value != null && text.toLowerCase().includes(String(value).toLowerCase());
+                check(size, 'shows', ok, ok ? `${hbtest.shows.selector} shows ${hbtest.shows.path} = ${value}` : `${hbtest.shows.selector} shows "${text.slice(0, 40)}", the round's ${hbtest.shows.path} is ${value}`);
+            }
+            // draws: after the round the game's play area shows something — its
+            // visible leaves and painted boxes (canvases, pictures, anything with a
+            // background), backdrops the size of the frame aside, cover at least
+            // 2% of the frame. A board with no size fails.
+            if (revealed) {
+                let area = 0, frameArea = 1;
+                for (const f of studioFrames(page)) {
+                    const d = await f.evaluate(() => {
+                        const root = document.querySelector('hb-game [slot="zone"]') || document.body;
+                        let a = 0;
+                        for (const el of [root, ...root.querySelectorAll('*')]) { // the zone itself may be the board (a coin)
+                            if (el.closest('svg') && el.tagName !== 'svg') continue;
+                            const st = getComputedStyle(el);
+                            const painted = st.backgroundImage !== 'none' || !/rgba\(.*, 0\)|transparent/.test(st.backgroundColor);
+                            if (el.children.length && !painted && !/^(CANVAS|IMG|VIDEO|svg)$/.test(el.tagName)) continue;
+                            if (!el.checkVisibility({ visibilityProperty: true, opacityProperty: true })) continue;
+                            const r = el.getBoundingClientRect();
+                            const s = Math.max(0, Math.min(r.right, innerWidth) - Math.max(r.left, 0)) * Math.max(0, Math.min(r.bottom, innerHeight) - Math.max(r.top, 0));
+                            if (s < innerWidth * innerHeight * 0.9) a += s; // a backdrop the size of the frame is not the game
+                        }
+                        return { a, f: innerWidth * innerHeight };
+                    }).catch(() => ({ a: 0, f: 1 }));
+                    area += d.a; frameArea = Math.max(frameArea, d.f);
+                }
+                const share = area / frameArea;
+                check(size, 'draws', share >= 0.02, share >= 0.02 ? `the play area shows content (${Math.round(share * 100)}% of the frame)` : `the play area shows nothing (${(share * 100).toFixed(1)}% of the frame): check the board has a size`);
+            }
+            if (plays.length > before && hbtest.stake) {
+                let sent = null;
+                try { sent = JSON.parse(plays[before]).amount; } catch { sent = null; }
+                const want = money.parse(String(hbtest.stake.value));
+                // The currency on screen: in the page's text, or in the engine
+                // field (its sign, or the unit its input is labelled with).
+                const seen = await Promise.all(studioFrames(page).map((x) => x.evaluate((unit) => {
+                    const f = document.querySelector('hb-bet-amount') || [...document.querySelectorAll('*')].map((e) => e.shadowRoot && e.shadowRoot.querySelector('hb-bet-amount')).find(Boolean);
+                    const inField = f && f.shadowRoot && (f.shadowRoot.querySelector('.sign').textContent + ' ' + f.shadowRoot.querySelector('input').getAttribute('aria-label'));
+                    return document.body.innerText + ' ' + (inField || '');
+                }, shows).catch(() => '')));
+                const visible = seen.some((t) => t.includes(shows));
+                check(size, 'currency', sent === want && visible, `${display.isFiat ? display.currentFiat + ' at ' + display.rate : display.symbol}: typed ${hbtest.stake.value}, sent ${sent}, the Originals send ${want}` + (visible ? '' : `; nothing on screen says ${shows}`));
+            }
+            // The next bet meets an ambiguous wallet answer (engine-dev debits
+            // and answers "pending"): the game must not break, and the site
+            // must be asked to re-read the wallet.
+            if (SKIP_OUTAGE) {
+                check(size, 'outage', true, 'skipped: this job has no wallet fault stub; the real round checks completed', 'skipped');
+            } else {
+                const armed = await fetch(RGS + '/dev/fault', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ count: 1 }) }).then((r) => r.ok).catch(() => false);
+                if (!armed) check(size, 'outage', false, 'engine-dev has no /dev/fault: update the sandbox (hbengine) to run the outage check');
+                else {
+                const errs = errors.length;
+                await page.waitForTimeout(1200);
+                await act(hbtest.bet);
+                const reread = await waitFor((l) => l.some((m) => m.d.type === 'housebets-game-balance-reconciliation-request'), 10000);
+                check(size, 'outage', reread && errors.length === errs, reread ? (errors.length === errs ? 'ambiguous bet: the site was asked to re-read the wallet; the game kept running' : 'the game threw: ' + errors.slice(errs).join('; ')) : 'no wallet re-read requested after an ambiguous bet');
+                }
+            }
+        } catch (e) {
+            check(size, 'bet', false, 'hbtest.json step failed: ' + e.message);
+            for (const rule of ['currency', 'outage']) check(size, rule, false, 'not reached: the bet step failed');
+        }
+    }
+    await measure();
+    // The site's fullscreen button: the frame takes the whole screen.
+    const full = FULLSCREEN[size];
+    await page.setViewportSize(full);
+    await page.evaluate(() => { document.getElementById('c').style.height = innerHeight + 'px'; });
+    await page.waitForTimeout(1500);
+    await measure('fullscreen: ');
+    check(size, 'fit', scrolling.size === 0, scrolling.size ? 'does not fit: ' + [...scrolling].join('; ') : `fits ${width}×720 and fullscreen ${full.width}×${full.height}`);
+    check(size, 'errors', errors.length === 0, errors.length ? [...new Set(errors)].slice(0, 4).join(' | ') : 'none');
+    network(size, outside, refused, rtcCount(), context.serviceWorkers().length, reports());
+    keepConsole();
+    const shot = await page.screenshot().catch(() => null);
+    if (shot) {
+        writeFileSync(`${opt('shots', process.cwd())}/conformance-${SLUG}-${size}.png`, shot);
+        // A frame of one flat colour: the game drew nothing the screenshot can see
+        // (a canvas the browser could not draw, or a board that never painted).
+        // A warning for the reviewer for now: the run's software WebGL is new.
+        let flat = null;
+        try { flat = flatShare(shot); } catch { /* not a picture we can read: say nothing */ }
+        if (flat !== null) check(size, 'picture', true, flat >= 0.98 ? `the screenshot is one flat colour (${Math.round(flat * 100)}% of it): the game may draw nothing a player can see` : 'the screenshot shows the game', flat >= 0.98 ? 'warning' : undefined);
+    }
+}
+
+// ---- time travel: the matrix of clocks, zones and languages ------------------------------
+// Every variant is a fresh context at the desktop frame under the desktop
+// display (EUR at a rate: the very pairing the frame-size run plays at this
+// width, so a game keying on the frame's width and the currency finds nothing
+// the frame-size run does not show it), with Playwright's clock installed
+// before the page loads (so the game's first read of the date is the
+// travelled one), the zone and the language set on the context and the
+// language on the launch, and the game's storage as the variant before left
+// it (travel.mjs handedStorage: never written at a later clock than the
+// variant's own). What it records is judged against the baseline variant
+// (travel.mjs compareVariant); the screenshots are kept so a reviewer can
+// look at a warning.
+let timeTravel = null;
+if (TRAVEL) {
+    const now = new Date();
+    const matrixStart = Date.now();
+    const variants = variantsFor(TRAVEL, now).filter((v) => !TRAVEL_ONLY || TRAVEL_ONLY.includes(v.id)).map((v) => ({ ...v, rounds: v.rounds ? TRAVEL_ROUNDS : undefined, at: clockFor(v, now).toISOString() }));
+    const manifest = opt('manifest', '') && existsSync(opt('manifest')) ? JSON.parse(readFileSync(opt('manifest'), 'utf8')) : null;
+    const { shows, ...display } = DISPLAYS.desktop; // the frame-size run's pairing at 1194 px
+    const shotsDir = opt('shots', process.cwd());
+    const grids = { boot: {}, late: {} };
+    // The frame as a grid of grey cells (travel.mjs GRID), drawn by the
+    // browser from the PNG it just took: no image library in the run.
+    const toGrid = (page, png) => page.evaluate(async ([b64, w, h]) => {
+        const img = new Image();
+        await new Promise((res, rej) => { img.onload = res; img.onerror = rej; img.src = 'data:image/png;base64,' + b64; });
+        const c = document.createElement('canvas');
+        c.width = w; c.height = h;
+        const ctx = c.getContext('2d');
+        ctx.drawImage(img, 0, 0, w, h);
+        const d = ctx.getImageData(0, 0, w, h).data;
+        const out = [];
+        for (let i = 0; i < d.length; i += 4) out.push(Math.round(0.299 * d[i] + 0.587 * d[i + 1] + 0.114 * d[i + 2]));
+        return out;
+    }, [png.toString('base64'), GRID.w, GRID.h]).catch(() => null);
+    // The game's pages: their inputs (by signature, never a value; a masked or
+    // password-autocompleting text field, a contenteditable, a role=textbox
+    // among them) and their words (the rendered text, text nodes, placeholders,
+    // labels, titles, alt text, CSS generated content, shadow roots included),
+    // for the credential-prompt patterns.
+    const scanPages = async (page) => listIn(page, () => {
+        const inputs = [], texts = [];
+        let looked = 0;
+        const walk = (root, hosts) => {
+            const sdk = hosts.some((t) => t.startsWith('HB-'));
+            for (const el of root.querySelectorAll('input, textarea, [contenteditable]:not([contenteditable="false"]), [role="textbox"]')) {
+                let type = el.tagName === 'TEXTAREA' ? 'textarea' : el.tagName === 'INPUT' ? (el.getAttribute('type') || 'text').toLowerCase() : 'text';
+                if (!['password', 'email', 'text', 'tel', 'url', 'search', 'textarea'].includes(type)) continue;
+                const st = getComputedStyle(el);
+                const masked = st.webkitTextSecurity && st.webkitTextSecurity !== 'none';
+                inputs.push({ type, id: el.id, name: el.getAttribute('name') || '', autocomplete: el.getAttribute('autocomplete') || '', masked, sdk });
+            }
+            const it = document.createNodeIterator(root, NodeFilter.SHOW_TEXT);
+            for (let n = it.nextNode(); n; n = it.nextNode()) {
+                const p = n.parentElement;
+                if (p && !p.closest('script, style, template, noscript')) texts.push(n.textContent);
+            }
+            // The text as rendered: inline boundaries kept, so a word split over
+            // two elements reads as one word.
+            const body = root === document ? document.body : root.host;
+            if (body && body.innerText) texts.push(body.innerText);
+            for (const el of root.querySelectorAll('[placeholder], [aria-label], [title], [alt]')) texts.push(el.getAttribute('placeholder'), el.getAttribute('aria-label'), el.getAttribute('title'), el.getAttribute('alt'));
+            for (const el of root.querySelectorAll('*')) {
+                if (looked++ > 4000) break;
+                for (const pseudo of ['::before', '::after']) {
+                    const c = getComputedStyle(el, pseudo).content;
+                    if (c && c !== 'none' && c !== 'normal' && c.length > 2) texts.push(c.replace(/^["']|["']$/g, ''));
+                }
+            }
+            for (const host of root.querySelectorAll('*')) if (host.shadowRoot) walk(host.shadowRoot, [...hosts, host.tagName]);
+        };
+        walk(document, []);
+        return [{ inputs, text: texts.filter(Boolean).join(' ') }];
+    });
+    // The game's child frames with something in them (a placeholder about:blank
+    // is nothing): where the game's pages are, by path or by kind.
+    const childFrames = async (page) => {
+        const out = [];
+        for (const f of page.frames()) {
+            if (!isGameFrame(f) || !f.parentFrame() || !isGameFrame(f.parentFrame())) continue;
+            const has = await f.evaluate(() => !!document.body && (document.body.children.length > 0 || document.body.textContent.trim().length > 0)).catch(() => false);
+            if (!has) continue;
+            const u = f.url();
+            out.push(u.startsWith(ORIGIN.studio) ? new URL(u).pathname : u.split('?')[0].slice(0, 80));
+        }
+        return out;
+    };
+    // The long session's animations: timers and frames run on the clock, and a
+    // CSS or Web Animations API animation, which runs on the compositor's real
+    // time, is moved on by every jump of the clock (clock.mjs startClock), so
+    // a round's reveal costs no waiting and the screen agrees with the clock.
+    // What the game's screen says when a round is stuck, for the report.
+    const screenSays = async (page) => {
+        const words = (await listIn(page, () => [document.body.innerText.replace(/\s+/g, ' ').trim().slice(0, 160)])).filter(Boolean).join(' / ');
+        const animations = (await listIn(page, () => document.getAnimations().filter((a) => a.playState === 'running').map((a) => `${a.effect?.target?.tagName || '?'}${a.effect?.target?.id ? '#' + a.effect.target.id : ''} at ${Math.round(a.currentTime || 0)} of ${a.effect?.getTiming?.().duration ?? '?'} ms`))).slice(0, 4);
+        return (words ? ` (the screen says: "${words}")` : '') + (animations.length ? ` (animations still running: ${animations.join(', ')})` : '');
+    };
+    const record = async (v, page, m) => {
+        for (const p of await scanPages(page)) {
+            for (const i of p.inputs) { const s = inputSignature(i); if (!v.inputs.includes(s)) v.inputs.push(s); }
+            for (const hit of credentialHits(p.text)) if (!v.phishing.includes(hit)) v.phishing.push(hit);
+        }
+        for (const hit of credentialHits(m.canvasText.join(' '))) if (!v.phishing.includes(hit)) v.phishing.push(hit);
+        for (const f of await childFrames(page)) if (!v.frames.includes(f)) v.frames.push(f);
+    };
+    // The bet control as the browser measures it: a player's button, or a decoy
+    // (travel.mjs controlProblem). What was pressed goes in the report.
+    const measureControl = async (control) => control.evaluate((el) => {
+        const r = el.getBoundingClientRect();
+        let opacity = 1;
+        for (let e = el; e; e = e.parentElement || (e.getRootNode && e.getRootNode().host)) { const o = Number(getComputedStyle(e).opacity); if (!Number.isNaN(o)) opacity *= o; if (e === document.documentElement) break; }
+        const st = getComputedStyle(el);
+        return { w: r.width, h: r.height, left: r.left, top: r.top, vw: innerWidth, vh: innerHeight, opacity, pointerEvents: st.pointerEvents, visibility: st.visibility, disabled: !!el.disabled || el.getAttribute('aria-disabled') === 'true', tag: el.tagName.toLowerCase(), id: el.id || '', text: (el.textContent || el.getAttribute('aria-label') || '').replace(/\s+/g, ' ').trim().slice(0, 24) };
+    }).catch(() => null);
+    const checkControl = async (v, h) => {
+        const f = h.gameFrame(hbtest.bet.page);
+        const control = f && f.locator(hbtest.bet.selector).first();
+        const box = control && await control.count().catch(() => 0) ? await measureControl(control) : null;
+        if (box) v.betControl = { tag: box.tag, id: box.id, text: box.text, w: Math.round(box.w), h: Math.round(box.h) };
+        v.controlProblem = controlProblem(box);
+        return !v.controlProblem;
+    };
+    // The game's storage as a variant left it, for the next one: its own origin
+    // only (the shell's session is never carried over), IndexedDB included.
+    const keepStorage = async (context) => {
+        try {
+            const st = await context.storageState({ indexedDB: true });
+            const origins = (st.origins || []).filter((o) => o.origin === ORIGIN.studio);
+            return { cookies: [], origins, keys: (origins[0]?.localStorage || []).map((e) => e.name).sort().slice(0, 50) };
+        } catch { return null; }
+    };
+    const shotTo = async (page, name, where, id) => {
+        // Three captures a second apart, the middle one kept, their grid the
+        // cell-by-cell median: a reel that happened to spin in one capture does
+        // not make the difference.
+        const pngs = [], cells = [];
+        for (let k = 0; k < 3; k++) {
+            if (k) await page.waitForTimeout(1000);
+            const png = await page.screenshot();
+            pngs.push(png);
+            cells.push(await toGrid(page, png));
+        }
+        writeFileSync(join(shotsDir, name), pngs[1]);
+        grids[where][id] = medianGrid(cells);
+    };
+    // The storage the first variant starts from: what an earlier run left
+    // (`--storage`), at today's origin, or nothing. `storage` is what the next
+    // variant is handed (handedStorage: never a storage written at a clock
+    // past the variant's own); `carriedOut` is what the next run is handed
+    // (the file): the storage as the last variant on the real clock left it,
+    // before any walk, so tomorrow's run finds yesterday's date in it and not
+    // a day in its own future.
+    let storage = null, carriedOut = null;
+    const carried = { from: 'none', keys: 0 };
+    if (STORAGE_FILE && existsSync(STORAGE_FILE)) {
+        const raw = statSync(STORAGE_FILE).size <= STORAGE_FILE_MAX ? readFileSync(STORAGE_FILE, 'utf8') : '';
+        storage = carriedStorage(raw, ORIGIN.studio);
+        carried.from = storage ? 'file' : 'unreadable';
+        carried.keys = storage ? storage.keys.length : 0;
+    }
+    let variantsLeft = variants.length;
+    for (const [index, v] of variants.entries()) {
+        const started = Date.now();
+        variantsLeft--;
+        v.boot = false; v.inputs = []; v.phishing = []; v.requests = []; v.refused = []; v.errors = []; v.consoleErrors = []; v.dialogs = 0; v.dialogKinds = []; v.workers = []; v.frames = [];
+        // The matrix's real time: a variant that no longer fits is skipped and
+        // says so. The variants still to come are estimated from the short ones
+        // already played (the baseline first), not from the pessimistic constant,
+        // which would leave the long session no room in any job.
+        const fit = fitsBudget({ elapsedMs: Date.now() - matrixStart, totalMs: TRAVEL_TOTAL_MS, rounds: v.rounds, longBudgetMs: TRAVEL_BUDGET_MS, after: variantsLeft, perVariantMs: shortVariantEstimate(variants) });
+        if (!fit.fits) { v.skipped = `out of time: ${Math.round((Date.now() - matrixStart) / 1000)} s into the matrix's ${Math.round(TRAVEL_TOTAL_MS / 1000)} s`; continue; }
+        // A variant at the real time starts at the real time of its own start,
+        // not the matrix's (travel.mjs startInstant): the storage it is handed
+        // was written by the variant before it at the real time (the baseline's,
+        // before its walk, seconds into its play), and a clock behind that
+        // storage is a clock that ran backwards between visits. The dated
+        // variants keep the matrix's instants.
+        v.at = startInstant(v, v.at);
+        // The canary's baseline runs on the real clock: at the real date the
+        // point is to be a player's browser, which has no fake Date to find.
+        const fakeClock = !(TRAVEL === 'canary' && v.id === 'base');
+        clockOffsetMs = fakeClock ? new Date(v.at).getTime() - Date.now() : 0;
+        travelling = fakeClock;
+        // Chrome for the variant's zone (TZ on the process, timezoneId on the context: both say the zone).
+        const chrome = await browserFor(v.tz).catch((e) => { v.broke = `Chrome did not start for ${v.tz}: ${String(e.message || e).split('\n')[0].slice(0, 120)}`; return null; });
+        if (!chrome) { v.ms = Date.now() - started; continue; }
+        const context = await chrome.newContext({ viewport: { width: 1194, height: 900 }, timezoneId: v.tz, locale: v.locale, ...(storage ? { storageState: { cookies: storage.cookies, origins: storage.origins } } : {}) });
+        // The fake clock is installed by the init script (clock.mjs) and driven
+        // through the run's channel from the site page: every frame moves its
+        // clock and answers with its now, and the server's clock (clockOffsetMs:
+        // the proxy's timestamps, the Date headers, a worker prelude's instant)
+        // follows the game's own frame, so after a day of game time, or 300 fast
+        // rounds, a round's settledAt still agrees with the game's Date.now().
+        // The game's frame is the one to follow: a fake clock stands still while
+        // it jumps, so the real time a heavy frame spends inside its jumps is
+        // not counted by its clock while the site's and the shell's run on;
+        // those drift ahead of the game's by that much (clockSkewMs records how
+        // far), which the game cannot see (other origins) and the server does
+        // not follow. A frame that did not answer within 10 s is a frame whose
+        // clock did not move: the variant breaks rather than judging a game on
+        // clocks that disagree.
+        const advance = async (op, ms) => {
+            let timer;
+            const r = await Promise.race([
+                page.evaluate(siteJump, [RUN_TOKEN, op, ms]),
+                new Promise((_, reject) => { timer = setTimeout(() => reject(new Error('timeout')), 10000); }),
+            ]).finally(() => clearTimeout(timer)).catch(async (e) => {
+                const tally = await page.evaluate(() => window.__clock).catch(() => null);
+                throw new Error(`the fake clock did not move (${op} ${ms} ms) in every frame within 10 s${tally ? `: ${tally.from.length} of ${tally.posted} window(s) answered (${tally.from.join(', ')})` : ''}: ${e.message}`);
+            });
+            const far = Math.max(...r.nows), near = Math.min(...r.nows);
+            v.clockSkewMs = Math.max(v.clockSkewMs || 0, far - near);
+            const game = r.nows.filter((_, i) => String(r.from[i] || '').startsWith(ORIGIN.studio));
+            clockOffsetMs = (game.length ? Math.min(...game) : near) - Date.now();
+        };
+        const jump = (ms) => advance('runFor', ms);
+        const leap = (ms) => advance('fastForward', ms);
+        // The game's clock read back now and then against the server's: a drift
+        // would show here (clockDriftMs) instead of in a round's timestamps.
+        const syncClock = async (page) => {
+            if (!fakeClock) return;
+            const frame = studioFrames(page)[0];
+            if (!frame) return;
+            const gameNow = await frame.evaluate(() => Date.now()).catch(() => null);
+            if (typeof gameNow !== 'number') return;
+            const measured = gameNow - Date.now();
+            v.clockDriftMs = Math.max(v.clockDriftMs || 0, Math.abs(measured - clockOffsetMs));
+            clockOffsetMs = measured;
+        };
+        const page = await context.newPage();
+        await page.addInitScript(initScript({ travel: fakeClock, at: v.at }));
+        const pageDialogs = [];
+        page.on('dialog', (d) => { pageDialogs.push(d.type()); d.dismiss().catch(() => {}); });
+        const m = instrument(page);
+        const h = helpers(page);
+        // The game's storage as it stood before the walk (at the variant's own
+        // instant), for a variant whose clock is not past the walk's end.
+        let beforeWalk = null;
+        try {
+            await page.goto(ORIGIN.site + '/');
+            const { url } = await launch(display, v.locale);
+            await page.evaluate((u) => window.__launch(u), url);
+            v.boot = await h.waitFor((l) => l.some((x) => x.d.message === 'gameLoaded'), 25000);
+            if (v.boot) {
+                await page.waitForTimeout(2000);
+                await h.wander();
+                // The page the bet is on (a game behind a menu): opened as the frame-size run opens it.
+                for (const s of hbtest?.open || []) { await h.act(s); await page.waitForTimeout(1500); }
+                await record(v, page, m);
+                if (!v.rounds && !v.hidden) await shotTo(page, shotName(v.id), 'boot', v.id);
+                if (hbtest && !v.rounds) {
+                    // One round as a player plays it, at this clock (the stake first:
+                    // the SDK panel's Bet is disabled and dimmed until there is one);
+                    // then the clock walked on through a day, the page scanned after
+                    // each jump.
+                    if (hbtest.stake) await h.act(hbtest.stake);
+                    if (await checkControl(v, h)) {
+                        const ends = h.roundEnds(await h.log());
+                        await h.act(hbtest.bet);
+                        for (let k = 0; k < (hbtest.then || []).length; k++) { await page.waitForTimeout(1500); await h.thenSteps(hbtest.then); }
+                        v.played = m.plays.length;
+                        v.settledOne = await h.waitFor((l) => h.roundEnds(l) > ends, 10000);
+                        if (!v.settledOne) v.errors.push('the round did not end within 10 s of the bet (no round-end from the game)');
+                    }
+                    if (fakeClock) {
+                        beforeWalk = await keepStorage(context);
+                        await leap(WALK.firstMs);
+                        await record(v, page, m);
+                        for (let k = 0; k < WALK.steps; k++) {
+                            await leap(WALK.stepMs);
+                            await record(v, page, m);
+                        }
+                        await syncClock(page);
+                        v.walked = true;
+                        // The hidden canary variant's late frame stands as the baseline's (lateFor).
+                        await shotTo(page, lateShotName(v.lateFor || v.id), 'late', v.lateFor || v.id);
+                    }
+                } else if (hbtest && v.rounds) {
+                    // The long session: fast rounds, the first as drawn (its play
+                    // names the mode and bet the game plays), then each forced to the
+                    // next row of that mode's table, game time driven by the clock so
+                    // an animation costs no waiting. A round that never ends, or a
+                    // bet control that never comes back, ends the session and is
+                    // reported. The SDK panel's Bet, when the game has one and the
+                    // test names another control, is pressed every other round: the
+                    // path players use is exercised too.
+                    v.settled = 0;
+                    if (hbtest.stake) await h.act(hbtest.stake);
+                    if (await checkControl(v, h)) {
+                        const f0 = h.gameFrame(hbtest.bet.page);
+                        const panel = f0 && hbtest.bet.selector !== 'hb-game [data-main]' && await f0.locator('hb-game [data-main]').count().catch(() => 0) ? { page: hbtest.bet.page, selector: 'hb-game [data-main]' } : null;
+                        v.pressed = { control: 0, panel: 0 };
+                        // A round (a feature with free spins, a big win's presentation)
+                        // may run this long in game time before it counts as stuck.
+                        // ENGINE_TRAVEL_REALTIME=1 lets game time run at real time
+                        // instead (for telling a game that hangs from a clock it
+                        // dislikes while working on the run; never the job's).
+                        const ROUND_GAME_MS = 180_000, STEP_MS = 1000, sessionStart = Date.now();
+                        v.budgetMs = fit.longBudgetMs;
+                        // In real time both clocks flow together and the offset stands; a jump moves it.
+                        const step = () => (process.env.ENGINE_TRAVEL_REALTIME === '1' ? page.waitForTimeout(STEP_MS) : jump(STEP_MS));
+                        let rows = null;
+                        forceLog = { asked: 0, applied: 0, refused: 0 };
+                        lastPlayBody = null;
+                        for (let i = 0; i < v.rounds; i++) {
+                            if (Date.now() - sessionStart > v.budgetMs) { v.outOfTime = true; break; }
+                            if (i === 1) {
+                                const played = lastPlayBody && typeof lastPlayBody.mode === 'string' ? { mode: lastPlayBody.mode, bet: lastPlayBody.bet } : null;
+                                rows = forcedRows(manifest, v.rounds, played);
+                                v.forced = rows !== null;
+                                v.forcedMode = played?.mode;
+                            }
+                            if (i && i % 20 === 0) await h.wander();
+                            forceNext = rows ? rows[i] : null;
+                            const usePanel = panel && i % 2 === 1;
+                            const which = usePanel ? panel : hbtest.bet;
+                            const f = h.gameFrame(which.page);
+                            const control = f && f.locator(which.selector).first();
+                            const ends = h.roundEnds(await h.log()), plays = m.plays.length;
+                            // Press until a bet leaves. The site's round-end can come before
+                            // the game is done showing the round (the shell's reveal deadline),
+                            // and a press meanwhile is the game's own hurry, so a press that
+                            // sends no bet is followed by another once the game is ready.
+                            let left = false;
+                            for (let k = 0; k < ROUND_GAME_MS / STEP_MS && !left; k++) {
+                                if (!!control && await control.isVisible().catch(() => false) && await control.isEnabled().catch(() => false)) {
+                                    try { await h.act(which); v.pressed[usePanel ? 'panel' : 'control']++; } catch { /* covered or moving: next step */ }
+                                } else if (k % 20 === 10 && f) {
+                                    // A screen that waits for a tap (a feature's intro, a win): tap the game.
+                                    await f.locator('body').click({ position: { x: 300, y: 300 }, timeout: 2000, force: true }).catch(() => {});
+                                }
+                                await step();
+                                left = m.plays.length > plays;
+                            }
+                            if (!left) { v.stuck = `round ${i + 1}: no bet left the game within ${ROUND_GAME_MS / 1000} s of game time${await screenSays(page)}`; break; }
+                            let done = h.roundEnds(await h.log()) > ends;
+                            for (let k = 0; k < ROUND_GAME_MS / STEP_MS && !done; k++) {
+                                await step();
+                                if (hbtest.then?.length) await h.thenSteps(hbtest.then);
+                                done = h.roundEnds(await h.log()) > ends;
+                            }
+                            if (!done) { v.stuck = `round ${i + 1} did not end within ${ROUND_GAME_MS / 1000} s of game time${await screenSays(page)}`; break; }
+                            v.settled++;
+                            // The two clocks read against each other every so often: the
+                            // server must not fall behind the game over a long session.
+                            if (v.settled % 25 === 0) await syncClock(page);
+                        }
+                        forceNext = null;
+                        v.forcedAsked = forceLog.asked; v.forcedApplied = forceLog.applied; v.forcedRefused = forceLog.refused;
+                        forceLog = null;
+                        v.played = m.plays.length;
+                        v.sessionMs = Date.now() - sessionStart;
+                        await jump(2000);
+                        await syncClock(page);
+                    }
+                }
+                await record(v, page, m);
+                if (v.rounds) await shotTo(page, shotName(v.id), 'boot', v.id);
+            }
+        } catch (e) {
+            v.broke = e.message.split('\n')[0].slice(0, 160);
+            // What is on the page now that the run broke: a password field, a
+            // credential prompt or a new frame shown just before the harness
+            // jammed (a click that could not land because an overlay took it)
+            // is the game's, and lands in the report beside the break, so the
+            // break is not the only thing the verdict sees. Bounded: a page
+            // that no longer answers does not hold the matrix.
+            let bound;
+            await Promise.race([record(v, page, m), new Promise((r) => { bound = setTimeout(r, 5000); })]).catch(() => {}).finally(() => clearTimeout(bound));
+        }
+        v.requests = [...new Set(m.outside)];
+        v.refused = [...new Set(m.refused)];
+        v.errors = [...new Set([...m.errors, ...v.errors])];
+        v.consoleErrors = [...new Set(m.consoleErrors)];
+        v.workers = [...new Set(m.workers)];
+        if (m.unshimmed()) v.unshimmedWorkers = m.unshimmed();
+        const dialogs = [...pageDialogs, ...m.dialogs()];
+        v.dialogs = dialogs.length;
+        v.dialogKinds = [...new Set(dialogs)];
+        v.rtc = m.rtcCount();
+        if (v.rtc) v.requests.push(`webrtc:${v.rtc} peer connection(s)`);
+        const kept = await keepStorage(context);
+        if (kept) v.storage = kept.keys;
+        // What this variant hands on: to the next variant, by the next one's
+        // clock (the storage before the walk unless that clock is past the
+        // walk's end); to the next run, what the last variant on the real
+        // clock left before any walk.
+        const left = kept || beforeWalk ? { at: v.at, before: beforeWalk || kept, walked: v.walked ? kept : null } : null;
+        const following = variants.slice(index + 1).find((x) => !x.skipped);
+        if (left) storage = handedStorage(left, following ? following.at : null) || storage;
+        if (left && v.clock === 'now') carriedOut = left.before;
+        v.ms = Date.now() - started;
+        await context.close().catch(() => {});
+    }
+    clockOffsetMs = 0;
+    travelling = false;
+    // What the last real-clock variant left, for the next run (the canary's next day).
+    if (STORAGE_FILE && carriedOut) {
+        try { writeFileSync(STORAGE_FILE, JSON.stringify({ origins: carriedOut.origins, keys: carriedOut.keys })); carried.kept = carriedOut.keys.length; } catch { carried.kept = -1; }
+    }
+    // The hidden variant (the canary's walked baseline) gave its late frame and is not reported.
+    const reported = variants.filter((v) => !v.hidden);
+    const baseline = reported.find((v) => v.id === 'base');
+    for (const v of reported) {
+        if (v === baseline) continue;
+        if (grids.boot[v.id] && grids.boot.base) v.visual = visualDifference(grids.boot[v.id], grids.boot.base);
+        if (grids.late[v.id] && grids.late.base) {
+            v.visualLate = visualDifference(grids.late[v.id], grids.late.base);
+            if (v.visualLate?.strong) v.lateShot = lateShotName(v.id);
+        }
+    }
+    // A late frame kept for a variant is kept for the baseline too: a reviewer
+    // asked to compare the late screenshots has both.
+    if (baseline && grids.late.base && reported.some((v) => v.visualLate?.strong)) baseline.lateShot = lateShotName('base');
+    // The canary's hidden walked baseline: when it did not play, the late frames
+    // were compared with nothing, and the report says so (the studio treats a
+    // comparison it asked for and did not get as a canary that did not run).
+    const walked = variants.find((v) => v.hidden && v.lateFor === 'base');
+    const walkedNot = walked && (walked.skipped || walked.broke || (!walked.boot ? 'the game did not boot' : '') || (!grids.late.base ? 'no late frame was taken' : ''));
+    // The canary: each variant against the screenshot of the same variant as
+    // the version was approved, so a change at the real date, which every
+    // variant of today shares, is still seen, and a variant whose approved
+    // look a reviewer accepted is still held to that look.
+    const baselines = opt('baselines', '');
+    if (baselines && existsSync(baselines)) {
+        const context = await browser.newContext({ viewport: { width: 1194, height: 900 } });
+        const page = await context.newPage();
+        await page.goto(ORIGIN.site + '/');
+        for (const v of reported) {
+            const file = join(baselines, shotName(v.id));
+            if (!grids.boot[v.id] || !existsSync(file)) continue;
+            const approved = await toGrid(page, readFileSync(file));
+            if (approved) v.visualVsApproved = visualDifference(grids.boot[v.id], approved);
+        }
+        await context.close().catch(() => {});
+    }
+    results.push(...checksFor(reported, baseline));
+    if (walkedNot) results.push({ size: 'baseday', rule: 'time-travel', ok: true, status: 'skipped', detail: `the walked baseline did not play (${walkedNot}): the late frames were not compared` });
+    timeTravel = { at: now.toISOString(), set: TRAVEL, rounds: TRAVEL_ROUNDS, variants: reported, ...(STORAGE_FILE ? { storage: carried } : {}) };
+}
+// Chrome's crash reporter can outlive Chrome and hold its pipe open, and then
+// close() never returns: the verdict does not wait on it.
+await Promise.race([Promise.all([...browsers.values()].map((b) => b.close())), new Promise((r) => setTimeout(r, 5000))]);
+servers.forEach((s) => s.close());
+
+const ok = results.every((r) => r.ok);
+if (args.includes('--json')) { console.log(JSON.stringify({ ok, slug: SLUG, sandbox: !UNSANDBOXED, softwareWebGL: SOFTWARE_WEBGL.length > 0, checks: results, ...(Object.keys(frameConsole).length ? { console: frameConsole } : {}), ...(timeTravel ? { timeTravel } : {}) })); process.exit(ok ? 0 : 1); }
+console.log(`${ok ? 'PASS' : 'FAIL'}  conformance ${SLUG}${TRAVEL ? ` time travel (${TRAVEL})` : ''}${UNSANDBOXED ? '  (Chrome sandbox OFF)' : ''}`);
+for (const r of results) console.log(`  ${r.status === 'skipped' ? 'skip' : r.status === 'warning' ? 'warn' : r.ok ? 'ok  ' : 'FAIL'} ${r.size.padEnd(8)} ${r.rule.padEnd(8)} ${r.detail}`);
+if (timeTravel) for (const v of timeTravel.variants) console.log(`       ${v.id.padEnd(8)} ${((v.ms || 0) / 1000).toFixed(1)}s${v.visual ? ` visual ${Math.round(v.visual.changed * 100)}%` : ''}${v.visualLate ? ` late ${Math.round(v.visualLate.changed * 100)}%` : ''}${v.rounds ? ` settled ${v.settled || 0}/${v.rounds}${v.forcedAsked ? ` forced ${v.forcedApplied || 0}/${v.forcedAsked}` : ''}` : ''}${v.betControl ? ` bet ${v.betControl.tag}${v.betControl.id ? '#' + v.betControl.id : ''} ${v.betControl.w}×${v.betControl.h}` : ''}${v.clockSkewMs ? ` skew ${v.clockSkewMs}ms` : ''}${v.clockDriftMs ? ` drift ${v.clockDriftMs}ms` : ''}${v.unshimmedWorkers ? ` unshimmed ${v.unshimmedWorkers}` : ''}${v.skipped ? ' skipped' : ''}`);
+if (timeTravel?.storage) console.log(`       storage  ${timeTravel.storage.from}: ${timeTravel.storage.keys} key(s) carried in${timeTravel.storage.kept !== undefined ? `, ${timeTravel.storage.kept} kept` : ''}`);
+process.exit(ok ? 0 : 1);