Files
zhangxiang 1c0ce5f458 chore(gates): DEC-N6 让 e2e 进类型口径,并修 pre-commit 位与证据路径覆盖历史
- 新增 e2e/tsconfig.json + `npm run type-check:e2e`(并入 test:all)。
  本轮实测证据:teardown 补丁里第二个 `const revalidateSecret` 与既有声明重名,
  `npm run type-check` 全程 EXIT=0,只有 `playwright test --list` 才报重复声明 ——
  现在静态期就能抓。读数:type-check:e2e EXIT=0。
- .husky/pre-commit 的索引模式改回 100755(本轮每次提交都在打
  "was ignored because it's not set as executable",即 lint-staged 在任何克隆里都不执行)。
  验证看 `git ls-files -s .husky` 的 mode,不是看文件系统权限。
- axe 证据落盘改为按运行轮次分目录(原写死 docs/acceptance/2026-09-21-axe/axe-evidence.json,
  于是每跑一次就覆盖一次历史:0157b1c9 里那 409 行 diff 就是这么产生的),
  并补 check:axe:selftest;判定逻辑与退出码三档语义未动。
- 顺带修一处仪器级缺陷:package.json 里 `type-check:e2e` 被写了两遍 ——
  JSON 重复键是后者静默覆盖前者,不会报错也不会判红,正是本仓反复吃的"重复声明"类。
  现取键数与值由 node 回读校验。
2026-10-17 07:54:21 +08:00

