done-done-axi 0.3.0 → 0.3.2

package/dist/dom.js

@@ -3,8 +3,10 @@
 // (home.dark.390w.png -> home.dark.390w.dom.json), so a matrix cell's record carries its DONE_DONE_CELL suffix:
 //   {"url": "<page url>", "overflow": <true when content is wider than the viewport>, "overflowing": ["<element>", ...],
 //    "console_errors": ["<message>", ...], "failed_requests": [{"url": "<request url>", "status": <HTTP status, 0 when none>}],
-//    "squashed_text": [{"element": "<element>", "text": "<its text, ~40 chars>", "chars": <width>, "lines": <n>, "words": <n>}]}
-// squashed_text is optional, so a record written before it stays valid.
+//    "squashed_text": [{"element": "<element>", "text": "<its text, ~40 chars>", "chars": <width>, "lines": <n>, "words": <n>}],
+//    "clipped_text": [{"element": "<element>", "text": "<its text>", "by": "<the container that cuts it>"}],
+//    "cut_off": [{"element": "<element>", "text": "<its text>", "edges": ["left" | "right" | "top", ...]}]}
+// squashed_text, clipped_text and cut_off are optional, so a record written before them stays valid.
 import { readFileSync } from 'node:fs';
 import { basename } from 'node:path';
 // The measurement the recipe passes to its browser tool's eval, so no agent invents one: every visible element with its
@@ -27,8 +29,48 @@ export const SQUASHED_TEXT = `() => {
   }
   return out;
 }`.replace(/\s*\n\s*/g, ' ');
+// The rest of the look measurement, run in the page by `done-done look` next to SQUASHED_TEXT. A part of an element only
+// shows inside every ancestor that clips it (overflow other than visible; html and body clip as the viewport, so they are
+// the edges, not containers). Text is clipped when part of it shows and part runs past a hidden or clip container on an
+// axis without text-overflow: ellipsis or a line clamp; an element is cut off when part of what shows lies past the
+// left, right or top edge of the viewport (the page is at its top, so nothing above it can be scrolled to). Something
+// entirely outside its container or the viewport is hidden on purpose (a closed drawer, a visually hidden label), not cut;
+// a cut element's children are not listed again.
+// ponytail: the main frame only, and a transform or clip-path that hides part of a box is not seen; measure each frame
+// and clip-path when those show up.
+export const LOOK = `() => {
+  const vw = document.documentElement.clientWidth; const vh = document.documentElement.clientHeight; const out = { clipped_text: [], cut_off: [] }; const cut = new Set();
+  const name = (e) => e.tagName.toLowerCase() + (e.id ? '#' + e.id : e.classList[0] ? '.' + e.classList[0] : '');
+  const own = (e) => [...e.childNodes].filter((n) => n.nodeType === 3 && n.data.trim()).map((n) => n.data).join(' ').replace(/\\s+/g, ' ').trim().slice(0, 40);
+  const clips = (e) => { const out = []; for (let a = e; a && a !== document.body && a !== document.documentElement; a = a.parentElement) { const s = getComputedStyle(a); if (s.overflowX !== 'visible' || s.overflowY !== 'visible') { const r = a.getBoundingClientRect(); out.push({ a, s, l: r.left + a.clientLeft, t: r.top + a.clientTop, r: r.left + a.clientLeft + a.clientWidth, b: r.top + a.clientTop + a.clientHeight }); } } return out; };
+  const shows = (b) => b.r - b.l > 1 && b.b - b.t > 1;
+  for (const e of document.querySelectorAll('body *')) {
+    const s = getComputedStyle(e); const rect = e.getBoundingClientRect();
+    if (!e.getClientRects().length || s.visibility !== 'visible' || rect.width < 1 || rect.height < 1) continue;
+    const boxes = clips(e.parentElement);
+    const box = boxes.reduce((v, c) => ({ l: Math.max(v.l, c.l), t: Math.max(v.t, c.t), r: Math.min(v.r, c.r), b: Math.min(v.b, c.b) }), { l: rect.left, t: rect.top, r: rect.right, b: rect.bottom });
+    if (!shows(box)) continue;
+    const text = own(e);
+    const parent = [...cut].some((c) => c.contains(e));
+    const edges = [box.l < -1 && 'left', box.r > vw + 1 && 'right', box.t < -1 && 'top'].filter(Boolean);
+    if (edges.length && box.r > 0 && box.l < vw && box.b > 0 && box.t < vh && !parent) { cut.add(e); out.cut_off.push({ element: name(e), text, edges }); }
+    if (!text) continue;
+    const t = { l: Infinity, t: Infinity, r: -Infinity, b: -Infinity };
+    for (const n of e.childNodes) if (n.nodeType === 3 && n.data.trim()) { const g = document.createRange(); g.selectNodeContents(n); for (const q of g.getClientRects()) if (q.width) { t.l = Math.min(t.l, q.left); t.t = Math.min(t.t, q.top); t.r = Math.max(t.r, q.right); t.b = Math.max(t.b, q.bottom); } }
+    if (t.l === Infinity || t.t >= vh || t.b <= 0) continue;
+    for (const c of clips(e)) {
+      if (c.r - c.l <= 1 || c.b - c.t <= 1 || !(t.r > c.l && t.l < c.r && t.b > c.t && t.t < c.b) || !['hidden', 'clip'].some((v) => v === c.s.overflowX || v === c.s.overflowY)) continue;
+      const x = ['hidden', 'clip'].includes(c.s.overflowX) && c.s.textOverflow !== 'ellipsis' && (t.l < c.l - 1 || t.r > c.r + 1);
+      const y = ['hidden', 'clip'].includes(c.s.overflowY) && c.s.webkitLineClamp === 'none' && (t.t < c.t - 1 || t.b > c.b + 1);
+      if (x || y) { out.clipped_text.push({ element: name(e), text, by: c.a === e ? 'its own box' : name(c.a) }); break; }
+    }
+  }
+  return { overflow: document.documentElement.scrollWidth > vw, overflowing: [...document.querySelectorAll('body *')].filter((e) => e.getBoundingClientRect().right > vw + 1).slice(0, 10).map(name), ...out };
+}`.replace(/\s*\n\s*/g, ' ');
 const isMap = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 const strings = (a) => Array.isArray(a) && a.every((s) => typeof s === 'string');
