hbengine 0.2.3 → 0.4.0

package/engine-conformance/js-releases.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+// Adds rows to js-releases.json: the SHA-256 of every JavaScript file of a
+// library release as published on npm. Usage:
+//
+//   node packages/engine-conformance/js-releases.mjs PixiJS pixi.js@8.16.0 [pixi.js@8.15.0 …]
+//
+// The first argument is the library's name as KNOWN_LIBRARIES (scan.mjs)
+// spells it; each following one a package at an exact version. The tarball is
+// fetched from the registry, checked against the registry's integrity, and read
+// in memory; nothing in it is run. A file in a bundle's vendor/ whose bytes are
+// one of these is read as that library (scan.mjs, recognisedLibrary).
+import { createHash } from 'node:crypto';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { gunzipSync } from 'node:zlib';
+
+const FILE = new URL('./js-releases.json', import.meta.url);
+const REGISTRY = 'https://registry.npmjs.org';
+// The files a studio copies into vendor/: a release's browser builds (dist/,
+// build/, umd/, browser/, or the package's root) and three.js's loader glue
+// (examples/jsm/libs/), not its sources or modules.
+const SHIPPED = /^(?:(?:dist|build|umd|browser|examples\/jsm\/libs)\/(?:[^/]+\/)*)?[^/]+\.m?js$/i;
+
+// The regular files of a tar archive: { name, data }. ustar and GNU long names;
+// the package/ prefix npm puts on every entry is removed.
+export function tarFiles(buf) {
+    const out = [];
+    let longName = null;
+    for (let off = 0; off + 512 <= buf.length; ) {
+        const h = buf.subarray(off, off + 512);
+        if (h.every((b) => b === 0)) break;
+        const str = (a, n) => { const s = h.subarray(a, a + n); const z = s.indexOf(0); return s.subarray(0, z < 0 ? n : z).toString('utf8'); };
+        const size = parseInt(str(124, 12).trim() || '0', 8);
+        const type = String.fromCharCode(h[156] || 48);
+        const prefix = str(345, 155);
+        let name = longName ?? (prefix ? `${prefix}/${str(0, 100)}` : str(0, 100));
+        longName = null;
+        const data = buf.subarray(off + 512, off + 512 + size);
+        if (type === 'L') longName = data.toString('utf8').replace(/\0+$/, '');
+        else if (type === '0' || type === '\0') out.push({ name: name.replace(/^[^/]+\//, ''), data });
+        off += 512 + Math.ceil(size / 512) * 512;
+    }
+    return out;
+}
+
+async function release(spec) {
+    const at = spec.lastIndexOf('@');
+    if (at <= 0) throw new Error(`${spec}: give package@version`);
+    const pkg = spec.slice(0, at), version = spec.slice(at + 1);
+    const meta = await (await fetch(`${REGISTRY}/${pkg.replace('/', '%2f')}/${version}`)).json();
+    if (!meta?.dist?.tarball || !meta.dist.integrity?.startsWith('sha512-')) throw new Error(`${spec}: not on the registry`);
+    const tgz = Buffer.from(await (await fetch(meta.dist.tarball)).arrayBuffer());
+    if ('sha512-' + createHash('sha512').update(tgz).digest('base64') !== meta.dist.integrity) throw new Error(`${spec}: the tarball does not match the registry's integrity`);
+    return { pkg, version, files: tarFiles(gunzipSync(tgz)).filter((f) => SHIPPED.test(f.name)) };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const [library, ...specs] = process.argv.slice(2);
+    if (!library || !specs.length) { console.error('usage: js-releases.mjs <library> <package@version>…'); process.exit(2); }
+    const doc = JSON.parse(readFileSync(FILE, 'utf8'));
+    let added = 0;
+    for (const spec of specs) {
+        const r = await release(spec);
+        for (const f of r.files) {
+            const sha = createHash('sha256').update(f.data).digest('hex');
+            const row = doc.files[sha] ?? (doc.files[sha] = { library, file: f.name, bytes: f.data.length, releases: [] });
+            if (row.library !== library) throw new Error(`${sha}: already a file of ${row.library}`);
+            const release = `${r.pkg}@${r.version}`;
+            if (!row.releases.includes(release)) { row.releases.push(release); added++; }
+        }
+        console.log(`${spec}: ${r.files.length} files`);
+    }
+    doc.files = Object.fromEntries(Object.entries(doc.files).sort(([, a], [, b]) => a.library.localeCompare(b.library) || a.file.localeCompare(b.file) || a.releases[0].localeCompare(b.releases[0], undefined, { numeric: true })));
+    writeFileSync(FILE, JSON.stringify(doc, null, 2) + '\n');
+    console.log(`${added} rows or versions added`);
+}

package/engine-conformance/run.mjs

@@ -25,8 +25,11 @@
  *              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.
+ *              within it, at 720 high, at the shortest frame the site gives
+ *              (desktop 1194×582, a 1366×768 laptop; phone 364×440, a
+ *              375×667 phone between the site's header and bottom nav) and
+ *              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.
@@ -40,6 +43,10 @@
  *   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
+ *   sound      untouched, the game starts no sound (no media element plays
+ *              unmuted, no Web Audio source starts) before the player's first
+ *              tap; a control labelled mute or sound is looked for, and a
+ *              game without one is a warning for the reviewer, not a fail
  *
  * 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
@@ -124,15 +131,22 @@
  *   names an element whose text must carry a value of the round (data.0.side).
  */
 import http from 'node:http';
+import { fileURLToPath } from 'node:url';
 import { randomBytes } from 'node:crypto';
-import { readFileSync, existsSync, statSync, writeFileSync } from 'node:fs';
+import { readFileSync, readdirSync, 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 { GRID, STORAGE_FILE_MAX, WALK, carriedStorage, checksFor, checkerOnlySilent, clockFor, clockShim, clockTrap, controlProblem, credentialHits, fitsBudget, failureShotName, forcedRows, handedStorage, inputSignature, lateShotName, medianGrid, missedPress, shortVariantEstimate, shotName, startInstant, trapOptions, travelAnswer, travelClocks, variantsFor, visualDifference, withClocks, workerShim, OUTCOME_SHOTS, outcomeShotName, tierOf } from './travel.mjs';
+import { hintFor } from './hints.mjs';
 import { clockSource, siteJump, startClock } from './clock.mjs';
+import { appendDiagnostic } from './diagnostic-text.mjs';
+import { enableFeatures } from './chrome-flags.mjs';
+import { SOUND_CONTROL, soundControls, soundProbe, soundVerdict } from './sound.mjs';
+import { consoleRecorder, failureEvidence, handshakeProbe, runnerInfo } from './diagnostics.mjs';
+import { focusProbe, focusVerdict } from './focus.mjs';
 
 const args = process.argv.slice(2);
 const BUNDLE = args[0];
@@ -154,6 +168,11 @@ const TRAVEL_BUDGET_MS = Math.max(10, Number(opt('travel-budget', '240')) || 240
 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;
+// `--travel-clocks <json>`: a dated variant's instant, zone and language given by
+// the caller instead of travel.mjs's ({"plus7d": {"at": ISO, "tz", "locale"}}).
+// The check job draws its own for every upload, so the dates a game is played at
+// there are not the ones this file names (travel.mjs travelClocks checks them).
+const TRAVEL_CLOCKS = travelClocks(opt('travel-clocks', ''));
 // `--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
@@ -163,7 +182,7 @@ 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/
+const PKG = fileURLToPath(new URL('..', import.meta.url)); // 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: '' };
@@ -318,7 +337,15 @@ if (args.includes('--dev')) {
     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;
+// Without hbtest.json, a game that loads the SDK's Bet button (the platform's
+// /engine-sdk/bet.js, <hb-bet>) is pressed through it: the run finds the
+// button a player presses by itself, at the game's own stake.
+const usesBetButton = () => {
+    const files = (dir) => readdirSync(dir, { withFileTypes: true }).flatMap((d) => (d.isDirectory() ? files(join(dir, d.name)) : /\.(html?|m?js)$/i.test(d.name) ? [join(dir, d.name)] : []));
+    try { return files(BUNDLE).some((f) => /engine-sdk\/bet\.js/.test(readFileSync(f, 'utf8'))); } catch { return false; }
+};
+const hbtest = existsSync(join(BUNDLE, 'hbtest.json')) ? JSON.parse(readFileSync(join(BUNDLE, 'hbtest.json'), 'utf8'))
+    : usesBetButton() ? { bet: { page: 'index.html', selector: 'hb-bet' } } : null;
 const results = [];
 const check = (size, rule, ok, detail, status) => results.push({ size, rule, ok, detail, ...(status ? { status } : {}) });
 const { chromium } = await import('playwright-core');
@@ -342,7 +369,10 @@ const launchEnv = { PATH: process.env.PATH, HOME: process.env.HOME || '/tmp', LA
 // 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] });
+// A process per origin, so a game drawing in software cannot keep the shell
+// from answering the clock (chrome-flags.mjs).
+const FEATURES = [enableFeatures(process.env)];
+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', ...FEATURES, ...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;
@@ -354,6 +384,43 @@ try {
     process.exit(3);
 }
 
+// How fast this machine runs a game, measured the same way everywhere (the
+// upload's job, a studio's laptop): plain JavaScript, a 2D canvas, and WebGL
+// as this Chrome draws it (on the CPU here, SwiftShader). Recorded, not judged:
+// it is how a run on a studio's machine is held to the job's pace.
+async function machineSpeed(chrome) {
+    const page = await chrome.newPage();
+    try {
+        return await page.evaluate(() => {
+            const time = (f) => { const t = performance.now(); f(); return Math.round(performance.now() - t); };
+            const js = time(() => { let x = 0; for (let i = 0; i < 3e7; i++) x += Math.sqrt(i); return x; });
+            const c2 = document.createElement('canvas'); c2.width = 1194; c2.height = 720;
+            const g = c2.getContext('2d');
+            const d2 = time(() => { for (let i = 0; i < 200; i++) { g.fillStyle = `hsl(${i},60%,50%)`; g.fillRect(0, 0, 1194, 720); for (let k = 0; k < 50; k++) g.fillRect((k * 37 + i) % 1194, (k * 53) % 720, 64, 64); } g.getImageData(0, 0, 1, 1); });
+            const c3 = document.createElement('canvas'); c3.width = 1194; c3.height = 720;
+            const gl = c3.getContext('webgl');
+            let webgl = null;
+            if (gl) {
+                // A full-frame quad through a small shader, 60 times: what a frame of a 2D game costs, roughly.
+                const sh = (type, src) => { const o = gl.createShader(type); gl.shaderSource(o, src); gl.compileShader(o); return o; };
+                const prog = gl.createProgram();
+                gl.attachShader(prog, sh(gl.VERTEX_SHADER, 'attribute vec2 p;void main(){gl_Position=vec4(p,0.,1.);}'));
+                gl.attachShader(prog, sh(gl.FRAGMENT_SHADER, 'precision mediump float;uniform float t;void main(){vec2 u=gl_FragCoord.xy/700.;float v=0.;for(int i=0;i<8;i++)v+=sin(u.x*float(i)+t)*cos(u.y*float(i));gl_FragColor=vec4(v,u,1.);}'));
+                gl.linkProgram(prog); gl.useProgram(prog);
+                gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
+                gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1]), gl.STATIC_DRAW);
+                const at = gl.getAttribLocation(prog, 'p'); gl.enableVertexAttribArray(at); gl.vertexAttribPointer(at, 2, gl.FLOAT, false, 0, 0);
+                const ut = gl.getUniformLocation(prog, 't');
+                webgl = time(() => { for (let i = 0; i < 60; i++) { gl.uniform1f(ut, i); gl.drawArrays(gl.TRIANGLES, 0, 6); gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array(4)); } });
+            }
+            return { jsMs: js, canvasMs: d2, webglMs: webgl };
+        });
+    } finally {
+        await page.close().catch(() => {});
+    }
+}
+const bench = await machineSpeed(browser).catch(() => null);
+
 // 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).
@@ -362,6 +429,11 @@ const DISPLAYS = {
     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 } };
+// The shortest frame the site gives a game, at the frame's own width: on a
+// phone the frame is the room between the site's header and bottom nav (a
+// 375×667 iPhone with Safari's bars: 440 high); on a laptop the window caps it
+// (1366×768: 582 high). A game lays itself out in any frame from these up.
+const SHORT = { desktop: 582, phone: 440 };
 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,
@@ -435,6 +507,19 @@ const CLOCK = CLOCK_SOURCE ? { source: CLOCK_SOURCE, start: String(startClock) }
 // (given the fake clock's text when the variant travels, for the workers).
 const initScript = ({ travel, at }) => `(() => {
     const scope = globalThis;
+    // location.origin identifies the URL even when the sandbox's security
+    // origin is opaque. An about:blank/srcdoc child inherits its parent's.
+    const studioFrame = (() => {
+        let frame = scope;
+        for (let depth = 0; depth < 20; depth++) {
+            try {
+                if (frame.location.origin === ${JSON.stringify(ORIGIN.studio)}) return true;
+                if (frame === frame.parent) break;
+                frame = frame.parent;
+            } catch { break; }
+        }
+        return false;
+    })();
     const natives = (${String(clockShim)})(scope, { capture: true });
     let fake = null, jump = null;
     ${travel ? `{
@@ -445,6 +530,11 @@ const initScript = ({ travel, at }) => `(() => {
     }` : ''}
     const setAt = (${String(clockShim)})(scope, { natives, fake });
     (${String(INSTRUMENT_PAGE)})(scope, ${JSON.stringify(RUN_TOKEN)});
+    if (studioFrame) (${String(handshakeProbe)})(scope, ((say) => (key) => say(${JSON.stringify(RUN_TOKEN)} + ':init:' + key))(scope.console.debug.bind(scope.console)));
+    if (studioFrame) (${String(focusProbe)})(scope, ((say) => (key) => say(${JSON.stringify(RUN_TOKEN)} + ':focus:' + key))(scope.console.debug.bind(scope.console)));
+    // The sound rule is about the game: the site's page and the House Engine
+    // shell (whose loader plays its own short sound) are ours, not the studio's.
+    if (!${JSON.stringify([ORIGIN.site, ORIGIN.shell])}.includes(scope.location.origin)) (${String(soundProbe)})(scope, ((say) => (key) => say(${JSON.stringify(RUN_TOKEN)} + ':sound:' + key))(scope.console.debug.bind(scope.console)));
     (${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,
@@ -461,9 +551,9 @@ const listIn = async (page, expr) => (await Promise.all(studioFrames(page).map((
 // 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)));
+    const errors = [], outside = [], refused = [], plays = [], consoleErrors = [], dialogs = [], workers = [], canvasText = [], sounds = [], scriptFocus = [];
+    let reports = 0, rtc = 0, unshimmed = 0, initSeen = 0;
+    page.on('pageerror', (e) => appendDiagnostic(errors, e.message));
     page.on('console', (m) => {
         const text = m.text();
         if (text.startsWith(RUN_TOKEN + ':')) {
@@ -475,12 +565,15 @@ function instrument(page) {
             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
+            else if (kind === 'sound') sounds.push(payload);
+            else if (kind === 'init') initSeen++;
+            else if (kind === 'focus') scriptFocus.push(payload);
+            else if (kind === 'uncaught') appendDiagnostic(errors, payload); // 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));
+        else appendDiagnostic(consoleErrors, text);
     });
     page.on('request', (r) => {
         const u = r.url();
@@ -495,7 +588,7 @@ function instrument(page) {
         }
         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 };
+    return { errors, outside, refused, plays, consoleErrors, workers, canvasText, sounds, scriptFocus, initReceived: () => initSeen > 0, 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.
@@ -521,11 +614,29 @@ function helpers(page) {
         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) => {
+    // The round can end between the look and the press (a ladder's Cash out
+    // turns off with it): that press is let go and the caller looks again.
+    // A control that will not take the click (covered, moving) breaks the
+    // run, with its evidence, after `tries` misses of that step in a row: one
+    // by default (the frame sizes, the short variants), more for the long
+    // session's loop (travel.mjs missedPress). Its control going off or away,
+    // or a press that lands, starts the count again.
+    const missed = new Map();
+    const thenSteps = async (steps, tries = 1) => {
         for (const s of steps || []) {
+            const key = s.page + ' ' + s.selector;
             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 on = async () => !!control && await control.isVisible().catch(() => false) && await control.isEnabled().catch(() => false);
+            if (!await on()) { missed.delete(key); continue; }
+            try {
+                await press(control);
+                missed.delete(key);
+            } catch (e) {
+                const r = missedPress({ on: await on(), covered: /intercepts pointer events/.test(String(e && e.message)), missed: missed.get(key) || 0, tries });
+                if (r.verdict === 'break') { missed.delete(key); throw e; }
+                if (r.missed) missed.set(key, r.missed); else missed.delete(key);
+            }
         }
     };
     const roundEnds = (l) => l.filter((m) => m.d.type === 'housebets-game-round-end').length;
@@ -550,17 +661,22 @@ function helpers(page) {
 // 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 = {};
+const diagnostics = {};
 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 } });
+    try {
+    const started = Date.now();
     const page = await context.newPage();
+    const consoleLines = consoleRecorder(page, RUN_TOKEN);
+    const evidence = () => failureEvidence(page, { console: consoleLines, runner: runnerInfo(browser), started, shot: `${size}.png`, shotFile: join(opt('shots', process.cwd()), `conformance-${SLUG}-${size}.png`), log: () => page.evaluate(() => window.__log || []), initReceived: initReceived() });
     await page.addInitScript(initScript({ travel: false }));
-    const { errors, outside, refused, plays, reports, rtcCount, consoleErrors } = instrument(page);
+    const { errors, outside, refused, plays, reports, rtcCount, consoleErrors, sounds, initReceived, scriptFocus } = 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);
+    const { log, waitFor, act, gameFrame, roundEnds, thenSteps } = helpers(page);
     await page.goto(ORIGIN.site + '/');
     const { url } = await launch(display);
     await page.evaluate((u) => window.__launch(u), url);
@@ -568,11 +684,11 @@ for (const [size, width] of TRAVEL ? [] : [['desktop', 1194], ['phone', 364]]) {
     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');
+        for (const rule of ['idle', 'focus', 'sound', '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();
+        diagnostics[size] = await evidence();
         continue;
     }
     // Nobody touches the game for a while: it must not bet on its own. A
@@ -580,6 +696,14 @@ for (const [size, width] of TRAVEL ? [] : [['desktop', 1194], ['phone', 364]]) {
     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`);
+    // Nothing has been touched yet: any sound so far started before the
+    // player's first tap. A mute control is the game's to give (the shell has
+    // none); one is looked for by its label, and its absence is a warning.
+    {
+        const control = (await Promise.all(studioFrames(page).map((f) => f.evaluate(soundControls, SOUND_CONTROL.source).catch(() => [])))).flat()[0];
+        const v = soundVerdict(sounds, control);
+        check(size, 'sound', v.ok, v.detail, v.status);
+    }
 
     // fit: every page of the game at its frame size, now and after each page
     // the test opens
@@ -587,6 +711,9 @@ for (const [size, width] of TRAVEL ? [] : [['desktop', 1194], ['phone', 364]]) {
     // 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();
+    // What the short frame alone found (364×440, 1194×582): a warning for now,
+    // while studios lay their games out for the site's shorter frames.
+    const shortOnly = new Set();
     const measure = async (at = '') => {
         for (const f of studioFrames(page)) {
             const d = await f.evaluate(() => {
@@ -641,6 +768,13 @@ for (const [size, width] of TRAVEL ? [] : [['desktop', 1194], ['phone', 364]]) {
     };
     await measure();
 
+    // focus: nothing has been pressed yet (the idle wait, sound and fit press
+    // nothing), so every focus said so far was the script's own. Read here, at
+    // the last moment before the first click, so a timer's focus counts too.
+    // A warning for now, not a fail: some frameworks focus the window at start-up
+    // by default (Phaser's autoFocus), and no live game has been measured against it yet.
+    { const v = focusVerdict(scriptFocus); check(size, 'focus', true, v.detail, v.ok ? undefined : 'warning'); }
+
     // 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 {
@@ -654,9 +788,7 @@ for (const [size, width] of TRAVEL ? [] : [['desktop', 1194], ['phone', 364]]) {
             // `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);
+                await thenSteps([s]);
             }
             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.
@@ -723,7 +855,7 @@ for (const [size, width] of TRAVEL ? [] : [['desktop', 1194], ['phone', 364]]) {
             // 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');
+                check(size, 'outage', true, 'skipped: this engine 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');
@@ -736,24 +868,36 @@ for (const [size, width] of TRAVEL ? [] : [['desktop', 1194], ['phone', 364]]) {
                 }
             }
         } catch (e) {
+            diagnostics[size] = await evidence();
             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 on a short screen: the same frame, less high.
+    const short = SHORT[size];
+    await page.evaluate((h) => { document.getElementById('c').style.height = h + 'px'; }, short);
+    await page.waitForTimeout(1500);
+    const before = new Set(scrolling);
+    await measure(`${width}×${short}: `);
+    for (const x of scrolling) if (!before.has(x)) { scrolling.delete(x); shortOnly.add(x); }
     // 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}`);
+    if (scrolling.size) check(size, 'fit', false, 'does not fit: ' + [...scrolling].join('; '));
+    else if (shortOnly.size) check(size, 'fit', true, `fits ${width}×720 and fullscreen ${full.width}×${full.height}; not yet the shorter ${width}×${short} frame the site gives on smaller screens: ` + [...shortOnly].join('; '), 'warning');
+    else check(size, 'fit', true, `fits ${width}×720, ${width}×${short} 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);
+        // Keep the first failure's image; the later fullscreen measurement
+        // must not replace the state diagnostics[size] describes.
+        if (!diagnostics[size]?.screenshot) 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.
@@ -761,6 +905,9 @@ for (const [size, width] of TRAVEL ? [] : [['desktop', 1194], ['phone', 364]]) {
         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);
     }
+    } finally {
+        await context.close().catch(() => {});
+    }
 }
 
 // ---- time travel: the matrix of clocks, zones and languages ------------------------------
@@ -779,7 +926,7 @@ 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 variants = withClocks(variantsFor(TRAVEL, now), TRAVEL_CLOCKS, now).filter((v) => !TRAVEL_ONLY || TRAVEL_ONLY.includes(v.id)).map((v) => ({ ...v, rounds: v.rounds ? TRAVEL_ROUNDS : undefined, at: v.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());
@@ -961,18 +1108,29 @@ if (TRAVEL) {
         // 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
+        // not follow. A frame that did not answer within 60 s is a frame whose
         // clock did not move: the variant breaks rather than judging a game on
-        // clocks that disagree.
+        // clocks that disagree. An answer after 10 s is the job's software
+        // graphics behind a game that draws every frame (the answer waits for
+        // the frames queued before it), not the game's clock: the variant goes
+        // on and says how long it waited (slowJumpMs).
         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 started = Date.now();
+            const answer = page.evaluate(siteJump, [RUN_TOKEN, op, ms]);
+            const within = (limit) => Promise.race([answer, new Promise((_, reject) => { timer = setTimeout(() => reject(new Error('timeout')), limit); })]).finally(() => clearTimeout(timer));
+            const r = await within(10000).catch(() => within(50000)).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}`);
+                // Every window of the game answered and only ours did not (the
+                // site's page, the shell): the checker's own lag, said first,
+                // since the line is cut at 160 characters. Still a break: a
+                // game must not win a skipped variant by slowing the checker.
+                const ours = tally && checkerOnlySilent(page.frames().map((f) => ({ url: f.url(), game: isGameFrame(f) })), tally.from, tally.posted);
+                if (ours) throw new Error(`the checker's own page did not keep up with the clock (${op} ${ms} ms) within 60 s, while every window of the game did (${tally.from.length} of ${tally.posted} answered, silent: ${ours.join(' ')})`);
+                throw new Error(`the fake clock did not move (${op} ${ms} ms) in every frame within 60 s${tally ? `: ${tally.from.length} of ${tally.posted} window(s) answered (${tally.from.join(', ')})` : ''}: ${e.message}`);
             });
+            const waited = Date.now() - started;
+            if (waited > 10000) v.slowJumpMs = Math.max(v.slowJumpMs || 0, waited);
             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));
@@ -997,6 +1155,7 @@ if (TRAVEL) {
         const pageDialogs = [];
         page.on('dialog', (d) => { pageDialogs.push(d.type()); d.dismiss().catch(() => {}); });
         const m = instrument(page);
+        const consoleLines = consoleRecorder(page, RUN_TOKEN);
         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.
@@ -1101,11 +1260,23 @@ if (TRAVEL) {
                             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);
+                                if (hbtest.then?.length) await h.thenSteps(hbtest.then, 3);
                                 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 first round of each new forced row (a loss, then each pay
+                            // tier): its screen kept, with what the maths pays for it, for
+                            // the reviewer's "what the screen shows matches what was paid".
+                            if (rows && i >= 1 && (v.outcomes ||= []).length < OUTCOME_SHOTS && !v.outcomes.some((o) => o.row === rows[i])) {
+                                const name = outcomeShotName(v.outcomes.length + 1);
+                                const png = await page.screenshot().catch(() => null);
+                                if (png) {
+                                    writeFileSync(join(shotsDir, name), png);
+                                    const played = lastPlayBody && typeof lastPlayBody.mode === 'string' ? { mode: lastPlayBody.mode, bet: lastPlayBody.bet } : null;
+                                    v.outcomes.push({ row: rows[i], multBp: tierOf(manifest, played, rows[i]), mode: played?.mode || '', bet: played?.bet || '', shot: name });
+                                }
+                            }
                             // 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);
@@ -1120,7 +1291,11 @@ if (TRAVEL) {
                     }
                 }
                 await record(v, page, m);
-                if (v.rounds) await shotTo(page, shotName(v.id), 'boot', v.id);
+                // The picture after the session is the reviewer's, not a verdict:
+                // the session is over, and a capture the job's software renderer
+                // could not make in 30 s is reported as missing (a warning that
+                // names both causes) instead of breaking the session.
+                if (v.rounds) await shotTo(page, shotName(v.id), 'boot', v.id).catch((e) => { v.shotMissing = e.message.split('\n')[0].slice(0, 160); });
             }
         } catch (e) {
             v.broke = e.message.split('\n')[0].slice(0, 160);
@@ -1133,6 +1308,11 @@ if (TRAVEL) {
             let bound;
             await Promise.race([record(v, page, m), new Promise((r) => { bound = setTimeout(r, 5000); })]).catch(() => {}).finally(() => clearTimeout(bound));
         }
+        if (!v.boot || v.broke) {
+            const shot = failureShotName(v.id);
+            v.diagnostics = await failureEvidence(page, { console: consoleLines, runner: runnerInfo(await browserFor(v.tz)), started, shot, shotFile: join(shotsDir, shot), log: h.log, initReceived: m.initReceived() });
+            if (v.diagnostics.screenshot) v.failureShot = shot;
+        }
         v.requests = [...new Set(m.outside)];
         v.refused = [...new Set(m.refused)];
         v.errors = [...new Set([...m.errors, ...v.errors])];
@@ -1209,9 +1389,16 @@ await Promise.race([Promise.all([...browsers.values()].map((b) => b.close())), n
 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' : ''}`);
+const incomplete = results.filter((r) => r.status === 'skipped').map((r) => ({ size: r.size, rule: r.rule, detail: r.detail }));
+for (const v of timeTravel?.variants || []) if (v.rounds && v.boot && !v.skipped && !v.broke && !v.stuck && (v.settled || 0) < v.rounds) incomplete.push({ size: v.id, rule: 'time-travel', detail: `${v.settled || 0} of ${v.rounds} rounds completed` });
+const coverage = { complete: incomplete.length === 0, incomplete };
+// What each failure means and what to change (hints.mjs): in the report the
+// dashboard shows, and under the line here.
+for (const r of results) { const hint = hintFor(r); if (hint) r.hint = hint; }
+if (args.includes('--json')) { console.log(JSON.stringify({ ok, slug: SLUG, sandbox: !UNSANDBOXED, softwareWebGL: SOFTWARE_WEBGL.length > 0, checks: results, ...(Object.keys(diagnostics).length ? { diagnostics } : {}), ...(bench ? { bench } : {}), ...(Object.keys(frameConsole).length ? { console: frameConsole } : {}), ...(timeTravel ? { timeTravel } : {}) })); process.exit(ok ? 0 : 1); }
+if (bench) console.log(`machine: JavaScript ${bench.jsMs} ms, 2D canvas ${bench.canvasMs} ms, WebGL ${bench.webglMs ?? '-'} ms (the upload's job is the yardstick)`);
+console.log(`${ok ? (coverage.complete ? 'PASS' : 'PASS WITH INCOMPLETE COVERAGE') : '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}${r.hint ? `\n         → ${r.hint}` : ''}`);
+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.slowJumpMs ? ` slow jump ${(v.slowJumpMs / 1000).toFixed(1)}s` : ''}${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);