@junixlabs/uxcli 0.1.1 → 0.2.0

package/README.md

@@ -2,7 +2,7 @@
 
 `uxcli` measures a running UI against its design commitments. Built for AI coding agents that need to verify the frontend they just wrote.
 
-**Status:** early. Three flow probes (WCAG 3.3.4, 3.3.7, 3.2.3), a gate that proves each probe can fail, a verdict card, and a second reader. On npm as `@junixlabs/uxcli`; the command is `uxcli`.
+**Status:** early. Three flow probes (WCAG 3.3.4, 3.3.7, 3.2.3), three single-screen probes (2.4.7, 1.4.12, 1.4.3), a gate that proves each probe can fail and can pass, a verdict card, and a second reader. On npm as `@junixlabs/uxcli`; the command is `uxcli`.
 
 **Core rule: no commitment, no verdict.** Every finding cites the commitment it enforces: W3C's, yours, or none. Where no one has committed, `uxcli` says nothing.
 
@@ -19,16 +19,17 @@ Node 20+.
 ```
 npm install -g @junixlabs/uxcli
 npx playwright-core install chromium-headless-shell   # once; or set UXCLI_CHROME to a Chromium binary
-uxcli run journey.json                                # verdict card
+uxcli run journey.json                                # verdict card for a flow
 uxcli run journey.json --json                         # full evidence packet
+uxcli run https://example.org/login                   # verdict card for one screen; --state=FILE for a signed-in page (Playwright storageState)
 uxcli run journey.json --refute                       # a fresh second reader checks each fail from the screenshots (needs the claude CLI, or set UXCLI_REFUTER)
 uxcli gate                                            # every probe must fail on its seeded fixture and stay silent on the clean twin
-uxcli why 3.3.7                                       # the probe's definition
+uxcli why 3.3.7                                       # the probe's definition (also why 2.4.7, why contrast)
 ```
 
 `npx @junixlabs/uxcli <command>` works without the global install. To hack on it: `git clone https://github.com/junixlabs/uxcli && cd uxcli && npm install`, then `node bin/uxcli.js` in place of `uxcli`. An example journey is in `examples/sylius-guest-checkout.json`.
 
-A journey is the commitment: the steps of one process, which step commits, and what the human declares (`sameProcess`, `checkedPass`, `reversible`). See `test/journeys/checkout.json`.
+A journey is the commitment: the steps of one process, which step commits, and what the human declares (`sameProcess`, `checkedPass`, `reversible`). See `test/journeys/checkout.json`. Selectors are Playwright locator strings. Omit `url` for a page reached by the previous step's submit. A step whose `url` differs from the page the previous step left is opened directly and starts a new process segment.
 
 ## How it works
 
@@ -36,11 +37,12 @@ The one input the machine cannot derive, the journey, is written by a human. Eve
 
 | Available | Planned |
 |---|---|
-| `run <journey>` measure a flow; card by default, `--json`, `--refute` | `run <url>` single-screen probes (focus-visible, text-spacing, contrast) |
-| `gate` run every probe's falsification pair | `principles` skill: what the product commits to, as thresholds |
-| `why <rule>` the probe's definition | `diff a b --gate` drift between builds |
+| `run <journey>` measure a flow; card by default, `--json`, `--refute`, `--var=k=v` | `principles` skill: what the product commits to, as thresholds |
+| `run <url>` measure one screen: focus-visible, text-spacing, contrast (axe-core, pinned); `--state` | `diff a b --gate` drift between builds |
+| `gate` run every probe's falsification pair | |
+| `why <rule>` the probe's definition | |
 
-Every probe ships with a pair of fixtures: one where it must fail, one where it must stay silent. A probe without that pair cannot say `fail`. `gate` enforces it.
+Every probe ships with a pair of fixtures: one where it must fail, one where it must pass. A probe without that pair cannot say `fail`. `gate` enforces it. Exit codes: 0 no fail, 2 at least one fail, 1 the run could not be carried out.
 
 What comes next, and in what order, is in [ROADMAP.md](ROADMAP.md).
 
@@ -54,24 +56,6 @@ What comes next, and in what order, is in [ROADMAP.md](ROADMAP.md).
 - Every exception ships with a coverage test.
 - No score, no summary line, no conformance claim.
 
-## Evidence so far
-
-Method checked against public test suites and unseen sites before product code; the flow probes checked on a seeded fixture, on real apps, and on agents.
-
-| Probe | Suite | Result |
-|---|---|---|
-| focus-visible | W3C ACT, 7 cases | 7/7 |
-| focus-visible | GOV.UK, 22 pages, 1,244 focusable elements | 0 false fails |
-| text-spacing (locked) | W3C ACT, 62 cases | 62/62, after 3 definition fixes |
-| contrast (delegated to axe-core) | W3C ACT, 32 cases | 24/32, 0 false positives, 7 `cantTell` |
-| focus-visible, text-spacing | 20 unseen pages, 5 sites, definitions frozen and hashed first | 0 false fails |
-| flow probes 3.3.4 / 3.3.7 / 3.2.3 | seeded checkout fixture, probe frozen before the fixture existed | 3/3 caught, silent on the clean twin |
-| flow probes | 10 flows on 4 real apps the probes had never seen | 0 false fails; one real 3.3.7 defect found by hand that the probe then missed, now caught |
-| verdict card vs JSON packet | 40 fresh agent sessions fixing the seeded fixture | 0 reported done with a check failing; card sessions edited only the cited file 19/20, JSON 7/20 |
-| planted wrong `fail` | 20 agent sessions on the clean fixture | 2/10 rewrote the site to satisfy it without the tool; 0/10 with the tool in hand |
-
-Not yet shown: precision on more than 10 real flows; recall on defects seeded into real pages by someone who does not tune the probes; any of this on a second model.
-
 ## Non-goals
 
 Conformance certification. Visual regression. Scores. Design critique.

package/bin/uxcli.js

@@ -1,25 +1,37 @@
 #!/usr/bin/env node
 // uxcli — UI/UX review for coding agents. No commitment, no verdict.
-import fs from 'node:fs'; import path from 'node:path'; import { fileURLToPath } from 'node:url';
+import fs from 'node:fs'; import path from 'node:path'; import { fileURLToPath, pathToFileURL } from 'node:url';
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const [cmd, ...rest] = process.argv.slice(2);
 const flags = new Set(rest.filter(a => a.startsWith('--') && !a.includes('='))); const args = rest.filter(a => !a.startsWith('--'));
 const opt = k => (rest.find(a => a.startsWith('--' + k + '=')) || '').split('=').slice(1).join('=') || null;
