@sdods/core 0.9.0 → 0.10.0

package/dist/api/template.js

@@ -59,7 +59,7 @@ export function renderJson(template, ...scopes) {
         return JSON.parse(text);
     }
     catch (e) {
-        throw new Error(`Body is not valid JSON after rendering templates: ${e.message}\n${text}`);
+        throw new Error(`Body is not valid JSON after rendering templates: ${e.message}\n${text}`, { cause: e });
     }
 }
 //# sourceMappingURL=template.js.map

package/dist/fixtures/auth.js

@@ -233,7 +233,7 @@ export class AuthStateCache {
             catch (e) {
                 if (e.code !== 'EEXIST')
                     throw e;
-                let stale = false;
+                let stale;
                 try {
                     stale = Date.now() - statSync(lock).mtimeMs > LOCK_STALE_MS;
                 }

package/dist/har/api-har.js

@@ -119,7 +119,7 @@ export function snapshotToEntry(snap) {
 }
 export function entryToResponse(entry) {
     const text = entry.response.content.text ?? '';
-    let body = text;
+    let body;
     try {
         body = text.length ? JSON.parse(text) : null;
     }

package/dist/matrix/index.js

@@ -478,7 +478,7 @@ export function poolAccountsByEnv(project, opts = {}) {
             out.set(env, new Map());
             continue;
         }
-        let rows = [];
+        let rows;
         try {
             const text = readFileSync(file, 'utf8');
             if (spec.type === 'csv')

package/dist/quality/a11y-scenario.d.ts

@@ -10,34 +10,61 @@ import { type A11yResults } from '../a11y/audit.js';
  * `a11y.failOn`. The report is attached as `sdods/a11y-scenario` pass or fail, and it is also what
  * the `a11y` process gate reads.
  *
+ * `a11y.scope: every-page` widens that to every distinct URL the scenario reaches. Each one is
+ * audited after the STEP that reached it, once the page has settled at the point the `@perf` hook
+ * reads a document (load, first paint, the LCP settle window). The trigger is the step boundary
+ * rather than the page's own load event on purpose: an audit started from a load listener runs
+ * beside the next step's clicks, and a step that leaves the page mid-audit destroys the context axe
+ * runs in, so whether a page got audited would depend on timing. Between two steps nothing else
+ * drives the page. Violations are collected per URL and fail the scenario once, at its end, naming
+ * every URL that has them. A URL the scenario passed through inside a single step (a redirect, or a
+ * step that clicks through two pages) is listed as `not-audited`, so the gap is visible.
+ *
  * What it deliberately does not do:
  *   · audit a scenario that already failed. The page it stopped on is wherever the failure left it,
  *     and a violation list on top of the real error only buries the error;
  *   · audit a URL an explicit whole-page audit step already covered in the same scenario. That step
  *     ran with the threshold its author chose, and it passed (a failed step would have failed the
- *     scenario);
- *   · audit every page the scenario passed through. It audits the final page. A flow that needs each
- *     page checked writes the explicit step after each navigation.
+ *     scenario). Under `every-page` this holds even when the step ran after the tag's own audit;
+ *   · with the default `scope: final`, audit any page but the last one.
  */
 export type A11yScenarioStatus = 'audited' | 'covered-by-step' | 'skipped';
+/** One URL's audit under `a11y.scope: every-page`. */
+export interface A11yPageReport {
+    url: string;
+    status: 'audited' | 'covered-by-step' | 'not-audited';
+    reason?: string;
+    /** When the page was audited: after the named step, or at the end of the scenario. */
+    auditedAfter?: string;
+    violations: number;
+    blocking: number;
+    blockingRules: string[];
+    results?: A11yResults;
+}
 /** What `sdods/a11y-scenario` contains, and what the `a11y` process gate reads back. */
 export interface A11yScenarioReport {
     kind: 'a11y-scenario';
     runnerProject: string;
     fingerprint: string;
     retry: number;
+    /** The URL the scenario ended on. */
     url: string;
     status: A11yScenarioStatus;
     reason?: string;
+    /** Absent in reports written before `a11y.scope` existed, which were all `final`. */
+    scope?: A11yConfig['scope'];
     failOn: A11yConfig['failOn'];
     include: string[];
     exclude: string[];
-    /** Every violation axe reported, at any impact. */
+    /** Every violation axe reported, at any impact (summed over `pages` under `every-page`). */
     violations: number;
     /** Violations at or above `failOn`: the ones that fail the scenario. */
     blocking: number;
     blockingRules: string[];
+    /** The axe results of the final page (`final` scope only; `every-page` keeps them per page). */
     results?: A11yResults;
+    /** Every URL the scenario reached, in order (`every-page` scope only). */
+    pages?: A11yPageReport[];
 }
 export interface A11yScenarioDeps {
     page: Page;
@@ -64,5 +91,20 @@ export interface A11yScenarioDeps {
 }
 /** Effective a11y settings with the schema defaults, so a hand-built config behaves like a parsed one. */
 export declare function a11ySettings(config: A11yScenarioDeps['config']): A11yConfig;
+/**
+ * Under `every-page`, starts listing the URLs the page's main frame reaches, so a URL no step ended
+ * on still shows up in the report. A no-op under `final`.
+ */
+export declare function watchA11yPages(deps: Pick<A11yScenarioDeps, 'page' | 'config' | 'scenario'>): void;
+/**
+ * Under `every-page`, audits the page after a step when the step left it on a URL not yet audited
+ * or covered. Violations are kept for the end of the scenario; a configuration defect (an `include`
+ * that matches nothing, an audit that examined nothing) fails the step it follows.
+ */
+export declare function auditAfterStep(deps: Pick<A11yScenarioDeps, 'page' | 'config' | 'scenario'> & {
+    step: string;
+    /** True when the step failed: its page proves nothing, as at the end of a failed scenario. */
+    failed?: boolean;
+}): Promise<A11yPageReport | undefined>;
 export declare function auditScenarioEnd(deps: A11yScenarioDeps): Promise<A11yScenarioReport>;
 //# sourceMappingURL=a11y-scenario.d.ts.map

package/dist/quality/a11y-scenario.js

@@ -2,22 +2,125 @@ import { expect } from '@playwright/test';
 import { attachmentNames, scenarioFiles } from '@sdods/contracts';
 import { IMPACT_ORDER, assertAxeChecked, describeViolations, parseImpactFloor, runAxe, violationsAtOrAbove, wasPageAudited, writeAndAttachJson, } from '../a11y/audit.js';
 import { SdodsError } from '../errors.js';
+import { waitForSettle } from './perf-scenario.js';
 /** Effective a11y settings with the schema defaults, so a hand-built config behaves like a parsed one. */
 export function a11ySettings(config) {
     const a = config.project.a11y ?? {};
-    return { failOn: a.failOn ?? 'serious', include: a.include ?? [], exclude: a.exclude ?? [] };
+    return {
+        failOn: a.failOn ?? 'serious',
+        include: a.include ?? [],
+        exclude: a.exclude ?? [],
+        scope: a.scope ?? 'final',
+    };
+}
+const pageWatches = new WeakMap();
+function watchOf(scenario) {
+    let watch = pageWatches.get(scenario);
+    if (!watch)
+        pageWatches.set(scenario, (watch = { visited: [], pages: new Map() }));
+    return watch;
+}
+const auditable = (url) => Boolean(url) && url !== 'about:blank';
+/**
+ * Under `every-page`, starts listing the URLs the page's main frame reaches, so a URL no step ended
+ * on still shows up in the report. A no-op under `final`.
+ */
+export function watchA11yPages(deps) {
+    if (a11ySettings(deps.config).scope !== 'every-page')
+        return;
+    const watch = watchOf(deps.scenario);
+    deps.page.on('framenavigated', (frame) => {
+        if (frame !== deps.page.mainFrame())
+            return;
+        const url = frame.url();
+        if (auditable(url) && !watch.visited.includes(url))
+            watch.visited.push(url);
+    });
+}
+/** A navigation that replaced the document axe was running in: not a defect of the page. */
+const LEFT_THE_PAGE = /execution context was destroyed|frame was detached|navigat/i;
+async function auditPage(page, settings, url, auditedAfter) {
+    const results = await runAxe(page, { include: settings.include, exclude: settings.exclude });
+    assertAxeChecked(results, `on ${url}`);
+    const blocking = violationsAtOrAbove(results.violations, parseImpactFloor(settings.failOn));
+    return {
+        url,
+        status: 'audited',
+        auditedAfter,
+        violations: results.violations.length,
+        blocking: blocking.length,
+        blockingRules: blocking.map((v) => v.id),
+        results,
+    };
+}
+/**
+ * Under `every-page`, audits the page after a step when the step left it on a URL not yet audited
+ * or covered. Violations are kept for the end of the scenario; a configuration defect (an `include`
+ * that matches nothing, an audit that examined nothing) fails the step it follows.
+ */
+export async function auditAfterStep(deps) {
+    const { page, scenario } = deps;
+    const settings = a11ySettings(deps.config);
+    if (settings.scope !== 'every-page' || deps.failed)
+        return undefined;
+    const watch = watchOf(scenario);
+    watch.fresh = undefined;
+    const before = page.url();
+    if (!auditable(before) || watch.pages.has(before))
+        return undefined;
+    if (wasPageAudited(scenario, before))
+        return covered(watch, before);
+    await waitForSettle(page);
+    // The page may have redirected while it settled; audit where it is now.
+    const url = page.url();
+    if (!auditable(url) || watch.pages.has(url))
+        return undefined;
+    if (wasPageAudited(scenario, url))
+        return covered(watch, url);
+    if (!watch.visited.includes(url))
+        watch.visited.push(url);
+    try {
+        const report = await auditPage(page, settings, url, deps.step);
+        watch.pages.set(url, report);
+        watch.fresh = url;
+        return report;
+    }
+    catch (e) {
+        // A client-side redirect after the settle point: the next step boundary, or the end of the
+        // scenario, audits wherever it went. This URL is listed as not audited.
+        if (e instanceof Error && LEFT_THE_PAGE.test(e.message) && page.url() !== url)
+            return undefined;
+        throw e;
+    }
 }
+function covered(watch, url) {
+    const report = {
+        url,
+        status: 'covered-by-step',
+        reason: 'an explicit whole-page accessibility step already audited this URL in the scenario',
+        violations: 0,
+        blocking: 0,
+        blockingRules: [],
+    };
+    if (!watch.visited.includes(url))
+        watch.visited.push(url);
+    watch.pages.set(url, report);
+    return report;
+}
+/* ── the end of the scenario ─────────────────────────────────────────────── */
 export async function auditScenarioEnd(deps) {
     const { page, scenario, testInfo } = deps;
     const settings = a11ySettings(deps.config);
     const floor = parseImpactFloor(settings.failOn);
     const url = page.url();
+    const everyPage = settings.scope === 'every-page';
     const base = {
         kind: 'a11y-scenario',
         runnerProject: scenario.data.runnerProject,
         fingerprint: scenario.data.fingerprint,
         retry: scenario.data.retry,
         url,
+        ...(everyPage ? { scope: settings.scope } : {}),
         failOn: settings.failOn,
         include: settings.include,
         exclude: settings.exclude,
@@ -34,11 +137,14 @@ export async function auditScenarioEnd(deps) {
             reason: `the scenario ${testInfo.status} before the audit, so the page it stopped on proves nothing`,
         });
     }
-    if (!url || url === 'about:blank') {
+    const watch = everyPage ? watchOf(scenario) : undefined;
+    if (!auditable(url) && !watch?.pages.size) {
         throw new SdodsError('RUN_FAILED', 'This @a11y scenario never navigated anywhere, so there is no page to audit.', {
             hint: 'Navigate to the page under test in the scenario, or drop @a11y from a scenario that has no page.',
         });
     }
+    if (watch)
+        return auditEveryPageEnd({ ...deps, settings, url, watch, base, write });
     if (wasPageAudited(scenario, url)) {
         return write({
             ...base,
@@ -60,4 +166,64 @@ export async function auditScenarioEnd(deps) {
     expect(blocking.length, `@a11y: ${blocking.length} violation(s) at ${IMPACT_ORDER[floor]} or worse on ${url} (of ${results.violations.length} total; a11y.failOn is "${settings.failOn}"):\n${describeViolations(blocking)}`).toBe(0);
     return report;
 }
+async function auditEveryPageEnd(input) {
+    const { page, scenario, settings, url, watch, base, write } = input;
+    const floor = parseImpactFloor(settings.failOn);
+    // The final page is audited as it stands at the end, as under `final`: the steps after the one
+    // that reached it may have changed what is on it. Unless the last step's own audit is that state.
+    if (auditable(url) && watch.fresh !== url) {
+        if (!watch.visited.includes(url))
+            watch.visited.push(url);
+        if (wasPageAudited(scenario, url))
+            covered(watch, url);
+        else
+            watch.pages.set(url, await auditPage(page, settings, url, 'the end of the scenario'));
+    }
+    const pages = watch.visited.map((visited) => {
+        const audit = watch.pages.get(visited);
+        // An explicit step that audited this URL AFTER the tag did has the last word, as it does under `final`.
+        if (audit?.status === 'audited' && wasPageAudited(scenario, visited))
+            return {
+                url: visited,
+                status: 'covered-by-step',
+                reason: 'an explicit whole-page accessibility step audited this URL later in the scenario, with the threshold its author chose',
+                violations: 0,
+                blocking: 0,
+                blockingRules: [],
+            };
+        return (audit ?? {
+            url: visited,
+            status: 'not-audited',
+            reason: 'the scenario left this URL within the step that reached it, so no step boundary found it',
+            violations: 0,
+            blocking: 0,
+            blockingRules: [],
+        });
+    });
+    const audited = pages.filter((p) => p.status === 'audited');
+    const failing = audited.filter((p) => p.blocking > 0);
+    const report = await write({
+        ...base,
+        status: audited.length ? 'audited' : 'covered-by-step',
+        ...(audited.length
+            ? {}
+            : {
+                reason: 'explicit whole-page accessibility steps covered every URL the scenario reached',
+            }),
+        violations: audited.reduce((n, p) => n + p.violations, 0),
+        blocking: audited.reduce((n, p) => n + p.blocking, 0),
+        blockingRules: [...new Set(failing.flatMap((p) => p.blockingRules))],
+        pages,
+    });
+    if (failing.length) {
+        const byUrl = failing
+            .map((p) => {
+            const blocking = violationsAtOrAbove(p.results?.violations ?? [], floor);
+            return `${p.url} — ${p.blocking} of ${p.violations}:\n${describeViolations(blocking)}`;
+        })
+            .join('\n');
+        expect(report.blocking, `@a11y: ${report.blocking} violation(s) at ${IMPACT_ORDER[floor]} or worse on ${failing.length} of ${audited.length} audited page(s) (a11y.scope is "every-page", a11y.failOn is "${settings.failOn}"):\n${byUrl}`).toBe(0);
+    }
+    return report;
+}
 //# sourceMappingURL=a11y-scenario.js.map

package/dist/quality/gates.d.ts

@@ -1,4 +1,4 @@
-import type { GateResult, GateRow, ProcessGates } from '@sdods/contracts';
+import type { GateResult, GateRow, ProcessConfig, ProcessGates, RunManifest } from '@sdods/contracts';
 import type { A11yScenarioReport } from './a11y-scenario.js';
 import type { PerfScenarioReport } from './perf-scenario.js';
 export type { GateResult, GateRow };
@@ -45,10 +45,43 @@ export declare function evaluateGates(input: {
     evidence: GateEvidence;
 }): GateResult;
 /**
- * Reads the `@a11y` and `@perf` scenario reports out of a run directory
+ * Reads the `@a11y` and `@perf` scenario reports out of one or more run directories
  * (`<runDir>/<slug>/<fingerprint>/r<retry>/{a11y,perf}/scenario--<runner project>.json`), keeping
  * only the highest retry of each scenario on each runner project: an attempt that was retried is not
- * the scenario's verdict.
+ * the scenario's verdict. Several directories are how the shards of one run are read together: each
+ * shard wrote its own scenarios, and the same scenario never ran on two shards.
  */
-export declare function collectGateEvidence(runDir: string): GateEvidence;
+export declare function collectGateEvidence(runDirs: string | readonly string[], 
+/** Reports read from elsewhere (the attachments of a merged report), judged the same way. */
+extra?: readonly (A11yScenarioReport | PerfScenarioReport)[]): GateEvidence;
+/**
+ * The `sdods/a11y-scenario` and `sdods/perf-scenario` reports attached to the tests of a runner JSON
+ * report. After `playwright merge-reports` their paths point into the directory the blob reports
+ * were unpacked into, which lives only as long as the merge, so read them before it is removed. A
+ * missing or unreadable file is skipped; the run directories are the other source of the same
+ * evidence.
+ */
+export declare function gateReportsFromRunnerJson(report: unknown): (A11yScenarioReport | PerfScenarioReport)[];
+/**
+ * Gate totals from a runner JSON report's `stats` (what `playwright merge-reports --reporter json`
+ * writes for the merged shards). The same counting as the run dashboard: one row per test, retries
+ * folded into `flaky`.
+ */
+export declare function gateTotalsFromRunnerStats(stats: {
+    expected?: number;
+    unexpected?: number;
+    flaky?: number;
+    skipped?: number;
+} | undefined): GateTotals | undefined;
+/**
+ * The gate judge ingest runs when a run directory carries no `gates.json`: the process the run's
+ * manifest names, over the totals ingest just computed and the evidence in the run directory.
+ * `undefined` when there is nothing it may judge: no process, a process without gates, a cancelled
+ * run, or one shard of several (a shard is not the run; `sdods report merge --process` judges it).
+ */
+export declare function ingestGateJudge(input: {
+    manifest: Partial<RunManifest> | null | undefined;
+    runDir: string;
+    processOf: (slug: string, name: string) => ProcessConfig;
+}): ((totals: GateTotals) => GateResult | undefined) | undefined;
 //# sourceMappingURL=gates.d.ts.map

package/dist/quality/gates.js

@@ -1,5 +1,6 @@
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
+import { attachmentNames } from '@sdods/contracts';
 /** True when the process declares at least one gate worth evaluating. */
 export function hasGates(gates) {
     return Boolean(gates &&
@@ -45,21 +46,22 @@ export function evaluateGates(input) {
         });
     }
     if (gates.a11y) {
-        const audited = evidence.a11y.filter((r) => r.status !== 'skipped');
-        const blocking = audited.reduce((n, r) => n + r.blocking, 0);
-        const failing = audited.filter((r) => r.blocking > 0);
+        const reports = evidence.a11y.filter((r) => r.status !== 'skipped');
+        // Under `a11y.scope: every-page` one scenario report holds an audit per URL; each is counted.
+        const audits = reports.reduce((n, r) => n + auditsIn(r), 0);
+        const blocking = reports.reduce((n, r) => n + r.blocking, 0);
+        const failing = reports.flatMap((r) => (r.pages ?? [r])
+            .filter((p) => p.blocking > 0)
+            .map((p) => `${p.url} [${r.runnerProject}]: ${p.blockingRules.join(', ')}`));
         rows.push({
             gate: 'a11y',
             threshold: 'no blocking violation',
-            actual: `${blocking} blocking in ${audited.length} audit(s)`,
-            passed: audited.length > 0 && blocking === 0,
-            detail: audited.length === 0
+            actual: `${blocking} blocking in ${audits} audit(s)`,
+            passed: audits > 0 && blocking === 0,
+            detail: audits === 0
                 ? 'no @a11y audit ran in this run, so the gate has nothing to prove'
                 : failing.length
-                    ? failing
-                        .slice(0, 5)
-                        .map((r) => `${r.url} [${r.runnerProject}]: ${r.blockingRules.join(', ')}`)
-                        .join('; ')
+                    ? failing.slice(0, 5).join('; ')
                     : undefined,
         });
     }
@@ -83,16 +85,25 @@ export function evaluateGates(input) {
     }
     return { process: input.process, passed: rows.every((r) => r.passed), rows };
 }
+/** Audits one scenario report stands for: one per URL under `every-page`, otherwise one. */
+function auditsIn(report) {
+    if (!report.pages)
+        return 1;
+    return report.pages.filter((p) => p.status !== 'not-audited').length;
+}
 function formatPct(n) {
     return Number.isInteger(n) ? String(n) : n.toFixed(1);
 }
 /**
- * Reads the `@a11y` and `@perf` scenario reports out of a run directory
+ * Reads the `@a11y` and `@perf` scenario reports out of one or more run directories
  * (`<runDir>/<slug>/<fingerprint>/r<retry>/{a11y,perf}/scenario--<runner project>.json`), keeping
  * only the highest retry of each scenario on each runner project: an attempt that was retried is not
- * the scenario's verdict.
+ * the scenario's verdict. Several directories are how the shards of one run are read together: each
+ * shard wrote its own scenarios, and the same scenario never ran on two shards.
  */
-export function collectGateEvidence(runDir) {
+export function collectGateEvidence(runDirs, 
+/** Reports read from elsewhere (the attachments of a merged report), judged the same way. */
+extra = []) {
     const latest = new Map();
     const keep = (report) => {
         const key = `${report.kind}|${report.fingerprint}|${report.runnerProject}`;
@@ -103,7 +114,8 @@ export function collectGateEvidence(runDir) {
             ? { retry: report.retry, a11y: report }
             : { retry: report.retry, perf: report });
     };
-    for (const file of scenarioReportFiles(runDir)) {
+    const dirs = [...new Set(typeof runDirs === 'string' ? [runDirs] : runDirs)];
+    for (const file of dirs.flatMap(scenarioReportFiles)) {
         try {
             const parsed = JSON.parse(readFileSync(file, 'utf8'));
             if (parsed.kind === 'a11y-scenario' || parsed.kind === 'perf-scenario')
@@ -113,12 +125,61 @@ export function collectGateEvidence(runDir) {
             /* a half-written report is not evidence */
         }
     }
+    for (const report of extra)
+        keep(report);
     const values = [...latest.values()];
     return {
         a11y: values.flatMap((v) => (v.a11y ? [v.a11y] : [])),
         perf: values.flatMap((v) => (v.perf ? [v.perf] : [])),
     };
 }
+/**
+ * The `sdods/a11y-scenario` and `sdods/perf-scenario` reports attached to the tests of a runner JSON
+ * report. After `playwright merge-reports` their paths point into the directory the blob reports
+ * were unpacked into, which lives only as long as the merge, so read them before it is removed. A
+ * missing or unreadable file is skipped; the run directories are the other source of the same
+ * evidence.
+ */
+export function gateReportsFromRunnerJson(report) {
+    const names = new Set([attachmentNames.a11yScenario, attachmentNames.perfScenario]);
+    const out = [];
+    const walk = (suite) => {
+        for (const spec of suite.specs ?? [])
+            for (const test of spec.tests ?? [])
+                for (const result of test.results ?? [])
+                    for (const a of result.attachments ?? []) {
+                        if (!names.has(a.name) || !a.path || !existsSync(a.path))
+                            continue;
+                        try {
+                            const parsed = JSON.parse(readFileSync(a.path, 'utf8'));
+                            if (parsed.kind === 'a11y-scenario' || parsed.kind === 'perf-scenario')
+                                out.push(parsed);
+                        }
+                        catch {
+                            /* not evidence */
+                        }
+                    }
+        for (const child of suite.suites ?? [])
+            walk(child);
+    };
+    for (const suite of report?.suites ?? [])
+        walk(suite);
+    return out;
+}
+/**
+ * Gate totals from a runner JSON report's `stats` (what `playwright merge-reports --reporter json`
+ * writes for the merged shards). The same counting as the run dashboard: one row per test, retries
+ * folded into `flaky`.
+ */
+export function gateTotalsFromRunnerStats(stats) {
+    if (!stats)
+        return undefined;
+    const passed = stats.expected ?? 0;
+    const failed = stats.unexpected ?? 0;
+    const flaky = stats.flaky ?? 0;
+    const skipped = stats.skipped ?? 0;
+    return { total: passed + failed + flaky + skipped, passed, failed, skipped, flaky };
+}
 function scenarioReportFiles(runDir) {
     const out = [];
     const dirs = (p) => existsSync(p) ? readdirSync(p).filter((n) => statSync(join(p, n)).isDirectory()) : [];
@@ -141,4 +202,32 @@ function scenarioReportFiles(runDir) {
     }
     return out;
 }
+/**
+ * The gate judge ingest runs when a run directory carries no `gates.json`: the process the run's
+ * manifest names, over the totals ingest just computed and the evidence in the run directory.
+ * `undefined` when there is nothing it may judge: no process, a process without gates, a cancelled
+ * run, or one shard of several (a shard is not the run; `sdods report merge --process` judges it).
+ */
+export function ingestGateJudge(input) {
+    const { manifest, runDir } = input;
+    if (!manifest?.process || !manifest.projectSlug)
+        return undefined;
+    if ((manifest.shardTotal ?? 1) > 1 || manifest.exitCode === 130)
+        return undefined;
+    let proc;
+    try {
+        proc = input.processOf(manifest.projectSlug, manifest.process);
+    }
+    catch {
+        return undefined; // a process this checkout no longer defines has no gates to judge
+    }
+    if (!hasGates(proc.gates))
+        return undefined;
+    return (totals) => evaluateGates({
+        process: proc.name,
+        gates: proc.gates,
+        totals,
+        evidence: collectGateEvidence(runDir),
+    });
+}
 //# sourceMappingURL=gates.js.map

package/dist/quality/hooks.js

@@ -1,5 +1,5 @@
-import { AfterScenario, BeforeScenario } from '../fixtures/test.js';
-import { auditScenarioEnd } from './a11y-scenario.js';
+import { AfterScenario, AfterStep, BeforeScenario } from '../fixtures/test.js';
+import { auditAfterStep, auditScenarioEnd, watchA11yPages } from './a11y-scenario.js';
 import { judgeScenarioPerf, watchNavigations } from './perf-scenario.js';
 /**
  * `@a11y` and `@perf` tag hooks.
@@ -32,6 +32,19 @@ BeforeScenario({ name: 'sdods:perf:watch', tags: `@perf and ${PAGE}` }, async ({
 AfterScenario({ name: 'sdods:perf', tags: '@perf' }, async ({ config, scenario, apiContext, $testInfo }) => {
     await noting(scenario, () => judgeScenarioPerf({ config, scenario, apiContext, testInfo: $testInfo }));
 });
+// `a11y.scope: every-page` only; both are no-ops under the default `final`.
+BeforeScenario({ name: 'sdods:a11y:watch', tags: `@a11y and ${PAGE}` }, async ({ page, config, scenario }) => {
+    watchA11yPages({ page, config, scenario });
+});
+AfterStep({ name: 'sdods:a11y:page', tags: `@a11y and ${PAGE}` }, async ({ page, config, scenario, $bddContext }) => {
+    await noting(scenario, () => auditAfterStep({
+        page,
+        config,
+        scenario,
+        step: $bddContext.step.title,
+        failed: $bddContext.step.error !== undefined,
+    }));
+});
 AfterScenario({ name: 'sdods:a11y', tags: `@a11y and ${PAGE}` }, async ({ page, config, scenario, $testInfo }) => {
     await noting(scenario, () => auditScenarioEnd({ page, config, scenario, testInfo: $testInfo }));
 });

package/dist/quality/index.d.ts

@@ -1,4 +1,4 @@
-export { collectGateEvidence, evaluateGates, hasGates, type GateEvidence, type GateResult, type GateRow, type GateTotals, } from './gates.js';
-export type { A11yScenarioReport, A11yScenarioStatus } from './a11y-scenario.js';
+export { collectGateEvidence, evaluateGates, gateReportsFromRunnerJson, gateTotalsFromRunnerStats, hasGates, ingestGateJudge, type GateEvidence, type GateResult, type GateRow, type GateTotals, } from './gates.js';
+export type { A11yPageReport, A11yScenarioReport, A11yScenarioStatus } from './a11y-scenario.js';
 export type { PerfBreach, PerfScenarioReport } from './perf-scenario.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/quality/index.js

@@ -1,2 +1,2 @@
-export { collectGateEvidence, evaluateGates, hasGates, } from './gates.js';
+export { collectGateEvidence, evaluateGates, gateReportsFromRunnerJson, gateTotalsFromRunnerStats, hasGates, ingestGateJudge, } from './gates.js';
 //# sourceMappingURL=index.js.map

package/dist/quality/perf-scenario.d.ts

@@ -41,12 +41,29 @@ export declare const PAINT_WAIT_MS = 5000;
 export declare const REPORT_WAIT_MS: number;
 /** The binding each document reports through. Namespaced so it cannot collide with the app. */
 export declare const VITALS_BINDING = "__sdodsReportVitals";
+/**
+ * Resolves once the document has painted its first content, or after `paintWaitMs` when it never
+ * does. Runs in the page: it is serialised into the init script below and into `waitForSettle`, so
+ * the `@perf` and `@a11y` hooks agree on when a page has settled.
+ */
+export declare function firstPaintOrTimeout(paintWaitMs: number): Promise<void>;
 /**
  * The script every document in the page runs. Only the top-level document reports: after its load
  * event, once it has painted (or `paintWaitMs` has passed), and after the same LCP settle window the
  * explicit `I record the page vitals` step uses, so both measure a page the same way.
  */
 export declare function vitalsInitScript(settleMs?: number, paintWaitMs?: number, binding?: string): string;
+/**
+ * Waits, from Node, for the point at which the `@perf` init script reads a document: its load event
+ * (bounded by `LOAD_WAIT_MS`), its first contentful paint (bounded by `PAINT_WAIT_MS`), then the LCP
+ * settle window. Never throws: a page that will not settle is audited as it stands, and a page that
+ * navigates away while this waits is the caller's to notice.
+ */
+export declare function waitForSettle(page: Page, opts?: {
+    paintWaitMs?: number;
+    settleMs?: number;
+    loadWaitMs?: number;
+}): Promise<void>;
 /**
  * Starts recording the vitals of every document the page's main frame loads. Must run before the
  * scenario's first navigation, which is why the hook that calls it is a `BeforeScenario`.