407 lines
23 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 全站 axe 节点计数门禁(验收 §8-⑤ 的永久化版本)。
//
// 来源:本文件由 `docs/acceptance/2026-09-21-axe/axe-contrast-evidence.mjs` 平移而来(2026-09-23),
// 行为口径不变:同一份路由清单在 **chromium + firefox** × **light + dark** 四个组合下逐页跑两遍 axe-core
// 1) tag 通道 `runOnly:{type:'tag',values:['wcag2a','wcag2aa','wcag21a','wcag21aa']}`
// 2) 规则级通道 `runOnly:{type:'rules',values:EXTRA_RULES}`
// 第 2 遍是 `presentation-role-conflict` 的**唯一真实覆盖**(该规则属 `best-practice` tag,不在 tag 通道内),
// 也是 Lighthouse 那三条死断言删除后 `autocomplete-valid` / `svg-img-alt` 的兜底。
// 证据链:docs/acceptance/2026-09-21-gates/final-tree-results.md §⑤ 与「Lighthouse 的 3 条死断言」。
//
// 与一次性版本的关键差异:**门禁判定从「打印 PASSED」升级为「exit code」**,并新增分母自证断言,
// 使「悄悄不再覆盖」无法以绿灯形式通过(CI 见 Jenkinsfile 的 ♿♿ 阶段)。
//
// 用法:
// npm run check:axe:routes # 生成路由清单(默认 /tmp/axe-routes.xml)
// npm run check:axe # 用该清单扫描并判定
// npm run check:axe:selftest # 只验证证据落盘路径的装配逻辑(不起服务、不碰 docs/)
// 环境变量:BASE(默认 http://localhost:3100,须是 `node dist/standalone/server.js` 起的生产服务,
// 非 dev server)、SITEMAP(路由清单 XML)、OUT(证据 JSON 输出目录,默认按**运行日**分轮次目录
// docs/acceptance/<YYYY-MM-DD>-axe;显式给 OUT 时只写该目录,不再刷新 latest 指针)。
//
// 附加旗标(不参与门禁判定,退出码只属于门禁本身):
// --print-paths 打印本轮解析出的证据路径后 exit 0(不启动浏览器、不读清单)
// --selftest 用临时目录验证「路径模板 + 落盘/指针副本」这段装配逻辑,exit 0/1
//
// 退出码:0 通过 / 1 门禁判红(violation 节点 > 0、主题或底色不匹配、规则级通道分母不闭合)/
// 2 输入不可用(路由清单缺失或解析出 0 条)。
import { chromium, firefox } from 'playwright';
import { mkdirSync, writeFileSync, readFileSync, existsSync, mkdtempSync, rmSync } from 'fs';
import { fileURLToPath } from 'url';
import { dirname, isAbsolute, join, resolve, relative } from 'path';
import { tmpdir } from 'os';
// 本脚本从证据目录 docs/acceptance/2026-09-21-axe/ 搬到 scripts/accessibility/,cwd 相对路径一律改为
// 仓库根相对,这样无论从哪个目录调用都指向同一份 axe-core 与同一处证据目录(行为等价,只是不再依赖 cwd)。
const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
const repoPath = (p) => (isAbsolute(p) ? p : resolve(REPO_ROOT, p));
const BASE = process.env.BASE || 'http://localhost:3100';
const SITEMAP = repoPath(process.env.SITEMAP || '/tmp/axe-routes.xml');
const AXE_SCRIPT = repoPath('node_modules/axe-core/axe.min.js');
/**
* 证据落盘路径(本批补的仪器缺陷,见 docs/acceptance/qa-tracker.md §11.6 末尾「证据文件的口径提醒」):
* 旧实现把 OUT 写死成 `docs/acceptance/2026-09-21-axe` ⇒ **每跑一次就把那份 2026-09-21 的历史证据刷成
* 本轮读数**(commit 0157b1c9 里那 409 行 diff 就是它)。现按运行轮次落盘:
* 默认目录 = docs/acceptance/<YYYY-MM-DD>-axe(日期取运行日、**本地时区**,与 docs/acceptance 下
* 其它按日期分目录的证据一致;UTC 会让晚上 8 点后的运行日跳天,故不用 toISOString 的前 10 位)。
* 兼容性:`docs/acceptance/2026-09-21-axe/axe-evidence.json` 这个路径**仍然每轮刷新**,但它从今往后
* 只是「latest 指针副本」(Jenkinsfile:399 的 archiveArtifacts 与 docs 下的既有引用都指它),
* 不再是历史原件;历史原件留在各自轮次目录。显式设置 OUT 时只写 OUT、不刷新指针(与旧版一致)。
* 判定逻辑与退出码不受这段改动影响。
*/
const LATEST_POINTER_DIR = 'docs/acceptance/2026-09-21-axe';
const localRunDate = (d = new Date()) => {
const pad = (n) => String(n).padStart(2, '0');
return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
};
function resolveEvidenceTargets(env) {
const runDate = localRunDate();
const out = repoPath(env.OUT || `docs/acceptance/${runDate}-axe`);
const file = join(out, 'axe-evidence.json');
const latest = env.OUT ? null : repoPath(join(LATEST_POINTER_DIR, 'axe-evidence.json'));
return { runDate, out, file, latest };
}
const TARGETS = resolveEvidenceTargets(process.env);
/** 把一轮证据写进轮次目录,并(默认路径下)刷新 latest 指针副本。返回落盘位置供日志打印。 */
function writeEvidence(artifact, targets) {
const json = JSON.stringify(artifact, null, 2);
mkdirSync(targets.out, { recursive: true });
writeFileSync(targets.file, json);
if (targets.latest) {
mkdirSync(dirname(targets.latest), { recursive: true });
writeFileSync(targets.latest, json);
}
return targets;
}
const FLAGS = new Set(process.argv.slice(2));
if (FLAGS.has('--print-paths')) {
console.log(JSON.stringify(TARGETS, null, 2));
process.exit(0);
}
if (FLAGS.has('--selftest')) {
// 只验证这段「路径模板 + 落盘」的装配逻辑:不启动浏览器、不读路由清单、不碰 docs/。
// 1) 默认模板:docs/acceptance/<运行日>-axe/axe-evidence.json;
// 2) 显式 OUT:只写该目录,latest 指针为 null(旧版语义);
// 3) 真实写一遍:轮次文件与指针副本都要存在且内容一致。
const checks = [];
const pushCheck = (ok, msg) => checks.push({ ok, msg });
const today = `${new Date().getFullYear()}-${String(new Date().getMonth() + 1).padStart(2, '0')}-${String(new Date().getDate()).padStart(2, '0')}`;
const def = resolveEvidenceTargets({});
pushCheck(def.out === repoPath(`docs/acceptance/${today}-axe`), `默认轮次目录模板 = docs/acceptance/${today}-axe(实测 ${def.out})`);
pushCheck(def.file === repoPath(`docs/acceptance/${today}-axe/axe-evidence.json`), '默认轮次文件名 = <轮次目录>/axe-evidence.json');
pushCheck(def.latest === repoPath(`${LATEST_POINTER_DIR}/axe-evidence.json`), '默认刷新 latest 指针副本');
const explicit = resolveEvidenceTargets({ OUT: '/tmp/axe-selftest-out' });
pushCheck(explicit.file === '/tmp/axe-selftest-out/axe-evidence.json', '显式 OUT 时写该目录');
pushCheck(explicit.latest === null, '显式 OUT 时不刷新 latest 指针');
const sandbox = mkdtempSync(join(tmpdir(), 'axe-selftest-'));
try {
const artifact = { selftest: true, note: '非门禁产物,仅验证落盘路径逻辑', passed: true };
const roundLikeDir = join(sandbox, `docs/acceptance/${today}-axe`);
const pointerFile = join(sandbox, `${LATEST_POINTER_DIR}/axe-evidence.json`);
const written = writeEvidence(artifact, { runDate: today, out: roundLikeDir, file: join(roundLikeDir, 'axe-evidence.json'), latest: pointerFile });
pushCheck(existsSync(written.file), `轮次证据文件已写出:${written.file}`);
pushCheck(existsSync(written.latest), `latest 指针副本已写出:${written.latest}`);
pushCheck(
readFileSync(written.file, 'utf8') === readFileSync(written.latest, 'utf8'),
'轮次证据与 latest 指针内容逐字节一致',
);
// 反例:只给 out/file(latest=null)时不得在指针位置凭空造文件
const noPointerDir = join(sandbox, 'no-pointer');
writeEvidence(artifact, { runDate: today, out: noPointerDir, file: join(noPointerDir, 'axe-evidence.json'), latest: null });
pushCheck(!existsSync(join(noPointerDir, LATEST_POINTER_DIR)), 'latest 为 null 时不产生任何指针文件');
} finally {
rmSync(sandbox, { recursive: true, force: true });
}
const failed = checks.filter((c) => !c.ok);
for (const c of checks) console.log(`${c.ok ? '✓' : '✗'} ${c.msg}`);
if (failed.length > 0) {
console.error(`\nFAIL: axe 证据路径 selftest ${failed.length} 项未通过`);
process.exit(1);
}
console.log('SELFTEST PASSED(未触碰 docs/,未启动浏览器)');
process.exit(0);
}
const TAGS = ['wcag2a', 'wcag2aa', 'wcag21a', 'wcag21aa'];
// Lighthouse 12.6.1 不包装这三条 axe 规则,且 presentation-role-conflict 属 best-practice tag(不在 TAGS 内)
// ⇒ 只有这里的规则级 runOnly 才真正测到它们;证据链见 docs/acceptance/2026-09-21-gates/final-tree-results.md
//
// 两条数组刻意分开:
// CANONICAL_EXTRA_RULES = 门禁**要求被判定**的三条规则(绝对下限,写死在此)
// EXTRA_RULES = 实际传给 axe 的 runOnly 列表(默认等于下限)
// 只删 EXTRA_RULES 会立即判红(分母不再等于 路由 × 组合 × 3 条下限),删 CANONICAL 则需要改动带注释的门禁契约本身。
const CANONICAL_EXTRA_RULES = ['autocomplete-valid', 'presentation-role-conflict', 'svg-img-alt'];
const EXTRA_RULES = [...CANONICAL_EXTRA_RULES];
const ENGINES = [['chromium', chromium], ['firefox', firefox]];
const THEMES = ['light', 'dark'];
const COMBOS = ENGINES.length * THEMES.length; // 4 个「引擎 × 主题」组合
/**
* 底色哨兵:页面的 body 底色必须等于**令牌自己声明的值**。
* 为什么要有这条:样式没加载时所有元素都落在默认黑白底上,对比度会「意外通过」,
* 于是 axe 给出一个漂亮的 0 违规 —— 这条哨兵就是用来把那种「意外达标」判红的。
*
* ⚠ 原实现把期望值**硬编码成两条字面量**(light #FFF、dark `rgb(10, 14, 20)`),
* 而 P1 暖色迁移早在本分支基线 `da9a5cb6` 之前就把暗色底改成了暖墨
* (`--color-bg-primary-rgb: 20 18 16`)⇒ 闸的哨兵从此**恒红**,
* 本轮实测 `bgMismatch=36`(chromium/dark 与 firefox/dark 各 36 页)。
* 归因核过:`git diff da9a5cb6..HEAD -- src/app/globals.css` 里**没有**任何
* `color-bg-primary` 改动 ⇒ 不是本轮引入,是「令牌改了、闸里的抄本没跟」,
* 与本仓 `check:token-twins` 守的是同一类病(一个语义有多条表示通道)。
*
* 修法不是把字面量改成新值 —— 那只是把抄本再抄一遍,下次换色板还会红。
* 现改成**从令牌自己取值**:读 `--color-bg-primary-rgb` 三元组拼成期望色,
* 哨兵的失败模式不变(CSS 没加载时该自定义属性解析为空 ⇒ 期望串拼不出来 ⇒ 判红),
* 但对色板变更免疫。
*/
const BG_TRIPLET_VAR = '--color-bg-primary-rgb';
// 逐页状态码期望:清单里绝大多数路由必须 2xx/3xx,`/_not-found` 是本站 404 页、**期望** 404。
// 为什么必须逐页判:404/500 页几乎没有可比对节点,`violationNodes` 仍为 0,而 `s.pages` 计数照加;
// 聚合保险丝 `okResponses > 0` 只在**全部**响应都非 2xx 时才炸 ⇒ 单个路由退化成 404 会被当「干净」计过。
// 证据:docs/acceptance/2026-09-21-axe/axe-evidence.json 实测 136 行 = 132×200 + 4×404(全部来自 /_not-found)。
const EXPECTED_404 = ['/_not-found'];
const statusOffenders = [];
function fatal(message, code = 2) {
console.error(`FATAL: ${message}`);
process.exit(code);
}
// 扫描中途抛错(浏览器启动失败、服务不可达、axe 注入失败)会以非 0 退出,这里只是把原因说清楚。
for (const ev of ['unhandledRejection', 'uncaughtException']) {
process.on(ev, (err) => fatal(`扫描中断(${ev}):${err instanceof Error ? err.message : String(err)}`, 1));
}
if (!existsSync(AXE_SCRIPT)) {
fatal(`缺少 ${AXE_SCRIPT}(axe-core 未安装?先 npm ci)`, 2);
}
if (!existsSync(SITEMAP)) {
fatal(`路由清单 ${SITEMAP} 不存在。先跑 npm run check:axe:routes 生成清单`, 2);
}
const urls = [...new Set(
readFileSync(SITEMAP, 'utf8')
.split('<url>')
.slice(1)
.map((b) => (b.match(/<loc>([^<]+)<\/loc>/) || [])[1])
.map((loc) => {
try {
return new URL(loc).pathname;
} catch {
return null;
}
})
.filter(Boolean)
)];
// 空清单时下面的循环零次执行、计数器全为 0,「PASSED = true」是假绿,必须拒绝出证据。
if (urls.length === 0) {
fatal(`从 ${SITEMAP} 解析出 0 条路由,扫描等于没测,退出 2`, 2);
}
async function settle(page) {
await page.waitForTimeout(1200);
await page.evaluate(async () => {
let last = -1;
for (let i = 0; i < 12; i += 1) {
window.scrollTo(0, document.body.scrollHeight);
await new Promise((r) => setTimeout(r, 180));
if (Math.round(window.scrollY) === last) break;
last = Math.round(window.scrollY);
}
window.scrollTo(0, 0);
});
await page.waitForTimeout(400);
}
const rows = [];
for (const [engineName, launcher] of ENGINES) {
const browser = await launcher.launch();
for (const theme of THEMES) {
const ctx = await browser.newContext({ colorScheme: theme });
await ctx.addInitScript((t) => {
localStorage.setItem('novalon-theme', t);
localStorage.setItem('novalon-cookie-preferences',
JSON.stringify({ necessary: true, analytics: false, functional: false, timestamp: '2026-09-21T00:00:00.000Z' }));
}, theme);
const page = await ctx.newPage();
for (const url of urls) {
const res = await page.goto(`${BASE}${url}`, { waitUntil: 'domcontentloaded', timeout: 45000 });
const statusCode = res ? res.status() : 0;
await settle(page);
const observedTheme = await page.evaluate(() =>
document.documentElement.getAttribute('data-theme'));
await page.addScriptTag({ path: AXE_SCRIPT });
const tagRun = await page.evaluate((tags) => window.axe.run(document, {
runOnly: { type: 'tag', values: tags },
resultTypes: ['violations'],
}), TAGS);
const violations = tagRun.violations.map((v) => ({
id: v.id, impact: v.impact, nodes: v.nodes.length,
sample: v.nodes.slice(0, 3).map((n) => (n.target || []).join(' ')),
}));
// 规则级复跑:axe 遇到未知 rule id 会直接抛错;extraRulesChecked 断言三条规则确实参与了本页运行。
const ruleRes = await page.evaluate((rules) => window.axe.run(document, {
runOnly: { type: 'rules', values: rules },
}), EXTRA_RULES);
const ruleViolations = ruleRes.violations.map((v) => ({
id: v.id, impact: v.impact, nodes: v.nodes.length,
sample: v.nodes.slice(0, 3).map((n) => (n.target || []).join(' ')),
}));
const ruleIds = new Set([
...ruleRes.violations, ...ruleRes.passes, ...ruleRes.incomplete, ...ruleRes.inapplicable,
].map((r) => r.id));
const covered = CANONICAL_EXTRA_RULES.filter((id) => ruleIds.has(id));
// 一次 evaluate 同时取「实际底色」与「令牌声明的底色」,避免两次读之间主题被切换
const bgRead = await page.evaluate((varName) => {
const root = getComputedStyle(document.documentElement);
const triplet = (root.getPropertyValue(varName) || '').trim();
const parts = triplet.split(/\s+/).filter(Boolean);
const expected = parts.length >= 3 ? `rgb(${parts.slice(0, 3).join(', ')})` : '';
return { actual: getComputedStyle(document.body).backgroundColor, expected };
}, BG_TRIPLET_VAR);
rows.push({
engine: engineName, theme, url, observedTheme, statusCode,
pageBg: bgRead.actual,
expectedBg: bgRead.expected,
bgMatchesToken: bgRead.expected !== '' && bgRead.actual === bgRead.expected,
violationRules: violations.length,
violationNodes: violations.reduce((a, v) => a + v.nodes, 0),
contrastNodes: violations.filter((v) => v.id === 'color-contrast').reduce((a, v) => a + v.nodes, 0),
extraRuleNodes: ruleViolations.reduce((a, v) => a + v.nodes, 0),
extraRulesChecked: ruleIds.size,
extraRulesCovered: covered,
extraRulesMissing: CANONICAL_EXTRA_RULES.filter((id) => !ruleIds.has(id)),
violations,
extraRuleViolations: ruleViolations,
});
console.log(`${engineName}/${theme} ${url} status=${statusCode} theme=${observedTheme} bg=${bgRead.actual}|期望 ${bgRead.expected} rules=${violations.length} nodes=${rows.at(-1).violationNodes} contrast=${rows.at(-1).contrastNodes} extra=${rows.at(-1).extraRuleNodes}/${covered.length}/${rows.at(-1).extraRulesChecked}`);
}
await ctx.close();
}
await browser.close();
}
const summary = {};
for (const r of rows) {
const k = `${r.engine}/${r.theme}`;
summary[k] = summary[k] || {
pages: 0, themeMismatch: 0, bgMismatch: 0, contrastNodes: 0, violationNodes: 0,
extraRuleNodes: 0, extraRulePagesUnderCovered: 0, extraRuleCoveragePairs: 0,
non2xxResponses: 0, okResponses: 0, unexpectedStatus: 0,
};
summary[k].pages += 1;
summary[k].contrastNodes += r.contrastNodes;
summary[k].violationNodes += r.violationNodes;
summary[k].extraRuleNodes += r.extraRuleNodes;
summary[k].extraRuleCoveragePairs += r.extraRulesCovered.length;
// 两条都要满足:三条下限规则逐条判定过(缺一条即覆盖腐化),且通道本身没跑出预期之外的形状。
if (r.extraRulesMissing.length > 0 || r.extraRulesChecked !== EXTRA_RULES.length) {
summary[k].extraRulePagesUnderCovered += 1;
}
if (r.observedTheme !== r.theme) summary[k].themeMismatch += 1;
if (!r.bgMatchesToken) summary[k].bgMismatch += 1;
if (r.statusCode >= 200 && r.statusCode < 400) summary[k].okResponses += 1;
else summary[k].non2xxResponses += 1;
// 逐页状态码判据(独立于上面两条聚合计数)
const expects404 = EXPECTED_404.includes(r.url);
const statusMatches = expects404
? r.statusCode === 404
: r.statusCode >= 200 && r.statusCode < 400;
if (!statusMatches) {
summary[k].unexpectedStatus += 1;
statusOffenders.push(
`${k} ${r.url} status=${r.statusCode} expected=${expects404 ? '404' : '2xx/3xx'}`,
);
}
}
const expectedCombos = ENGINES.flatMap(([e]) => THEMES.map((t) => `${e}/${t}`));
const totalRuleChecks = rows.reduce((a, r) => a + r.extraRulesChecked, 0);
const totalCanonicalCoverage = rows.reduce((a, r) => a + r.extraRulesCovered.length, 0);
const expectedCanonicalCoverage = urls.length * COMBOS * CANONICAL_EXTRA_RULES.length;
const missingRuleUnion = [...new Set(rows.flatMap((r) => r.extraRulesMissing))];
// ---- 门禁断言(exit code 由此决定,不再只是打印) ----
const failures = [];
const push = (cond, msg) => { if (!cond) failures.push(msg); };
// 分母自证:缺了它,「少扫了几个组合」与「扫了且全绿」在证据上无法区分。
push(rows.length === urls.length * COMBOS,
`分母不闭合:rows=${rows.length},应为 ${urls.length} 路由 × ${COMBOS} 组合 = ${urls.length * COMBOS}`);
for (const combo of expectedCombos) {
const s = summary[combo];
if (!s) { push(false, `${combo} 组合完全缺失(浏览器未启动或中途中断)`); continue; }
push(s.pages === urls.length, `${combo} 只扫了 ${s.pages} 页,清单有 ${urls.length} 页`);
push(s.violationNodes === 0, `${combo} violationNodes=${s.violationNodes}(阈值 0)`);
push(s.contrastNodes === 0, `${combo} contrastNodes=${s.contrastNodes}(阈值 0)`);
push(s.extraRuleNodes === 0, `${combo} extraRuleNodes=${s.extraRuleNodes}(三条规则级判据,阈值 0)`);
push(s.extraRulePagesUnderCovered === 0,
`${combo} 有 ${s.extraRulePagesUnderCovered} 页的规则级通道未覆盖满 ${CANONICAL_EXTRA_RULES.length} 条下限规则(缺:${missingRuleUnion.join(', ') || '形状异常'})`);
push(s.extraRuleCoveragePairs === urls.length * CANONICAL_EXTRA_RULES.length,
`${combo} 规则级覆盖 ${s.extraRuleCoveragePairs} ≠ ${urls.length} 路由 × ${CANONICAL_EXTRA_RULES.length} 规则`);
push(s.themeMismatch === 0, `${combo} themeMismatch=${s.themeMismatch}(以为在量深色其实还是浅色)`);
push(s.bgMismatch === 0, `${combo} bgMismatch=${s.bgMismatch}(底色不等于令牌值 ⇒ 样式未加载 ⇒ 对比度「意外达标」)`);
// 保险丝:整组全非 2xx ⇒ 服务或清单不对,扫的是 404 页而不是本站页面。
push(s.okResponses > 0, `${combo} 所有响应都非 2xx(BASE=${BASE} 不是可用的生产服务,或清单已过期)`);
push(s.unexpectedStatus === 0,
`${combo} 有 ${s.unexpectedStatus} 页状态码不符期望(404/500 页会被 axe 判为「无违规」且仍计入 pages 分母;期望见 EXPECTED_404)`);
}
// offenders 明细直接进判据文本(而非只打 stdout):本仓曾因 line reporter 不带 stdout
// 而在并发失败时「查不到规则名」,同理这里若不落进 failures 就查不到是哪一条路由 404。
if (statusOffenders.length > 0) {
push(false, `逐页状态码断言失败 ${statusOffenders.length} 处:\n ${statusOffenders.join('\n ')}`);
}
push(totalRuleChecks === urls.length * COMBOS * EXTRA_RULES.length,
`规则级通道总量 ${totalRuleChecks} ≠ ${urls.length}×${COMBOS}×${EXTRA_RULES.length} = ${urls.length * COMBOS * EXTRA_RULES.length}`);
// 绝对下限的分母闭合:三条规则 × 每一页 × 每一个组合,一个都不能少(0 违规 ≠ 没测到)。
push(totalCanonicalCoverage === expectedCanonicalCoverage,
`规则级覆盖 ${totalCanonicalCoverage} ≠ ${expectedCanonicalCoverage}` +
`(= ${urls.length} 路由 × ${COMBOS} 组合 × ${CANONICAL_EXTRA_RULES.length} 条下限规则 ${CANONICAL_EXTRA_RULES.join(', ')})`);
const artifact = {
generatedAt: new Date().toISOString(),
runDate: TARGETS.runDate,
// 落盘位置写进产物本身:这样即使有人打开的是 latest 指针副本,也能一眼看出它是**哪一轮**跑出来的
// (§11.6 那条「引用前必读」的口径提醒,从此由产物自证而不是靠人记)。仓库相对路径,不落机器绝对路径。
evidenceRunDir: relative(REPO_ROOT, TARGETS.out),
latestPointer: TARGETS.latest ? relative(REPO_ROOT, TARGETS.latest) : null,
base: BASE,
axeCore: JSON.parse(readFileSync(repoPath('node_modules/axe-core/package.json'), 'utf8')).version,
routeSource: `${SITEMAP} → ${urls.length} 条路由(sitemap ∪ 预渲染产物 ∪ 站内链接 BFS)`,
routeCount: urls.length,
routes: urls,
combinations: expectedCombos,
tags: TAGS,
extraRules: EXTRA_RULES,
requiredRuleCoverage: CANONICAL_EXTRA_RULES,
thresholds: {
colorContrastNodes: 0, violationNodes: 0, themeMismatch: 0, bgMismatch: 0,
extraRuleNodes: 0, extraRulePagesUnderCovered: 0,
rows: urls.length * COMBOS,
totalExtraRuleChecks: urls.length * COMBOS * EXTRA_RULES.length,
requiredRuleCoverageTotal: expectedCanonicalCoverage,
},
totalExtraRuleChecks: totalRuleChecks,
expectedExtraRuleChecks: urls.length * COMBOS * EXTRA_RULES.length,
totalRequiredRuleCoverage: totalCanonicalCoverage,
expectedRequiredRuleCoverage: expectedCanonicalCoverage,
passed: failures.length === 0,
failures,
summary,
rows,
};
writeEvidence(artifact, TARGETS);
console.log('\nSUMMARY', JSON.stringify(summary, null, 2));
console.log('PASSED =', artifact.passed);
console.log(`证据已按轮次写入 ${relative(REPO_ROOT, TARGETS.file)}` +
(TARGETS.latest ? `(并刷新 latest 指针 ${relative(REPO_ROOT, TARGETS.latest)})` : '(显式 OUT,未刷新 latest 指针)'));
if (!artifact.passed) {
console.error(`\nFAIL: axe 节点计数门禁 ${failures.length} 条判据未通过(证据已写入 ${relative(REPO_ROOT, TARGETS.file)})`);
for (const f of failures) console.error(` ✗ ${f}`);
process.exit(1);
}