+const vars = Object.fromEntries(rest.filter(a => a.startsWith('--var=')).map(a => a.slice(6).split('=')).map(([k, ...v]) => [k, v.join('=')]));
 const usage = `usage:
-  uxcli run <journey.json> [--json] [--out=DIR] [--refute]
+  uxcli run <journey.json> [--json] [--out=DIR] [--refute] [--var=k=v ...]
       measure one flow; card by default, --json for the evidence packet; screenshots for fails in DIR (default .uxcli/<journey>);
-      --refute asks a fresh second reader (UXCLI_REFUTER, default claude -p) to confirm or dispute each fail from the images alone
+      --var substitutes {{k}} in the journey; --refute asks a fresh second reader (UXCLI_REFUTER, default claude -p) to confirm or dispute each fail from the images alone
+  uxcli run <url> [--json] [--state=FILE]
+      measure one screen: focus-visible (2.4.7), text-spacing (1.4.12), contrast (1.4.3, axe-core); --state is a Playwright storageState file for signed-in pages
   uxcli gate                          run every probe's falsification pair; exit 1 unless all hold
-  uxcli why <rule>                    print a probe's definition (e.g. why 3.3.7, why redundant-entry)
+  uxcli why <rule>                    print a probe's definition (e.g. why 3.3.7, why redundant-entry, why 2.4.7)
+exit: 0 no fail · 2 at least one fail · 1 the run could not be carried out
 browser: playwright-core; set UXCLI_CHROME to a Chromium binary if none is installed for playwright.`;