+// An optional record list: absent, or every item has an element and text and passes `more`.
+const list = (a, more) => a === undefined || (Array.isArray(a) && a.every((q) => isMap(q) && typeof q.element === 'string' && typeof q.text === 'string' && more(q)));
 const badRegex = (s) => { try {
     new RegExp(s);
     return false;
@@ -71,13 +113,23 @@ export function domIssues(dom, capture) {
     }
     if (!isMap(r) || typeof r.url !== 'string' || typeof r.overflow !== 'boolean' || !strings(r.overflowing ?? []) || !strings(r.console_errors)
         || !Array.isArray(r.failed_requests) || !r.failed_requests.every((q) => isMap(q) && typeof q.url === 'string' && typeof q.status === 'number')
-        || (r.squashed_text !== undefined && !(Array.isArray(r.squashed_text) && r.squashed_text.every((q) => isMap(q) && typeof q.element === 'string' && typeof q.text === 'string' && [q.chars, q.lines, q.words].every((n) => typeof n === 'number')))))
-        return [`page-check record ${basename(path)} is not {url, overflow, overflowing, console_errors, failed_requests: [{url, status}], squashed_text: [{element, text, chars, lines, words}]}`];
+        || !list(r.squashed_text, (q) => [q.chars, q.lines, q.words].every((n) => typeof n === 'number'))
+        || !list(r.clipped_text, (q) => typeof q.by === 'string') || !list(r.cut_off, (q) => strings(q.edges)))
+        return [`page-check record ${basename(path)} is not {url, overflow, overflowing, console_errors, failed_requests: [{url, status}], squashed_text: [{element, text, chars, lines, words}], clipped_text: [{element, text, by}], cut_off: [{element, text, edges}]}`];
     const allowed = (list, s) => list.some((re) => new RegExp(re).test(s));
     return [
-        ...(dom.fail_on_overflow && r.overflow ? [`${r.url} overflows the viewport horizontally${r.overflowing?.length ? ` (${r.overflowing.join(', ')})` : ''}`] : []),
+        ...lookIssues({ ...r, overflow: dom.fail_on_overflow && r.overflow }),
         ...r.console_errors.filter((m) => !allowed(dom.allow_console, m)).map((m) => `${r.url} console error: ${m}`),
         ...r.failed_requests.filter((q) => (q.status === 0 || q.status >= 400) && !allowed(dom.allow_requests, q.url)).map((q) => `${r.url} request failed (${q.status || 'no response'}): ${q.url}`),
+    ];
+}
+// The look defects a page-check record shows: horizontal overflow, squashed, clipped and cut-off text or elements.
+export function lookIssues(r) {
+    const quoted = (t) => (t ? ` "${t}"` : '');
+    return [
+        ...(r.overflow ? [`${r.url} overflows the viewport horizontally${r.overflowing?.length ? ` (${r.overflowing.join(', ')})` : ''}`] : []),
         ...(r.squashed_text ?? []).map((q) => `${r.url} squashed text: ${q.element} "${q.text}" is ${q.chars} characters wide (lines ${q.lines}, words ${q.words})`),
+        ...(r.clipped_text ?? []).map((q) => `${r.url} clipped text: ${q.element}${quoted(q.text)} is cut by ${q.by}`),
+        ...(r.cut_off ?? []).map((q) => `${r.url} cut off: ${q.element}${quoted(q.text)} runs past the ${q.edges.join(' and ')} edge of the viewport`),
     ];
 }