+const isUrl = s => /^https?:\/\//i.test(s) || /\.html?$/i.test(s) || s.startsWith('file:');
 try {
-  if (cmd === 'run' && args[0]) {
+  if (cmd === 'run' && args[0] && isUrl(args[0])) {
+    const { runPage } = await import('../src/page.js'); const { card } = await import('../src/card.js');
+    const url = /^(https?|file):/i.test(args[0]) ? args[0] : pathToFileURL(path.resolve(args[0])).href;
+    const result = await runPage(url, { state: opt('state') });
+    console.log(flags.has('--json') ? JSON.stringify(result, null, 1) : card(result));
+    process.exit(result.error ? 1 : result.probes.some(p => p.verdict === 'fail') ? 2 : 0);
+  } else if (cmd === 'run' && args[0]) {
     const { loadJourney } = await import('../src/journey.js'); const { runJourney } = await import('../src/run.js'); const { card } = await import('../src/card.js');
     const outDir = opt('out') || path.join('.uxcli', path.basename(args[0], '.json'));
-    const result = await runJourney(loadJourney(path.resolve(args[0])), { outDir });
+    const result = await runJourney(loadJourney(path.resolve(args[0]), vars), { outDir });
     if (flags.has('--refute')) { const { refute } = await import('../src/refute.js'); for (const p of result.probes) if (p.verdict === 'fail') p.refute = refute(p); }
     console.log(flags.has('--json') ? JSON.stringify(result, null, 1) : card(result));
-    process.exit(result.probes.some(p => p.verdict === 'fail') ? 2 : 0);
+    const couldNotRun = result.steps.some(s => s.error) || result.steps.length < result.stepCount;
+    process.exit(result.probes.some(p => p.verdict === 'fail') ? 2 : couldNotRun ? 1 : 0);
   } else if (cmd === 'gate') {
     const { gate } = await import('../src/gate.js'); process.exit((await gate()) ? 0 : 1);
   } else if (cmd === 'why' && args[0]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junixlabs/uxcli",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "UI/UX review for coding agents. No commitment, no verdict.",
   "license": "MIT",
   "repository": {
@@ -38,6 +38,7 @@
     "test": "node bin/uxcli.js gate"
   },
   "dependencies": {
+    "axe-core": "4.13.0",
     "playwright-core": "^1.58.0"
   }
 }

package/src/card.js

@@ -1,18 +1,28 @@
 // The verdict card: what the working agent reads. Low hundreds of tokens; --json carries the evidence.
-const V = v => ({ pass: 'PASS', fail: 'FAIL', unmeasurable: 'UNMEASURABLE', 'not-applicable': 'N/A', 'not-committed': 'NOT-COMMITTED', blocked: 'BLOCKED' }[v] || String(v).toUpperCase());
+const V = v => ({ pass: 'PASS', fail: 'FAIL', finding: 'FINDING', unmeasurable: 'UNMEASURABLE', 'not-applicable': 'N/A', 'not-committed': 'NOT-COMMITTED' }[v] || String(v).toUpperCase());
 const short = s => { s = String(s); if (s.startsWith('t:')) return s.slice(2); s = s.slice(2); const i = s.lastIndexOf('/'); return (i >= 0 ? s.slice(i + 1) : s).slice(0, 60) || s.slice(0, 60); };
+const name = p => p.probe.replace(/^(flow|page)\./, '');
+const reason = p => (p.why || '').slice(0, 120);
+
 export function card(result) {
+  return result.url ? pageCard(result) : flowCard(result);
+}
+
+function flowCard(result) {
   const L = [`uxcli run · ${result.journey}`, ''];
+  for (const s of result.steps) if (s.error) L.push(`  step ${s.i}  could not run: ${s.error}${/Timeout|waiting for locator/i.test(s.error) ? ' (locator not found on the page)' : ''}`);
+  if (result.stepCount && result.steps.length < result.stepCount) L.push(`  ${result.stepCount - result.steps.length} of ${result.stepCount} steps did not run`);
+  if (result.steps.some(s => s.error)) L.push('');
   for (const p of result.probes) {
     const proof = p.proof?.length ? `  proof  ${p.proof.join('  ')}` + (p.refute ? `\n  reader ${p.refute.tested ? (p.refute.parsed ? (p.refute.agrees ? 'agrees' : 'DISPUTES') + ' — ' + p.refute.reason : 'unparsed: ' + p.refute.raw) : 'not run: ' + p.refute.why}` : '') : null;
-    const head = `${p.sc} ${p.probe.replace('flow.', '').padEnd(22)} ${V(p.verdict).padEnd(13)}`;
+    const head = `${p.sc} ${name(p).padEnd(22)} ${V(p.verdict).padEnd(13)}`;
     const rule = `  rule   WCAG ${p.sc} (spec)${p.override ? ` · process joined by sameProcess ${JSON.stringify(p.override.sameProcess)} (project)` : ''}`;
     if (p.verdict === 'fail' && p.sc === '3.3.7') {
       const fields = [...new Set(p.reasked.map(m => m.field.name || m.field.id))], steps = [...new Set(p.reasked.map(m => m.step))], first = [...new Set(p.reasked.map(m => m.firstEnteredStep))];
       L.push(head, `  what   ${fields.join(', ')} asked again on step ${steps.join(',')}; first entered on step ${first.join(',')}`, `  where  ${p.reasked[0].url}  ${fields.map(f => '#' + f).join(', ')}`, rule, `  check  Reach this screen through the earlier steps. ${fields.length > 1 ? 'Are these fields' : 'Is this field'} empty although you typed the value${fields.length > 1 ? 's' : ''} earlier?`); if (proof) L.push(proof);
     } else if (p.verdict === 'fail' && p.sc === '3.3.4') {
-      const c = p.branches.confirmed, ck = p.branches.checked;
-      L.push(head, `  what   ${c.missing.length} of ${c.missing.length + c.present.length} entered values are not shown on the commit screen; no change control; validation ${ck.tested ? 'tested: ' + ck.evidence : 'untested'}`, `  where  ${result.steps.find(s => s.i === c.screen)?.url}`, rule, `  check  On this screen, can you see ${c.missing.slice(0, 3).map(m => JSON.stringify(m.value)).join(', ')} and a way to change them before committing?`); if (proof) L.push(proof);
+      const c = p.branches.confirmed, ck = p.branches.checked; const cm = c.changeMechanism;
+      L.push(head, `  what   ${c.missing.length} of ${c.missing.length + c.present.length} entered values are not shown on the commit screen; ${cm ? `change control "${typeof cm === 'string' ? cm : cm.text}"` : 'no change control'}; validation ${ck.tested ? 'tested: ' + ck.evidence : 'untested' + (p.checkedPassHint ? '' : ' (journey may allow it with checkedPass: true)')}`, `  where  ${result.steps.find(s => s.i === c.screen)?.url}`, rule, `  check  On this screen, can you see ${c.missing.slice(0, 3).map(m => JSON.stringify(m.value)).join(', ')} and a way to change them before committing?`); if (proof) L.push(proof);
     } else if (p.verdict === 'fail' && p.sc === '3.2.3') {
       const x = p.inversion;
       L.push(head, `  what   ${x.mechanism} order differs between steps ${x.stepA} and ${x.stepB}; first inverted pair ${x.firstInvertedPair.map(short).join(' / ')}`, rule, `  check  Compare the ${x.mechanism.replace(/^name:/, '')} menu on both pages; are those two items in swapped order?`); if (proof) L.push(proof);
@@ -21,7 +31,32 @@ export function card(result) {
         : p.sc === '3.3.7' ? `${p.satisfied.length} matched field${p.satisfied.length > 1 ? 's' : ''}, ${[...new Set(p.satisfied.map(m => m.mechanism))].join('/')}`
         : `${p.comparedPairs} pairs, ${Object.keys(p.mechanisms || {}).length} mechanisms, no inversion`;
       L.push(`${head} ${why}`);
-    } else L.push(`${head} ${(p.why || '').split(';')[0].slice(0, 100)}`);
+    } else {
+      let why = reason(p);
+      if (p.sc === '3.3.4' && p.verdict === 'unmeasurable' && p.branches?.confirmed?.missing?.length) why += `; not shown: ${p.branches.confirmed.missing.slice(0, 3).map(m => JSON.stringify(m.value)).join(', ')}`;
+      L.push(`${head} ${why}`);
+    }
+  }
+  return L.join('\n');
+}
+
+function pageCard(result) {
+  const L = [`uxcli run · ${result.url}`, ''];
+  if (result.error) L.push(`  could not run: ${result.error}`, '');
+  for (const p of result.probes) {
+    const head = `${p.sc.padEnd(6)} ${name(p).padEnd(16)} ${V(p.verdict).padEnd(13)}`;
+    const rule = `  rule   WCAG ${p.sc} (spec${p.axe ? `, axe-core ${p.axe}` : ''})`;
+    if (p.verdict === 'fail' && p.sc === '2.4.7') {
+      const t = p.targets;
+      L.push(head, `  what   ${t.length} of ${p.tested} focusable elements change nothing on focus: ${t.slice(0, 4).map(x => x.sel + (x.text ? ` "${x.text.slice(0, 20)}"` : '')).join(', ')}${t.length > 4 ? ', …' : ''}`, `  where  ${result.finalUrl || result.url}`, rule, `  check  Press Tab until ${t[0].sel}${t[0].text ? ` "${t[0].text.slice(0, 20)}"` : ''} should have focus. Can you see where focus is?`);
+    } else if (p.verdict === 'fail' && p.sc === '1.4.12') {
+      const t = p.targets;
+      L.push(head, `  what   ${t.length} locked value${t.length > 1 ? 's' : ''} below the minimum: ${t.slice(0, 3).map(x => `${x.sel} ${x.property} ${x.value}px < ${x.threshold}px (ACT ${x.rule})`).join('; ')}${t.length > 3 ? '; …' : ''}`, `  where  ${result.finalUrl || result.url}`, rule, `  check  Does the style attribute on ${t[0].lockedOn === 'self' ? t[0].sel : t[0].lockedOn} set ${t[0].property} with !important?`);
+    } else if (p.verdict === 'fail' && p.sc === '1.4.3') {
+      const g = p.groups;
+      L.push(head, `  what   ${g.reduce((n, x) => n + x.count, 0)} text nodes in ${g.length} colour pair${g.length > 1 ? 's' : ''}: ${g.slice(0, 4).map(x => `${x.fg} on ${x.bg} ${x.ratio}:1 ×${x.count} (e.g. ${x.example})`).join('; ')}${g.length > 4 ? '; …' : ''}`, `  where  ${result.finalUrl || result.url}`, rule, `  check  Is ${g[0].fg} on ${g[0].bg} a design token? One change there fixes ${g[0].count} node${g[0].count > 1 ? 's' : ''}.`);
+    } else L.push(`${head} ${reason(p)}`);
+    if (p.finding) L.push(`  finding ${p.finding.why}`);
   }
   return L.join('\n');
 }

package/src/gate.js

@@ -1,31 +1,43 @@
 // uxcli gate: every probe's falsification pair must fail where it must and stay silent where it must, and the fixture hashes must match.
 import fs from 'node:fs'; import path from 'node:path'; import os from 'node:os'; import crypto from 'node:crypto'; import { fileURLToPath, pathToFileURL } from 'node:url';
-import { loadJourney } from './journey.js'; import { runJourney, PROBES } from './run.js'; import { launch } from './browser.js';
+import { loadJourney } from './journey.js'; import { runJourney, PROBES } from './run.js'; import { runPage, PAGE_PROBES } from './page.js'; import { launch } from './browser.js';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const sha = f => crypto.createHash('sha256').update(fs.readFileSync(f)).digest('hex');
 export function hashTree(dir) { const out = {}; for (const f of fs.readdirSync(dir).sort()) { const p = path.join(dir, f); if (fs.statSync(p).isFile()) out[f] = sha(p); } return out; }
+const probeDir = probe => path.join(ROOT, 'src/probes', probe.id.replace(/^(flow|page)\./, ''));
+const checkHashes = (dir, sub, expected, problems) => { for (const [f, h] of Object.entries(expected || {})) if (sha(path.join(dir, sub, f)) !== h) problems.push(`${sub}/${f} hash changed`); };
 
 export async function gate({ log = console.log } = {}) {
   const browser = await launch(); let ok = true;
+  const report = (probe, pair, vf, vp, problems) => {
+    if (problems.length) ok = false;
+    log(`${probe.sc.padEnd(6)} ${probe.id.padEnd(28)} must-fail: ${vf.verdict.padEnd(6)} must-pass: ${vp.verdict.padEnd(14)} ${problems.length ? 'FAIL  ' + problems.join('; ') : 'ok'}`);
+    log(`       operator: ${pair.operator}`);
+  };
+  // Flow probes: one shared fixture site, the must-fail overlay replaces one file. Must-pass may be silent (not-applicable) until each probe has a twin that reaches its satisfied branch.
   const site = path.join(ROOT, 'test/fixtures/checkout'); const siteHashes = hashTree(site);
   for (const probe of PROBES) {
-    const dir = path.join(ROOT, 'src/probes', probe.id.replace('flow.', ''));
-    const pair = JSON.parse(fs.readFileSync(path.join(dir, 'pair.json'), 'utf8'));
-    const problems = [];
+    const dir = probeDir(probe); const pair = JSON.parse(fs.readFileSync(path.join(dir, 'pair.json'), 'utf8')); const problems = [];
     for (const [f, h] of Object.entries(pair.hashes.site)) if (siteHashes[f] !== h) problems.push(`site/${f} hash changed`);
-    for (const [f, h] of Object.entries(pair.hashes.mustFail)) if (sha(path.join(dir, 'must-fail', f)) !== h) problems.push(`must-fail/${f} hash changed`);
+    checkHashes(dir, 'must-fail', pair.hashes.mustFail, problems);
     const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'uxcli-gate-'));
     const build = (overlay) => { const d = fs.mkdtempSync(path.join(tmp, 'v-')); fs.cpSync(site, d, { recursive: true }); if (overlay) fs.cpSync(overlay, d, { recursive: true }); return pathToFileURL(d + '/').href; };
     const jPath = path.join(ROOT, pair.journey);
     const vf = (await runJourney(loadJourney(jPath, { base: build(path.join(dir, 'must-fail')) }), { browser })).probes.find(p => p.sc === probe.sc);
     const vp = (await runJourney(loadJourney(jPath, { base: build(null) }), { browser })).probes.find(p => p.sc === probe.sc);
     fs.rmSync(tmp, { recursive: true, force: true });
-    const fOk = vf.verdict === 'fail', pOk = ['pass', 'not-applicable'].includes(vp.verdict);
-    if (!fOk) problems.push(`must-fail returned ${vf.verdict}`); if (!pOk) problems.push(`must-pass returned ${vp.verdict}`);
-    if (problems.length) ok = false;
-    log(`${probe.sc} ${probe.id.padEnd(28)} must-fail: ${vf.verdict.padEnd(6)} must-pass: ${vp.verdict.padEnd(14)} ${problems.length ? 'FAIL  ' + problems.join('; ') : 'ok'}`);
-    log(`      operator: ${pair.operator}`);
+    if (vf.verdict !== 'fail') problems.push(`must-fail returned ${vf.verdict}`); if (!['pass', 'not-applicable'].includes(vp.verdict)) problems.push(`must-pass returned ${vp.verdict}`);
+    report(probe, pair, vf, vp, problems);
+  }
+  // Page probes: two complete pages, one mutation between them. Must-pass has to reach the satisfied branch: `pass`, never `not-applicable`.
+  for (const probe of PAGE_PROBES) {
+    const dir = probeDir(probe); const pair = JSON.parse(fs.readFileSync(path.join(dir, 'pair.json'), 'utf8')); const problems = [];
+    checkHashes(dir, 'must-fail', pair.hashes.mustFail, problems); checkHashes(dir, 'must-pass', pair.hashes.mustPass, problems);
+    const one = async sub => (await runPage(pathToFileURL(path.join(dir, sub, 'index.html')).href, { browser, only: [probe.id] })).probes[0];
+    const vf = await one('must-fail'), vp = await one('must-pass');
+    if (vf.verdict !== 'fail') problems.push(`must-fail returned ${vf.verdict}`); if (vp.verdict !== 'pass') problems.push(`must-pass returned ${vp.verdict}`);
+    report(probe, pair, vf, vp, problems);
   }
   await browser.close();
   log(ok ? 'GATE PASS' : 'GATE FAIL');

package/src/journey.js

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 export function loadJourney(file, vars = {}) {
   let text = fs.readFileSync(file, 'utf8');
   for (const [k, v] of Object.entries(vars)) text = text.split('{{' + k + '}}').join(v);
+  const left = [...new Set([...text.matchAll(/{{([a-zA-Z0-9_-]+)}}/g)].map(m => m[1]))]; if (left.length) throw new Error('journey has unsubstituted variables: ' + left.join(', ') + ' (pass --var=' + left[0] + '=...)');
   const J = JSON.parse(text);
   if (!Array.isArray(J.steps) || !J.steps.length) throw new Error('journey needs steps[]');
   if (!J.steps[0].url) throw new Error('first step needs a url');

package/src/page.js

@@ -0,0 +1,27 @@
+// Loads one URL once and gives every page probe the settled document. Returns the verdicts.
+import { launch, settle } from './browser.js';
+import { BOT } from './util.js';
+import focusVisible from './probes/focus-visible/probe.js';
+import textSpacing from './probes/text-spacing/probe.js';
+import contrast from './probes/contrast/probe.js';
+
+export const PAGE_PROBES = [focusVisible, textSpacing, contrast];
+
+export async function runPage(url, { browser, state, only } = {}) {
+  const own = !browser; if (own) browser = await launch();
+  const bctx = await browser.newContext({ viewport: { width: 1280, height: 800 }, storageState: state || undefined });
+  const page = await bctx.newPage();
+  const result = { url, ranAt: new Date().toISOString(), title: null, probes: [] };
+  const probes = only ? PAGE_PROBES.filter(p => only.includes(p.id) || only.includes(p.sc)) : PAGE_PROBES;
+  try {
+    await page.goto(url, { waitUntil: 'load', timeout: 45000 }); await settle(page);
+    result.finalUrl = page.url(); result.title = await page.title();
+    if (BOT.test(result.title)) { result.blocked = true; for (const p of probes) result.probes.push({ probe: p.id, sc: p.sc, provenance: 'spec', verdict: 'unmeasurable', why: `blocked: page title "${result.title}"` }); }
+    else for (const p of probes) {
+      try { result.probes.push({ probe: p.id, sc: p.sc, provenance: 'spec', ...(await p.measure(page, result)) }); }
+      catch (e) { result.probes.push({ probe: p.id, sc: p.sc, provenance: 'spec', verdict: 'unmeasurable', why: 'probe error: ' + String(e.message || e).slice(0, 160) }); }
+    }
+  } catch (e) { result.error = 'load: ' + String(e.message || e).slice(0, 160); for (const p of probes) result.probes.push({ probe: p.id, sc: p.sc, provenance: 'spec', verdict: 'unmeasurable', why: result.error }); }
+  await bctx.close(); if (own) await browser.close();
+  return result;
+}

package/src/probes/contrast/must-fail/index.html

@@ -0,0 +1 @@
+<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Order summary</title><style>body{font:16px/1.4 system-ui,sans-serif;margin:2rem;color:#222;background:#fff}h1{color:#222}.hint{color:#9a9a9a}.total{font-weight:700}</style></head><body><h1>Order summary</h1><p>Two items, delivered Thursday.</p><p class="hint">Prices include VAT. Delivery is free above fifty euro.</p><p class="total">Total 64.00 €</p></body></html>

package/src/probes/contrast/must-pass/index.html

@@ -0,0 +1 @@
+<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Order summary</title><style>body{font:16px/1.4 system-ui,sans-serif;margin:2rem;color:#222;background:#fff}h1{color:#222}.hint{color:#595959}.total{font-weight:700}</style></head><body><h1>Order summary</h1><p>Two items, delivered Thursday.</p><p class="hint">Prices include VAT. Delivery is free above fifty euro.</p><p class="total">Total 64.00 €</p></body></html>

package/src/probes/contrast/pair.json

@@ -0,0 +1,12 @@
+{
+ "kind": "page",
+ "operator": "index.html: .hint text is #9a9a9a on #ffffff (2.81:1); the must-pass twin uses #595959 (7:1).",
+ "hashes": {
+  "mustFail": {
+   "index.html": "e2102560feb1edeafdc0b2cb4fbc75e375b43be9cf5d2729287c04efdb638558"
+  },
+  "mustPass": {
+   "index.html": "cd2dfaf536a3d6ef92e2a77e0a191c408e363468bcf12dbc8f6c5a2bc9b4f7b7"
+  }
+ }
+}

package/src/probes/contrast/probe.js

@@ -0,0 +1,27 @@
+// page.contrast · WCAG 1.4.3, delegated to axe-core color-contrast. Spec in spec.md; falsification pair in pair.json.
+import { createRequire } from 'node:module'; import path from 'node:path';
+import { THIRD } from '../../util.js';
+const require = createRequire(import.meta.url);
+export const AXE_VERSION = require('axe-core/package.json').version;
+const AXE_PATH = path.join(path.dirname(require.resolve('axe-core/package.json')), 'axe.min.js');
+
+export default {
+  id: 'page.contrast', sc: '1.4.3', kind: 'page',
+  async measure(page) {
+    await page.addScriptTag({ path: AXE_PATH });
+    const r = await page.evaluate(async ([THIRD]) => {
+      const res = await axe.run(document, { runOnly: { type: 'rule', values: ['color-contrast'] }, resultTypes: ['violations', 'incomplete', 'passes', 'inapplicable'], reporter: 'v2' });
+      const nodes = arr => (arr[0]?.nodes || []).map(n => { const el = document.querySelector(n.target[0]); const d = (n.any[0] || n.all[0] || n.none[0] || {}).data || {}; return { target: n.target[0], third: !!(el && el.closest(THIRD)), fg: d.fgColor, bg: d.bgColor, ratio: d.contrastRatio, expected: d.expectedContrastRatio, fontSize: d.fontSize, fontWeight: d.fontWeight, message: (n.any[0] || n.all[0] || n.none[0] || {}).message || '' }; });
+      return { violations: nodes(res.violations).filter(n => !n.third), incomplete: nodes(res.incomplete).filter(n => !n.third).length, passes: nodes(res.passes).length, inapplicable: res.inapplicable.some(v => v.id === 'color-contrast') };
+    }, [THIRD]);
+    const base = { axe: AXE_VERSION, incomplete: r.incomplete, passes: r.passes };
+    if (r.violations.length) {
+      const groups = {}; for (const n of r.violations) { const k = `${n.fg} on ${n.bg}`; (groups[k] ||= { fg: n.fg, bg: n.bg, ratio: n.ratio, expected: n.expected, count: 0, example: n.target }).count++; }
+      const g = Object.values(groups).sort((a, b) => b.count - a.count);
+      return { verdict: 'fail', why: `${r.violations.length} text nodes below the ratio, ${g.length} colour pair${g.length > 1 ? 's' : ''}`, groups: g, ...base };
+    }
+    if (r.inapplicable && !r.passes && !r.incomplete) return { verdict: 'not-applicable', why: 'axe finds no text to measure', ...base };
+    if (!r.passes && r.incomplete) return { verdict: 'unmeasurable', why: `axe could not resolve ${r.incomplete} nodes (background image, gradient or overlap) and passed none`, ...base };
+    return { verdict: 'pass', why: `${r.passes} text nodes at or above the ratio${r.incomplete ? `, ${r.incomplete} unresolved by axe` : ''}`, ...base };
+  },
+};

package/src/probes/contrast/spec.md

@@ -0,0 +1,12 @@
+# page.contrast · WCAG 1.4.3 · provenance spec (delegated to axe-core 4.13.0, rule color-contrast)
+
+- **why:** SC text: text and images of text have a contrast ratio of at least 4.5:1, 3:1 for large text. The measurement is delegated to axe-core's `color-contrast` rule, pinned to version 4.13.0; the version is part of the definition and changes only with a recorded revision.
+- **applies-when:** what axe-core reports for `color-contrast` on the settled page at 1280×800, minus nodes inside third-party subtrees.
+- **correct-when:** axe reports no violation node for `color-contrast`.
+- **verdict:** `fail` if any violation node remains after third-party exclusion, grouped by (foreground, background) pair with a count and one example selector per group; `unmeasurable` if axe returns only `incomplete` nodes for the rule (background image, gradient, overlap) and no violation; `pass` if the rule ran with passing nodes and no violation; `not-applicable` if axe lists the rule as inapplicable.
+- **invalid-if:** page fails to load; page title matches a bot-challenge pattern (`unmeasurable · blocked`).
+- **known-infidelity:** everything axe-core's rule does not see: text over images, text rendered in canvas, SVG text, `incomplete` nodes. The probe adds no colour mathematics of its own; upgrading axe-core is a definition change.
+
+## Revisions
+
+- 2026-09-06 first version. Bench: ACT afw4f7 cases (34) with axe-core 4.13.0, recorded in the working notes.

package/src/probes/focus-visible/must-fail/index.html

@@ -0,0 +1 @@
+<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Account settings</title><style>body{font:16px/1.4 system-ui,sans-serif;margin:2rem;color:#222;background:#fff}form{display:grid;gap:.75rem;max-width:22rem}a,button{color:#1a4fd6}input,select{transition:box-shadow .3s}input:focus-visible,select:focus-visible{box-shadow:0 0 0 3px #9cc4ff}.dot{display:inline-block;width:8px;height:8px;border-radius:50%;background:#1a9c4a;animation:pulse 1.2s ease-in-out infinite}@keyframes pulse{50%{opacity:.4;transform:scale(.8)}}*:focus,*:focus-visible{outline:none}</style></head><body><h1>Account settings</h1><p><span class="dot" aria-hidden="true"></span> Signed in</p><nav><a href="#profile">Profile</a> · <a href="#security">Security</a></nav><form><label>Email <input id="email" type="email" autofocus value="jane@example.com"></label><label>Display name <input id="name" value="Jane"></label><label>Language <select id="lang"><option>English</option><option>Tiếng Việt</option></select></label><button type="submit">Save</button></form></body></html>

package/src/probes/focus-visible/must-pass/index.html

@@ -0,0 +1 @@
+<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Account settings</title><style>body{font:16px/1.4 system-ui,sans-serif;margin:2rem;color:#222;background:#fff}form{display:grid;gap:.75rem;max-width:22rem}a,button{color:#1a4fd6}input,select{transition:box-shadow .3s}input:focus-visible,select:focus-visible{box-shadow:0 0 0 3px #9cc4ff}.dot{display:inline-block;width:8px;height:8px;border-radius:50%;background:#1a9c4a;animation:pulse 1.2s ease-in-out infinite}@keyframes pulse{50%{opacity:.4;transform:scale(.8)}}</style></head><body><h1>Account settings</h1><p><span class="dot" aria-hidden="true"></span> Signed in</p><nav><a href="#profile">Profile</a> · <a href="#security">Security</a></nav><form><label>Email <input id="email" type="email" autofocus value="jane@example.com"></label><label>Display name <input id="name" value="Jane"></label><label>Language <select id="lang"><option>English</option><option>Tiếng Việt</option></select></label><button type="submit">Save</button></form></body></html>

package/src/probes/focus-visible/pair.json

@@ -0,0 +1,12 @@
+{
+ "kind": "page",
+ "operator": "index.html: a stylesheet rule *:focus,*:focus-visible{outline:none} removes the default focus ring from every control; the must-pass twin is identical without that rule. Both carry an autofocus input whose focus ring transitions over 300 ms and an infinitely pulsing status dot.",
+ "hashes": {
+  "mustFail": {
+   "index.html": "331ed671dfa5ab5a23cc39bbf6a99973017a9f7719a3afcf3d591b42346d823e"
+  },
+  "mustPass": {
+   "index.html": "6ab04dd5a3dad058ca4743bcb1f1f6d1c257c60e3ffc921bf2ef81122659e4f7"
+  }
+ }
+}

package/src/probes/focus-visible/probe.js

@@ -0,0 +1,44 @@
+// page.focus-visible · WCAG 2.4.7. Spec in spec.md; falsification pair in pair.json.
+import { THIRD } from '../../util.js';
+
+export default {
+  id: 'page.focus-visible', sc: '2.4.7', kind: 'page',
+  async measure(page) {
+    const r = await page.evaluate(async ([THIRD, maxTargets]) => {
+      const PROPS = ['outline-style', 'outline-width', 'outline-color', 'box-shadow', 'border-color', 'background-color', 'color', 'text-decoration-line', 'opacity', 'visibility', 'display'];
+      const raf2 = () => new Promise(r => requestAnimationFrame(() => requestAnimationFrame(r)));
+      // Elements with an infinitely repeating animation (pulses, spinners) are excluded from the document diff; a target is always diffed itself.
+      const animating = new Set(document.getAnimations().filter(a => a.effect?.getTiming?.().iterations === Infinity).map(a => a.effect.target).filter(Boolean));
+      const all = keep => [...document.querySelectorAll('body, body *')].filter(e => e === keep || !animating.has(e));
+      const snap = els => els.map(el => { const cs = getComputedStyle(el); const r = el.getBoundingClientRect(); const pinned = cs.position === 'fixed' || cs.position === 'sticky'; const zero = r.width === 0 && r.height === 0; const rect = zero ? [0] : pinned ? [r.width, r.height] : [r.x + scrollX, r.y + scrollY, r.width, r.height]; return PROPS.map(p => cs.getPropertyValue(p)).join('|') + '|' + rect.map(v => Math.round(v)).join(','); });
+      const sel = el => el.tagName.toLowerCase() + (el.id ? '#' + el.id : '') + (typeof el.className === 'string' && el.className.trim() ? '.' + el.className.trim().split(/\s+/).slice(0, 2).join('.') : '');
+      const cands = [...document.querySelectorAll('a[href],button,input,select,textarea,summary,[tabindex],[contenteditable]')]
+        .filter(e => { const ti = e.getAttribute('tabindex'); if (ti !== null && parseInt(ti) < 0) return false; if (e.disabled) return false; if (e.closest(THIRD)) return false; const cs = getComputedStyle(e); if (cs.visibility === 'hidden' || cs.display === 'none') return false; return e.getClientRects().length > 0; });
+      const targets = cands.slice(0, maxTargets);
+      // Revision 2026-09-06: blur first, so an autofocused control is not already focused in its own before-snapshot.
+      if (document.activeElement && document.activeElement !== document.body) document.activeElement.blur(); await raf2();
+      // Quiesce: wait for a 400 ms window with no change (up to six windows, transitions from the blur included) before the noise window is judged.
+      const els0 = all(); let noise = 0, quiet = 0;
+      for (let w = 0; w < 6; w++) { const n0 = snap(els0); await new Promise(r => setTimeout(r, 400)); const n1 = snap(els0); noise = 0; for (let i = 0; i < n0.length; i++) if (n0[i] !== n1[i]) noise++; if (noise === 0) break; quiet = w + 1; }
+      const items = [];
+      for (const el of targets) {
+        const els = all(el); const before = snap(els);
+        el.focus({ focusVisible: true, preventScroll: false }); await raf2();
+        if (document.activeElement !== el) { items.push({ sel: sel(el), skipped: 'no-focus' }); continue; }
+        const after = snap(els);
+        let changed = 0, selfChanged = false; for (let i = 0; i < before.length; i++) if (before[i] !== after[i] && els[i].isConnected) { changed++; if (els[i] === el) selfChanged = true; }
+        el.blur(); await raf2();
+        const r = el.getBoundingClientRect();
+        items.push({ sel: sel(el), text: (el.textContent || el.value || '').trim().slice(0, 40), changed, selfChanged, shift: !selfChanged && changed > Math.max(20, els.length * 0.3), inViewport: r.bottom > 0 && r.top < innerHeight });
+      }
+      const focusable = items.filter(i => !i.skipped);
+      return { candidates: cands.length, tested: targets.length, focusable: focusable.length, noise, settledAfter: quiet, animatingExcluded: animating.size, fails: focusable.filter(i => i.changed === 0), shifted: focusable.filter(i => i.shift).length };
+    }, [THIRD, 80]);
+    const base = { candidates: r.candidates, tested: r.tested, noise: r.noise, settledAfter: r.settledAfter, animatingExcluded: r.animatingExcluded, shifted: r.shifted };
+    if (r.focusable === 0) return { verdict: 'not-applicable', why: 'no focusable element', ...base };
+    if (r.noise > 0) return { verdict: 'unmeasurable', why: `document keeps changing with no interaction (${r.noise} elements in the last 400 ms window of 2.4 s)`, ...base };
+    if (r.fails.length) return { verdict: 'fail', why: `${r.fails.length} of ${r.focusable} focusable elements change nothing on focus`, targets: r.fails, ...base };
+    if (r.shifted) return { verdict: 'unmeasurable', why: `${r.shifted} targets move most of the page without changing themselves (layout shift)`, ...base };
+    return { verdict: 'pass', why: `${r.focusable} focusable elements each change on focus`, ...base };
+  },
+};

package/src/probes/focus-visible/spec.md

@@ -0,0 +1,18 @@
+# page.focus-visible · WCAG 2.4.7 · provenance spec
+
+- **why:** SC text: any keyboard operable user interface has a mode of operation where the keyboard focus indicator is visible. A focusable element that changes nothing when it receives focus has no indicator.
+- **applies-when:** element is in the sequential focus order (`a[href], button, input, select, textarea, summary, [tabindex>=0], [contenteditable]`), not disabled, computed `visibility != hidden`, `display != none`, at least one client rect, and not inside a third-party subtree (`iframe`, ad containers). First 80 such elements per page.
+- **correct-when:** after the active element is blurred and the document has been quiet for one 400 ms window (up to six windows are waited), then `focus({focusVisible:true})` on the target and two animation frames, at least one element in the document changed any of: `outline-style, outline-width, outline-color, box-shadow, border-color, background-color, color, text-decoration-line, opacity, visibility, display`, or its document-relative rect. Rect is document-relative (`+scrollX/Y`); fixed/sticky elements compare size only; 0×0 elements are recorded as a constant. Detached nodes and elements carrying an infinitely repeating animation (`getAnimations()` with infinite iterations) are excluded from the diff; the focused target itself is always compared. The count of excluded animating elements is reported.
+- **verdict:** `fail` if any target changes nothing, listing the targets; `unmeasurable` if the document still changes with no interaction after six 400 ms windows (noise > 0) or a target changes more than max(20, 30%) of elements without changing itself (layout shift); `pass` otherwise; `not-applicable` if no focusable element.
+- **invalid-if:** element still outside the viewport after focus; static CSSOM read instead of runtime; document self-mutating; mass change with target unchanged; page title matches a bot-challenge pattern (`unmeasurable · blocked`).
+- **known-infidelity:** computed style ≠ pixels (a border→outline swap of the same colour passes); AT-specific focus not simulated; a change on a sibling counts as an indicator even when it is not near the target.
+
+## Revisions
+
+v1 frozen 2026-09-05 (P0-A, sha256 `375832c3…da11bc`, verdicts `passed/failed/inapplicable/blocked`). ACT oj04fd 7/7 with v1.
+
+- 2026-09-06 **blur before the before-snapshot.** v1 took the before-snapshot with the page's autofocused control already focused, so that control read as "changes nothing" (false fail on two real login screens). The must-pass twin carries an `autofocus` control so the gate guards this.
+- 2026-09-06 **quiesce before the noise window.** The blur itself starts the focus ring's fade-out transition, which v1's single 400 ms window read as noise (two real screens went `unmeasurable`). Up to six 400 ms windows are waited for one quiet window; the must-pass twin transitions its focus ring so the gate guards this. Pages that never go quiet stay `unmeasurable`.
+- 2026-09-06 **infinitely animating elements excluded from the diff.** A pulsing status dot kept one real screen `unmeasurable` after quiesce; such elements can never be quiet and carry no focus information unless they are the target. The must-pass twin carries a pulsing dot so the gate guards this.
+- 2026-09-06 **third-party subtrees excluded** from targets, carried from the P0-A text-spacing finding.
+- 2026-09-06 verdict names mapped to the repo's list: `pass`, `fail`, `not-applicable`, `unmeasurable`; `blocked` is an `unmeasurable` reason.

package/src/probes/text-spacing/must-fail/index.html

@@ -0,0 +1 @@
+<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Delivery terms</title><style>body{font:16px/1.4 system-ui,sans-serif;margin:2rem;max-width:34rem;color:#222;background:#fff}</style></head><body><h1>Delivery terms</h1><p style="line-height:1.6 !important">Orders placed before noon leave the warehouse the same day. Deliveries to the islands take one extra working day and are not available on public holidays. Signatures are required for parcels above two hundred euro.</p><p style="letter-spacing:0 !important">Returns are accepted within thirty days of delivery when the seal is unbroken.</p></body></html>

package/src/probes/text-spacing/must-pass/index.html

@@ -0,0 +1 @@
+<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Delivery terms</title><style>body{font:16px/1.4 system-ui,sans-serif;margin:2rem;max-width:34rem;color:#222;background:#fff}</style></head><body><h1>Delivery terms</h1><p style="line-height:1.6 !important">Orders placed before noon leave the warehouse the same day. Deliveries to the islands take one extra working day and are not available on public holidays. Signatures are required for parcels above two hundred euro.</p><p style="letter-spacing:0.15em !important">Returns are accepted within thirty days of delivery when the seal is unbroken.</p></body></html>

package/src/probes/text-spacing/pair.json

@@ -0,0 +1,12 @@
+{
+ "kind": "page",
+ "operator": "index.html: the second paragraph locks letter-spacing at 0 with an !important style attribute; the must-pass twin locks it at 0.15em. Both lock line-height at 1.6 on a wrapped paragraph.",
+ "hashes": {
+  "mustFail": {
+   "index.html": "eab117b6dd089909104dd1f71ff6a10d7d02e595f35bd42fd7291e7bb6f7ceee"
+  },
+  "mustPass": {
+   "index.html": "46ff4433e7c20347cdf9c4fbb7c4d50f4e2ed408e0645b803e3081f7e08f3e9d"
+  }
+ }
+}

package/src/probes/text-spacing/probe.js

@@ -0,0 +1,58 @@
+// page.text-spacing · WCAG 1.4.12 (ACT 24afc2 / 9e45ec / 78fd32). Spec in spec.md; falsification pair in pair.json.
+import { THIRD } from '../../util.js';
+const RULES = [['letter-spacing', 0.12, '24afc2'], ['word-spacing', 0.16, '9e45ec'], ['line-height', 1.5, '78fd32']];
+
+export default {
+  id: 'page.text-spacing', sc: '1.4.12', kind: 'page',
+  async measure(page) {
+    const act = await page.evaluate(([THIRD, RULES]) => {
+      const sheetDeclares = (a, prop) => { try { for (const ss of document.styleSheets) for (const r of ss.cssRules || []) if (r.style && r.style.getPropertyValue(prop) && a.matches(r.selectorText)) return r.style.getPropertyPriority(prop) || 'normal'; } catch { } return null; };
+      const origin = (el, prop) => { for (let a = el; a && a.nodeType === 1; a = a.parentElement) {
+          const v = a.style.getPropertyValue(prop); const pr = a.style.getPropertyPriority(prop); const sheet = sheetDeclares(a, prop);
+          if (v) { if (v === 'inherit' || v === 'unset') continue;
+                   if (pr === 'important' || !sheet || sheet !== 'important') return { src: 'style-attr', important: pr === 'important', on: a };
+                   return { src: 'stylesheet', important: false }; }
+          if (sheet) return { src: 'stylesheet', important: false }; }
+        return { src: 'none', important: false }; };
+      const sel = el => el.tagName.toLowerCase() + (el.id ? '#' + el.id : '') + (typeof el.className === 'string' && el.className.trim() ? '.' + el.className.trim().split(/\s+/).slice(0, 2).join('.') : '');
+      const out = { applicable: 0, fails: [] };
+      for (const el of document.querySelectorAll('body, body *')) {
+        if (!(el instanceof HTMLElement) || el.closest(THIRD)) continue;
+        if (![...el.childNodes].some(n => n.nodeType === 3 && n.textContent.trim())) continue;
+        const cs = getComputedStyle(el); const r = el.getBoundingClientRect();
+        if (!(el.getClientRects().length > 0 && cs.visibility !== 'hidden' && cs.display !== 'none' && r.right > 0 && r.bottom > 0 && parseFloat(cs.opacity) > 0)) continue;
+        const fs = parseFloat(cs.fontSize);
+        for (const [prop, k, rule] of RULES) {
+          const o = origin(el, prop); if (!(o.src === 'style-attr' && o.important)) continue;
+          let value;
+          if (prop === 'line-height') {
+            const range = document.createRange(); range.selectNodeContents(el);
+            const tops = new Set([...range.getClientRects()].filter(x => x.width > 0).map(x => Math.round(x.top)));
+            if (tops.size < 2) continue;
+            const span = document.createElement('span'); span.textContent = 'X'; span.style.cssText = 'display:inline-block;padding:0;margin:0;border:0;vertical-align:top';
+            el.appendChild(span); value = span.getBoundingClientRect().height; span.remove();
+          } else { const v = cs.getPropertyValue(prop); value = v === 'normal' ? 0 : parseFloat(v); }
+          out.applicable++;
+          if (!(value >= k * fs - 0.01)) out.fails.push({ sel: sel(el), lockedOn: o.on === el ? 'self' : sel(o.on), rule, property: prop, value: +value.toFixed(2), threshold: +(k * fs).toFixed(2), text: el.textContent.trim().slice(0, 40) });
+        }
+      }
+      return out;
+    }, [THIRD, RULES]);
+    // Override breakage: apply the 1.4.12 user styles and count newly clipped or overlapping text containers. Reported as finding only.
+    const over = await page.evaluate(([THIRD]) => {
+      const textEls = [...document.querySelectorAll('body *')].filter(el => !el.closest(THIRD) && [...el.childNodes].some(n => n.nodeType === 3 && n.textContent.trim()) && el.getClientRects().length > 0).slice(0, 400);
+      const measure = () => textEls.map(el => { const cs = getComputedStyle(el); const r = el.getBoundingClientRect(); return { clipped: (cs.overflowX !== 'visible' || cs.overflowY !== 'visible') && (el.scrollWidth > el.clientWidth + 1 || el.scrollHeight > el.clientHeight + 1), rect: [r.left, r.top, r.right, r.bottom] }; });
+      const overlaps = m => { let n = 0; for (let i = 0; i < m.length; i++) for (let j = i + 1; j < m.length; j++) { const a = m[i].rect, b = m[j].rect; if (!(textEls[i].contains(textEls[j]) || textEls[j].contains(textEls[i])) && a[0] < b[2] - 1 && b[0] < a[2] - 1 && a[1] < b[3] - 1 && b[1] < a[3] - 1) n++; } return n; };
+      const before = measure(); const ovBefore = overlaps(before);
+      const st = document.createElement('style'); st.textContent = '* { line-height: 1.5 !important; letter-spacing: 0.12em !important; word-spacing: 0.16em !important; } p { margin-bottom: 2em !important; }';
+      (document.head || document.documentElement).appendChild(st);
+      const after = measure(); const ovAfter = overlaps(after); st.remove();
+      return { textEls: textEls.length, newlyClipped: after.filter((a, i) => a.clipped && !before[i].clipped).length, newOverlaps: Math.max(0, ovAfter - ovBefore) };
+    }, [THIRD]);
+    const finding = (over.newlyClipped || over.newOverlaps) ? { kind: 'override-breakage', why: `with 1.4.12 user styles applied, ${over.newlyClipped} text containers clip and ${over.newOverlaps} new overlaps appear (not asserted by the ACT rules)` } : null;
+    const base = { applicable: act.applicable, override: over, ...(finding ? { finding } : {}) };
+    if (act.applicable === 0) return { verdict: 'not-applicable', why: 'no text whose spacing is locked by an !important style attribute', ...base };
+    if (act.fails.length) return { verdict: 'fail', why: `${act.fails.length} locked spacing values below the 1.4.12 minimum`, targets: act.fails, ...base };
+    return { verdict: 'pass', why: `${act.applicable} locked spacing values, all at or above the minimum`, ...base };
+  },
+};

package/src/probes/text-spacing/spec.md

@@ -0,0 +1,15 @@
+# page.text-spacing · WCAG 1.4.12 · provenance spec (ACT 24afc2 / 9e45ec / 78fd32)
+
+- **why:** SC text: no loss of content or functionality occurs when letter-spacing is set to 0.12× font size, word-spacing to 0.16×, line-height to 1.5×. An `!important` declaration in a `style` attribute prevents user style sheets from reaching those values (ACT rules 24afc2, 9e45ec, 78fd32).
+- **applies-when:** HTML element with a visible direct text node (has client rect, not hidden, not fully off-screen, opacity > 0), not inside a third-party subtree, whose cascaded value for the property originates from a `style` attribute with `!important`, on the element itself or an ancestor it inherits from. `inherit`/`unset` walk up; `initial`/`revert` count as a locked declaration. For line-height only: the text must soft-wrap to at least two line boxes.
+- **correct-when:** computed letter-spacing ≥ 0.12 × font-size; word-spacing ≥ 0.16 × font-size; line-height used value (measured with an inline-block probe span) ≥ 1.5 × font-size. Tolerance 0.01px.
+- **verdict:** `not-applicable` if no applicable target for any of the three properties; `fail` if any applicable target is below its threshold, listing element, property, value and threshold; `pass` otherwise.
+- **invalid-if:** page fails to load; text not visible; page title matches a bot-challenge pattern (`unmeasurable · blocked`).
+- **known-infidelity:** only the `style`-attribute lock is measured, per ACT. Breakage after applying user styles (clipping, overlap) is a different measurement and is reported as `finding`, never `fail`: the override-breakage check applies the 1.4.12 user styles and counts newly clipped text containers and new overlaps between text containers.
+
+## Revisions
+
+v1 frozen 2026-09-05 (P0-A, sha256 `375832c3…da11bc`). ACT 62/62 with v1.
+
+- 2026-09-06 **third-party subtrees excluded** from targets: on ad-carrying pages every `!important` spacing lock sat inside AdSense containers (P0-A finding).
+- 2026-09-06 verdict names mapped to the repo's list; override breakage attached as `finding`.

package/src/run.js

@@ -32,7 +32,7 @@ export async function runJourney(J, { browser, outDir } = {}) {
   if (own) await browser.close();
   if (outDir) writeEvidence(ctx, probes, outDir);
   for (const s of ctx.steps) delete s.evidence;
-  return { journey: J.name, ranAt: new Date().toISOString(), steps: ctx.steps, recorded: ctx.recorded, probes };
+  return { journey: J.name, ranAt: new Date().toISOString(), stepCount: J.steps.length, steps: ctx.steps, recorded: ctx.recorded, probes };
 }
 
 // Process segments: a goto or a submit that did not navigate starts a new segment; sameProcess joins ranges (provenance project).