package/dist/judge.js

@@ -1,9 +1,8 @@
-import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { accessSync, constants, existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { accessSync, constants, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { basename, delimiter, isAbsolute, join } from 'node:path';
-import { agentRun, askAgent, claudeBin, notStartable } from './agents.js';
+import { agentRun, askAgent, notStartable } from './agents.js';
 import { home, KEY_ROUTES, parseDuration, UsageError } from './config.js';
 import { downscaleToPng } from './media.js';
 const MAX_SIDE = 1280; // long edge sent to the model, in pixels
@@ -79,21 +78,6 @@ export function onPath(name) {
     }
     return '';
 }
-// Is claude signed in to this sign-in folder? Reads only the binary's non-secret auth status, as the kit does.
-// It runs in a scratch folder with a scratch HOME, so nothing else of the user's is read.
-export function claudeLoggedIn(bin, configDir) {
-    const scratch = mkdtempSync(join(tmpdir(), 'done-done-judge-'));
-    try {
-        const r = spawnSync(bin, ['--safe-mode', '--setting-sources', '', 'auth', 'status'], { cwd: scratch, encoding: 'utf8', timeout: 30_000, env: { HOME: scratch, PATH: process.env.PATH, CLAUDE_CONFIG_DIR: configDir } });
-        return r.status === 0 && JSON.parse(r.stdout).loggedIn === true;
-    }
-    catch {
-        return false;
-    }
-    finally {
-        rmSync(scratch, { recursive: true, force: true });
-    }
-}
 const KIT = '@byokit/decide@0.8.0';
 export const quote = (a) => (/^[\w@%+=:,./-]+$/.test(a) ? a : `'${a.replaceAll("'", `'\\''`)}'`);
 // The kit is an optional peer dependency, so a plain install stays small; it loads only when a capture needs judging.
@@ -102,7 +86,7 @@ async function kit() {
     if (major < 22 || (major === 22 && minor < 18))
         throw new UsageError(`judge: the judge needs Node 22.18 or later (this is ${process.versions.node})`, 'Install Node 22.18 or later, then re-run this command');
     try {
-        return { ...(await import('@byokit/decide/claude-code')), ...(await import('@byokit/decide')) };
+        return await import('@byokit/decide');
     }
     catch (e) {
         if (e.code !== 'ERR_MODULE_NOT_FOUND')
@@ -114,7 +98,7 @@ async function kit() {
     }
 }
 // The backend for one judge choice. It checks everything that needs no model call, so doctor can use it too.
-// record: where the answerer writes its agent call record (the claude-code route starts no agent of ours);
+// record: where each agent call writes its call record (the claude-code and answerer routes both run a real agent call);
 // questions: what each request asks, so the answerer can ask its agent for that answer shape; attempts: asks per request
 // when the answer is malformed.
 export async function backend(cfg, choice, record = () => '', questions = { relevance: QUESTION }, attempts = 1) {
@@ -126,57 +110,35 @@ export async function backend(cfg, choice, record = () => '', questions = { rele
             throw new UsageError(`judge: ${choice.route} needs your own API key in ${name}, which is not set`, `Export ${name} with your key, then re-run this command`);
         const { openai, resolve } = await kit();
         const ask = openai({ model: choice.model, key, supportsImages: true, maxRetries: 0 }).ask;
-        return { ask, resolve, lastError: () => '', signIn: '', signedIn: () => true, detail: `${name} is set and the judge kit is present` };
+        return { ask, resolve, lastError: () => '', detail: `${name} is set and the judge kit is present` };
     }
-    const timeoutMs = parseDuration(cfg.agent_timeout);
     const override = cfg.agent_path_override[choice.agent];
-    if (choice.route !== 'claude-code') {
-        const run = agentRun(cfg, choice.agent, choice.model);
-        const bin = run.path;
-        if (!bin)
-            throw new UsageError(`judge: ${notStartable(choice.agent, override)}`, `Install ${choice.agent}, or ask the user for another judge and save it: done-done init --judge <agent> --judge-model <model>`);
-        const { answerer, resolve } = await kit();
-        let lastError = '';
-        // The kit hides a failed call's message from the verdict, so the real cause is kept here for the result.
-        let requests = 0;
-        const ask = answerer({
-            name: choice.route,
-            leaves: true,
-            supportsImages: true,
-            ask: async (prompt, _signal, images) => {
-                lastError = '';
-                requests++;
-                const attached = images.map((img) => ({ name: `${img.id}.${img.mime.split('/')[1]}`, bytes: Buffer.from(img.dataUrl.slice(img.dataUrl.indexOf(',') + 1), 'base64') }));
-                // A tool-less call runs in its own scratch folder, so the CLI sees the attached capture and nothing else.
-                const a = await askAgent({ ...run, prompt, schema: answerSchema(questions), cwd: tmpdir(), tools: 'none', attempts, record: record(requests), images: attached });
-                lastError = a.ok ? '' : a.error ?? 'no answer';
-                if (!a.ok)
-                    throw new Error(lastError);
-                return JSON.stringify(a.answer);
-            },
-        }).ask;
-        return { ask, resolve, lastError: () => lastError, signIn: '', signedIn: () => true, detail: `${choice.agent} at ${bin} and the judge kit are present; it judges with every tool off` };
-    }
-    const bin = claudeBin(cfg);
-    const dir = cfg.judge.claude_code.config_dir;
-    const signIn = `CLAUDE_CONFIG_DIR=${dir} ${bin || 'claude'} auth login`;
-    const where = '~/.done-done/config.yaml';
+    const run = agentRun(cfg, choice.agent, choice.model);
+    const bin = run.path;
+    const claude = choice.agent === 'claude';
     if (!bin)
-        throw new UsageError(`judge: ${notStartable('claude', override)}`, override ? `Fix agent_path_override.claude in ${where}, or install Claude Code` : 'Install Claude Code, or set agent_path_override.claude to its absolute path');
-    if (!isAbsolute(dir))
-        throw new UsageError(`judge: judge.claude_code.config_dir must be an absolute path (got ${dir})`, `Fix judge.claude_code.config_dir in ${where}`);
-    if (!existsSync(dir))
-        throw new UsageError(`judge: no Claude sign-in at ${dir}`, `Sign in once with your Claude plan: mkdir -p ${dir} && ${signIn}`);
-    const { claudeCode, resolve } = await kit();
-    // The real folder, so a link to ~/.claude is refused here as a config error, not later per capture.
-    const real = realpathSync(dir);
-    try {
-        const ask = claudeCode({ bin, configDir: real, model: choice.model, timeoutMs }).ask;
-        return { ask, resolve, lastError: () => '', signIn, signedIn: () => claudeLoggedIn(bin, real), detail: `claude binary at ${bin}, a sign-in folder and the judge kit are present (login is checked only when a capture is judged)` };
-    }
-    catch (e) {
-        throw new UsageError(`judge: ${e.message} (claude ${bin}, judge.claude_code.config_dir ${dir})`, 'Set judge.claude_code.config_dir to a folder of its own, not your ~/.claude');
-    }
+        throw new UsageError(`judge: ${notStartable(choice.agent, override)}`, claude ? (override ? 'Fix agent_path_override.claude in ~/.done-done/config.yaml, or install Claude Code' : 'Install Claude Code, or set agent_path_override.claude to its absolute path') : `Install ${choice.agent}, or ask the user for another judge and save it: done-done init --judge <agent> --judge-model <model>`);
+    const { answerer, resolve } = await kit();
+    let lastError = '';
+    // The kit hides a failed call's message from the verdict, so the real cause is kept here for the result.
+    let requests = 0;
+    const ask = answerer({
+        name: choice.route,
+        leaves: true,
+        supportsImages: true,
+        ask: async (prompt, _signal, images) => {
+            lastError = '';
+            requests++;
+            const attached = images.map((img) => ({ name: `${img.id}.${img.mime.split('/')[1]}`, bytes: Buffer.from(img.dataUrl.slice(img.dataUrl.indexOf(',') + 1), 'base64') }));
+            // A tool-less call runs in its own scratch folder, so the CLI sees the attached capture and nothing else.
+            const a = await askAgent({ ...run, prompt, schema: answerSchema(questions), cwd: tmpdir(), tools: 'none', safeMode: true, attempts, record: record(requests), images: attached });
+            lastError = a.ok ? '' : a.error ?? 'no answer';
+            if (!a.ok)
+                throw new Error(lastError);
+            return JSON.stringify(a.answer);
+        },
+    }).ask;
+    return { ask, resolve, lastError: () => lastError, detail: claude ? `claude binary at ${bin} and the judge kit are present; it judges with your own claude sign-in` : `${choice.agent} at ${bin} and the judge kit are present; it judges with every tool off` };
 }
 // The image to send: the original when it already fits, else a downscaled PNG; a reason when neither works.
 export function prepare(c) {
@@ -189,7 +151,7 @@ export function prepare(c) {
 // One request about the named images: each question's answer after the floors, or why the judge did not answer.
 // An answer the kit cannot read (all-zero probabilities, an option left out) would abstain on every question as if the
 // judge were unsure, so it is asked once more, and one that still cannot be read is never kept.
-// A signed-out or non-subscription claude-code sign-in is a usage error, since no later request can do better.
+// A signed-out claude is a usage error, since no later request can do better.
 export async function askJudge(cfg, be, choice, state, questions, images) {
     try {
         const ask = () => be.ask(state, questions, AbortSignal.timeout(parseDuration(cfg.agent_timeout)), Object.entries(images).map(([id, i]) => ({ id, mime: i.mime, dataUrl: `data:${i.mime};base64,${i.bytes.toString('base64')}` })));
@@ -203,12 +165,10 @@ export async function askJudge(cfg, be, choice, state, questions, images) {
         return Object.fromEntries(Object.entries(questions).map(([k, q]) => [k, be.resolve(q, raw[k])]));
     }
     catch (e) {
-        const code = e.code;
         const why = be.lastError() || e.message;
-        // The kit reports a signed-out binary, a bad model id and a used-up plan all as 'process', so ask the binary which.
-        if (choice.route === 'claude-code' && (code === 'subscription_required' || (code === 'process' && !be.signedIn())))
-            throw new UsageError(`judge: ${why} (sign-in ${cfg.judge.claude_code.config_dir})`, `Sign in once with your Claude plan: ${be.signIn}`);
-        const hint = code === 'process' ? ` (check judge.model ${choice.model} and your plan's usage limit)` : Object.hasOwn(KEY_ROUTES, choice.route) ? ` (check judge.model ${choice.model} and the key in ${KEY_ROUTES[choice.route]})` : '';
+        if (choice.route === 'claude-code' && /not logged in/i.test(why))
+            throw new UsageError(`judge: claude is not signed in (${why})`, 'sign in with: claude auth login, then re-run this command');
+        const hint = choice.route === 'claude-code' ? ` (check judge.model ${choice.model} and your plan's usage limit)` : Object.hasOwn(KEY_ROUTES, choice.route) ? ` (check judge.model ${choice.model} and the key in ${KEY_ROUTES[choice.route]})` : '';
         return `the judge did not answer: ${why}${hint}`;
     }
 }

package/dist/look.js

@@ -0,0 +1,116 @@
+import { spawn } from 'node:child_process';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { UsageError } from './config.js';
+import { domRecord, LOOK, SQUASHED_TEXT } from './dom.js';
+import { findBin } from './agents.js';
+// done-done look: opens one page in headless Chrome at a phone viewport over the DevTools protocol (Node's own
+// WebSocket, no browser library), writes the screenshot and its page-check record next to it, and returns the record.
+// Chrome runs without its sandbox so it starts in containers and CI: point look at your own app, not untrusted sites.
+const BROWSERS = ['google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser', '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'];
+const WAIT = 30_000;
+export async function look(url, capture, width, height) {
+    const bin = process.env.DONE_DONE_CHROME ? findBin(process.env.DONE_DONE_CHROME) : BROWSERS.map(findBin).find(Boolean);
+    if (!bin)
+        throw new UsageError(`look needs Chrome or Chromium: ${process.env.DONE_DONE_CHROME ? `DONE_DONE_CHROME=${process.env.DONE_DONE_CHROME} is not an executable` : `none of ${BROWSERS.slice(0, 4).join(', ')} is on PATH`}`, 'Install Chrome or Chromium, or set DONE_DONE_CHROME to its binary');
+    const profile = mkdtempSync(join(tmpdir(), 'done-done-look-'));
+    const chrome = spawn(bin, ['--headless', '--no-sandbox', '--disable-gpu', '--hide-scrollbars', '--no-first-run', '--no-default-browser-check', `--user-data-dir=${profile}`, '--remote-debugging-port=0', `--window-size=${width},${height}`, 'about:blank'], { stdio: ['ignore', 'ignore', 'pipe'] });
+    let ws;
+    try {
+        // Chrome prints its DevTools address on stderr once it listens; it exiting first is the real cause, so show its words.
+        let said = '';
+        const port = await within(WAIT, 'Chrome did not start', (done, fail) => {
+            chrome.stderr.on('data', (d) => {
+                said += d;
+                const m = /DevTools listening on ws:\/\/[^:]+:(\d+)\//.exec(said);
+                if (m)
+                    done(m[1]);
+            });
+            chrome.on('error', (e) => fail(new Error(`Chrome (${bin}) did not start: ${e.message}`)));
+            chrome.on('exit', (code) => fail(new Error(`Chrome (${bin}) exited ${code} before it listened: ${said.trim().split('\n').slice(-3).join(' ') || 'no output'}`)));
+        });
+        const pages = (await (await fetch(`http://127.0.0.1:${port}/json/list`)).json());
+        const target = pages.find((p) => p.type === 'page');
+        if (!target)
+            throw new Error('Chrome opened no page to drive');
+        const sock = new WebSocket(target.webSocketDebuggerUrl);
+        ws = sock;
+        await within(WAIT, 'Chrome DevTools did not connect', (done, fail) => {
+            sock.onopen = () => done();
+            sock.onerror = () => fail(new Error('Chrome DevTools connection failed'));
+        });
+        let id = 0;
+        const waiting = new Map();
+        const on = new Map();
+        let failLoad;
+        const died = (why) => { for (const w of waiting.values())
+            w.fail(new Error(why)); waiting.clear(); failLoad?.(new Error(why)); };
+        sock.onclose = () => died(`the Chrome DevTools connection closed before ${url} was captured`);
+        chrome.on('exit', (code) => died(`Chrome (${bin}) exited ${code} before ${url} was captured`));
+        sock.onmessage = (m) => {
+            const msg = JSON.parse(String(m.data));
+            const w = waiting.get(msg.id);
+            if (w) {
+                waiting.delete(msg.id);
+                if (msg.error)
+                    w.fail(new Error(`Chrome DevTools: ${msg.error.message}`));
+                else
+                    w.done(msg.result);
+            }
+            else
+                on.get(msg.method)?.(msg.params);
+        };
+        const send = (method, params = {}) => new Promise((done, fail) => {
+            waiting.set(++id, { done, fail });
+            sock.send(JSON.stringify({ id, method, params }));
+        });
+        const evaluate = async (expression) => {
+            const r = await send('Runtime.evaluate', { expression, returnByValue: true, awaitPromise: true });
+            if (r.exceptionDetails)
+                throw new Error(`the look measurement threw in ${url}: ${r.exceptionDetails.exception?.description ?? r.exceptionDetails.text}`);
+            return r.result.value;
+        };
+        // What the page logged and fetched, for the record's console_errors and failed_requests.
+        const consoleErrors = [];
+        const failed = [];
+        const requests = new Map();
+        on.set('Runtime.consoleAPICalled', (p) => { if (p.type === 'error')
+            consoleErrors.push(p.args.map((a) => a.value ?? a.description ?? '').join(' ')); });
+        on.set('Runtime.exceptionThrown', (p) => consoleErrors.push(p.exceptionDetails.exception?.description ?? p.exceptionDetails.text));
+        on.set('Network.requestWillBeSent', (p) => requests.set(p.requestId, p.request.url));
+        on.set('Network.responseReceived', (p) => { if (p.response.status >= 400)
+            failed.push({ url: p.response.url, status: p.response.status }); });
+        on.set('Network.loadingFailed', (p) => { if (!p.canceled)
+            failed.push({ url: requests.get(p.requestId) ?? '', status: 0 }); });
+        for (const d of ['Page', 'Runtime', 'Network'])
+            await send(`${d}.enable`);
+        await send('Emulation.setDeviceMetricsOverride', { width, height, deviceScaleFactor: 1, mobile: true });
+        const loaded = within(WAIT, `${url} did not finish loading in ${WAIT / 1000}s`, (done, fail) => { failLoad = fail; on.set('Page.loadEventFired', () => done()); });
+        loaded.catch(() => { }); // a navigation error below is the cause to report, not this wait
+        const nav = await send('Page.navigate', { url });
+        if (nav.errorText)
+            throw new Error(`${url} did not load: ${nav.errorText}`);
+        await loaded;
+        // Web fonts change text widths, so measure once they are in and two frames have painted.
+        await evaluate('document.fonts.ready.then(() => new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r))))');
+        const record = { url, ...(await evaluate(`(${LOOK})()`)), console_errors: consoleErrors, failed_requests: failed, squashed_text: await evaluate(`(${SQUASHED_TEXT})()`) };
+        const shot = await send('Page.captureScreenshot', { format: 'png' });
+        writeFileSync(capture, Buffer.from(shot.data, 'base64'));
+        writeFileSync(domRecord(capture), `${JSON.stringify(record, null, 2)}\n`);
+        return record;
+    }
+    finally {
+        ws?.close();
+        chrome.kill('SIGKILL');
+        await new Promise((r) => (chrome.exitCode === null && chrome.signalCode === null ? chrome.once('exit', r) : r(null)));
+        rmSync(profile, { recursive: true, force: true });
+    }
+}
+// A promise that fails with `why` after `ms`; its timer alone never keeps the process running.
+function within(ms, why, run) {
+    return new Promise((done, fail) => {
+        const timer = setTimeout(() => fail(new Error(why)), ms).unref();
+        run((v) => (clearTimeout(timer), done(v)), (e) => (clearTimeout(timer), fail(e)));
+    });
+}