An open source design system that's fully customizable and agent ready
TypeScript
ci(perf): compare timing metrics only on the same CPU model (#10535)
Cindy Zhang66a589bf1b34
diff --git a/.github/scripts/perf-trend.mjs b/.github/scripts/perf-trend.mjsindex e0bf3cbedd..b42fd1dbc2 100644--- a/.github/scripts/perf-trend.mjs+++ b/.github/scripts/perf-trend.mjs@@ -5,7 +5,8 @@* @file The nightly perf trend: compare a run's scene medians with the last* seven days of main and keep the history.* @input `--results <dir>` (one `<scene>.json` per scene from- * apps/sandbox/perf/scenes.perf.spec.ts), `--history <file>` (the previous+ * apps/sandbox/perf/scenes.perf.spec.ts, and its `runner.json`: the+ * runner's CPU model and calibration score), `--history <file>` (the previous* run's perf-history.json; may be missing), `--out <dir>`, and the run's* `--sha`, `--run-id`, `--run-url`, `--event`, `--ref`, `--repository`,* `--date` (ISO).@@ -25,11 +26,20 @@* 2 ms) is not a regression. A metric with fewer than three runs in the window* has no baseline yet. Every metric is better when lower.*- * A standard runner's speed swings by about a fifth from one machine to the- * next, more than the threshold, so one run over it is only pending: the- * regression is confirmed, and reported, when the metric was also over it on- * the recorded run before (the previous night, or a re-run dispatched right- * after). A run with any metric over the threshold is not a good run.+ * Standard runners come with different CPU models, and a timing metric (long+ * tasks, interaction latency) can double from one model to another on the+ * same commit. So a timing metric is compared only with the runs recorded on+ * the same CPU model. With fewer than three of those in the window it has no+ * baseline: the report and the summary list it as such, so a CPU change never+ * passes silently. Count metrics are compared with every+ * recorded run in the window. Each run records its CPU model and a fixed+ * calibration score; the score is kept for reference and gates nothing.+ *+ * On one CPU model a runner's speed still swings by about a fifth, more than+ * the threshold, so one run over it is only pending: the regression is+ * confirmed, and reported, when the metric was also over it on the recorded+ * run before (the previous night, or a re-run dispatched right after). A run+ * with any metric over the threshold is not a good run.** SYNC: METRICS names the fields of SceneSample in apps/sandbox/perf/measure.ts.*/@@ -43,12 +53,25 @@ export const WINDOW_DAYS = 7;export const MIN_BASELINE_RUNS = 3;export const HISTORY_LIMIT = 120;-/** metric → the smallest absolute worsening that can count, and its unit. */+/**+ * metric → the smallest absolute worsening that can count, its unit, and+ * whether it is a timing metric (compared only on the same CPU model).+ */export const METRICS = {- mountLongTaskMs: {floor: 20, unit: 'ms', label: 'Mount long tasks'},+ mountLongTaskMs: {+ floor: 20,+ unit: 'ms',+ label: 'Mount long tasks',+ timing: true,+ },mountLayouts: {floor: 2, unit: '', label: 'Mount layouts'},interactionLayouts: {floor: 2, unit: '', label: 'Interaction layouts'},- interactionMs: {floor: 16, unit: 'ms', label: 'Interaction latency'},+ interactionMs: {+ floor: 16,+ unit: 'ms',+ label: 'Interaction latency',+ timing: true,+ },heapDeltaKb: {floor: 256, unit: 'KB', label: 'Heap after unmount'},listenerDelta: {floor: 5, unit: '', label: 'Listeners after unmount'},};@@ -72,17 +95,23 @@ export function isRecordable({event, ref, repository}) {);}-/** scene → metric → {median, runs} over recorded runs in the window before `at`. */-export function baselineMedians(history, at) {+/**+ * scene → metric → {median, runs} over recorded runs in the window before+ * `at`. A timing metric counts only runs recorded on `cpu`; with no `cpu`, it+ * counts none.+ */+export function baselineMedians(history, at, cpu = null) {const end = Date.parse(at);const start = end - WINDOW_DAYS * DAY_MS;const values = {};for (const run of history.runs) {const time = Date.parse(run.date);if (!(time >= start && time < end)) continue;+ const sameCpu = cpu != null && run.runner?.cpu === cpu;for (const [scene, metrics] of Object.entries(run.scenes)) {for (const [metric, value] of Object.entries(metrics)) {if (typeof value !== 'number') continue;+ if (METRICS[metric]?.timing && !sameCpu) continue;((values[scene] ??= {})[metric] ??= []).push(value);}}@@ -105,6 +134,22 @@ export function isRegression(metric, value, base) {return value > base * (1 + THRESHOLD) && value - base >= floor;}+/**+ * Every timing metric with no baseline on this run's CPU model: fewer than+ * MIN_BASELINE_RUNS recorded runs on it in the window.+ */+export function findNoBaseline(scenes, baseline) {+ const missing = [];+ for (const [scene, metrics] of Object.entries(scenes)) {+ for (const [metric, {timing}] of Object.entries(METRICS)) {+ if (!timing || typeof metrics[metric] !== 'number') continue;+ const runs = baseline[scene]?.[metric]?.runs ?? 0;+ if (runs < MIN_BASELINE_RUNS) missing.push({scene, metric, runs});+ }+ }+ return missing;+}+/** Every scene metric that regressed against its baseline. */export function findRegressions(scenes, baseline) {const regressions = [];@@ -172,11 +217,28 @@ export function readHistory(file) {return history;}+export const RUNNER_FILE = 'runner.json';++/**+ * The runner the scenes ran on: `{cpu, calibrationMs}`, or `{cpu: null}` when+ * the driver wrote no runner file.+ */+export function readRunner(dir) {+ const file = path.join(dir, RUNNER_FILE);+ if (!fs.existsSync(file)) return {cpu: null, calibrationMs: null};+ const runner = JSON.parse(fs.readFileSync(file, 'utf8'));+ return {+ cpu: typeof runner.cpu === 'string' && runner.cpu ? runner.cpu : null,+ calibrationMs:+ typeof runner.calibrationMs === 'number' ? runner.calibrationMs : null,+ };+}+/** scene → metric → median, from the driver's result files. */export function readResults(dir) {const scenes = {};for (const name of fs.readdirSync(dir).sort()) {- if (!name.endsWith('.json')) continue;+ if (!name.endsWith('.json') || name === RUNNER_FILE) continue;const result = JSON.parse(fs.readFileSync(path.join(dir, name), 'utf8'));if (typeof result.scene !== 'string' || result.median == null) {throw new Error(`${name} is not a perf scene result`);@@ -201,6 +263,8 @@ export function renderSummary({baseline,regressions,pending = [],+ noBaseline = [],+ runner = {cpu: null, calibrationMs: null},range,recorded = true,}) {@@ -228,10 +292,20 @@ export function renderSummary({? "Compared with `main`'s 7-day median: no metric is more than 10% worse. This run is not recorded.": `Compared with \`main\`'s 7-day median: **${over} metric(s) are more than 10% worse** (⚠️). This run is not recorded.`,];+ const missing = new Set(noBaseline.map(metricKey));+ const cpu = runner.cpu ?? 'an unknown CPU';const lines = ['## Nightly perf scenes','',...headline,+ ...(noBaseline.length === 0+ ? []+ : [+ '',+ `${noBaseline.length} timing metric(s) have no baseline on ${cpu} (fewer than ${MIN_BASELINE_RUNS} recorded runs on it in 7 days), so they are not compared (no baseline).`,+ ]),+ '',+ `Runner: ${cpu}${runner.calibrationMs == null ? '' : `, calibration ${runner.calibrationMs} ms`}. Timing metrics compare with runs on the same CPU model.`,'',`| Scene | ${Object.values(METRICS).map(m => m.label)@@ -245,6 +319,7 @@ export function renderSummary({const base = baseline[scene]?.[metric];const key = metricKey({scene, metric});const mark = confirmed.has(key) ? ' ⚠️' : first.has(key) ? ' ⏳' : '';+ if (missing.has(key)) return `${format(metric, value)} (no baseline)`;return base && base.runs >= MIN_BASELINE_RUNS? `${format(metric, value)} (7d ${format(metric, base.median)})${mark}`: format(metric, value);@@ -261,9 +336,15 @@ export function renderSummary({}/** Compares a run with the history; returns the report and the next history. */-export function evaluateRun({scenes, history, run}) {- const baseline = baselineMedians(history, run.date);+export function evaluateRun({+ scenes,+ history,+ run,+ runner = {cpu: null, calibrationMs: null},+}) {+ const baseline = baselineMedians(history, run.date, runner.cpu);const overThreshold = findRegressions(scenes, baseline);+ const noBaseline = findNoBaseline(scenes, baseline);const {confirmed: regressions, pending} = confirmRegressions(overThreshold,history,@@ -281,6 +362,8 @@ export function evaluateRun({scenes, history, run}) {date: run.date,good: overThreshold.length === 0,overThreshold: overThreshold.map(metricKey),+ noBaseline: noBaseline.map(metricKey),+ runner,scenes,}): history;@@ -295,6 +378,8 @@ export function evaluateRun({scenes, history, run}) {range,regressions,pending,+ noBaseline,+ runner,},baseline,nextHistory,@@ -309,13 +394,21 @@ export function evaluateRun({scenes, history, run}) {*/export function runReport({resultsDir, historyFile, outDir, run}) {const scenes = readResults(resultsDir);+ const runner = readRunner(resultsDir);const history = readHistory(historyFile);- const {report, baseline, nextHistory} = evaluateRun({scenes, history, run});+ const {report, baseline, nextHistory} = evaluateRun({+ scenes,+ history,+ run,+ runner,+ });const summary = renderSummary({scenes,baseline,regressions: report.regressions,pending: report.pending,+ noBaseline: report.noBaseline,+ runner,range: report.range,recorded: report.recorded,});diff --git a/.github/scripts/perf-trend.test.mjs b/.github/scripts/perf-trend.test.mjsindex 078ca6e531..d6eba7c16a 100644--- a/.github/scripts/perf-trend.test.mjs+++ b/.github/scripts/perf-trend.test.mjs@@ -18,12 +18,14 @@ import {appendRun,baselineMedians,evaluateRun,+ findNoBaseline,findRegressions,isRecordable,isRegression,lastGoodRun,median,readResults,+ readRunner,renderSummary,runReport,} from './perf-trend.mjs';@@ -41,12 +43,18 @@ const SCENE = {listenerDelta: 0,};+const CPU_A = 'AMD EPYC 7763 64-Core Processor';+const CPU_B = 'Intel(R) Xeon(R) Platinum 8370C CPU @ 2.80GHz';+const RUNNER_A = {cpu: CPU_A, calibrationMs: 40};+const RUNNER_B = {cpu: CPU_B, calibrationMs: 75};+function run(days, scenes = {table: SCENE}, extra = {}) {return {sha: `sha-${days}`,runId: days,date: daysBefore(days),good: true,+ runner: RUNNER_A,scenes,...extra,};@@ -222,6 +230,7 @@ describe('evaluateRun', () => {scenes: {table: {...SCENE, mountLongTaskMs: 200}},history,run: NIGHTLY,+ runner: RUNNER_A,});expect(report.regressions.map(r => r.metric)).toEqual(['mountLongTaskMs']);expect(report.pending).toEqual([]);@@ -239,6 +248,7 @@ describe('evaluateRun', () => {scenes: {table: {...SCENE, mountLongTaskMs: 200}},history: firstTime,run: NIGHTLY,+ runner: RUNNER_A,});expect(report.regressions).toEqual([]);expect(report.pending.map(r => r.metric)).toEqual(['mountLongTaskMs']);@@ -254,6 +264,7 @@ describe('evaluateRun', () => {scenes: {table: {...SCENE, mountLayouts: 20}},history,run: NIGHTLY,+ runner: RUNNER_A,});expect(report.regressions).toEqual([]);expect(report.pending.map(r => r.metric)).toEqual(['mountLayouts']);@@ -264,6 +275,7 @@ describe('evaluateRun', () => {scenes: {table: {...SCENE, mountLongTaskMs: 200}},history: firstTime,run: NIGHTLY,+ runner: RUNNER_A,});expect(report.regressions).toEqual([]);});@@ -273,6 +285,7 @@ describe('evaluateRun', () => {scenes: {table: SCENE},history,run: NIGHTLY,+ runner: RUNNER_A,});expect(report.regressions).toEqual([]);expect(report.pending).toEqual([]);@@ -288,6 +301,7 @@ describe('evaluateRun', () => {scenes: {table: {...SCENE, mountLongTaskMs: 200}},history,run: {...NIGHTLY, event: 'pull_request', ref: 'refs/pull/1/merge'},+ runner: RUNNER_A,});expect(report.regressions).toHaveLength(1);expect(report.recorded).toBe(false);@@ -295,6 +309,155 @@ describe('evaluateRun', () => {});});+describe('timing metrics on different CPU models', () => {+ // Five nights on CPU A, then the previous night on CPU B, where the same+ // commit's timing metrics are about 75% higher.+ const slow = {...SCENE, mountLongTaskMs: 175, interactionMs: 140};+ const crossCpu = {+ version: 1,+ runs: [+ run(6),+ run(5),+ run(4),+ run(3),+ run(2),+ run(+ 1,+ {table: slow},+ {+ runner: RUNNER_B,+ good: false,+ noBaseline: ['table/mountLongTaskMs', 'table/interactionMs'],+ },+ ),+ ],+ };++ it('does not call a slower CPU model a regression, and reports no baseline instead', () => {+ const {report, nextHistory} = evaluateRun({+ scenes: {table: slow},+ history: crossCpu,+ run: NIGHTLY,+ runner: RUNNER_B,+ });+ expect(report.regressions).toEqual([]);+ expect(report.pending).toEqual([]);+ expect(report.noBaseline).toEqual([+ {scene: 'table', metric: 'mountLongTaskMs', runs: 1},+ {scene: 'table', metric: 'interactionMs', runs: 1},+ ]);+ // Never a silent pass: the run records which metrics had no baseline.+ expect(nextHistory.runs.at(-1)).toMatchObject({+ good: true,+ runner: RUNNER_B,+ noBaseline: ['table/mountLongTaskMs', 'table/interactionMs'],+ });+ });++ it('still finds a timing regression on the same CPU model', () => {+ const history = {+ version: 1,+ runs: [+ run(4, {table: slow}, {runner: RUNNER_B}),+ run(3, {table: slow}, {runner: RUNNER_B}),+ run(2, {table: slow}, {runner: RUNNER_B}),+ run(+ 1,+ {table: {...slow, mountLongTaskMs: 260}},+ {+ runner: RUNNER_B,+ good: false,+ overThreshold: ['table/mountLongTaskMs'],+ },+ ),+ ],+ };+ const {report} = evaluateRun({+ scenes: {table: {...slow, mountLongTaskMs: 260}},+ history,+ run: NIGHTLY,+ runner: RUNNER_B,+ });+ expect(report.regressions.map(r => r.metric)).toEqual(['mountLongTaskMs']);+ expect(report.noBaseline).toEqual([]);+ });++ it('compares count metrics with every CPU model', () => {+ const {report} = evaluateRun({+ scenes: {table: {...slow, interactionLayouts: 20}},+ history: crossCpu,+ run: NIGHTLY,+ runner: RUNNER_B,+ });+ expect(report.pending.map(r => r.metric)).toEqual(['interactionLayouts']);+ });++ it('gives a first run on a CPU model no baseline for its timing metrics', () => {+ const {report, nextHistory} = evaluateRun({+ scenes: {table: SCENE},+ history: {version: 1, runs: []},+ run: NIGHTLY,+ runner: RUNNER_A,+ });+ expect(report.noBaseline.map(r => r.metric)).toEqual([+ 'mountLongTaskMs',+ 'interactionMs',+ ]);+ expect(nextHistory.runs.at(-1).noBaseline).toEqual([+ 'table/mountLongTaskMs',+ 'table/interactionMs',+ ]);+ });++ it('gives a run with no CPU model no timing baseline', () => {+ expect(+ findNoBaseline(+ {table: SCENE},+ baselineMedians({version: 1, runs: [run(3), run(2), run(1)]}, NOW),+ ).map(r => r.metric),+ ).toEqual(['mountLongTaskMs', 'interactionMs']);+ });++ it('counts only same-CPU runs in a timing baseline, and every run in a count baseline', () => {+ const baseline = baselineMedians(crossCpu, NOW, CPU_A);+ expect(baseline.table.mountLongTaskMs).toEqual({median: 100, runs: 5});+ expect(baseline.table.mountLayouts).toEqual({median: 10, runs: 6});+ });++ it('lists the metrics with no baseline in the summary', () => {+ const summary = renderSummary({+ scenes: {table: slow},+ baseline: baselineMedians(crossCpu, NOW, CPU_B),+ regressions: [],+ noBaseline: [{scene: 'table', metric: 'mountLongTaskMs', runs: 1}],+ runner: RUNNER_B,+ });+ expect(summary).toContain(`no baseline on ${CPU_B}`);+ expect(summary).toContain('175 ms (no baseline)');+ expect(summary).toContain(`Runner: ${CPU_B}, calibration 75 ms`);+ });+});++describe('readRunner', () => {+ it('reads the runner file, and skips it among the scene results', () => {+ const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'perf-trend-'));+ fs.writeFileSync(path.join(dir, 'runner.json'), JSON.stringify(RUNNER_B));+ fs.writeFileSync(+ path.join(dir, 'table.json'),+ JSON.stringify({scene: 'table', samples: [SCENE], median: SCENE}),+ );+ expect(readRunner(dir)).toEqual(RUNNER_B);+ expect(Object.keys(readResults(dir))).toEqual(['table']);+ fs.rmSync(dir, {recursive: true, force: true});+ });++ it('reads no CPU model when the driver wrote no runner file', () => {+ const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'perf-trend-'));+ expect(readRunner(dir)).toEqual({cpu: null, calibrationMs: null});+ fs.rmSync(dir, {recursive: true, force: true});+ });+});+describe('runReport', () => {it('reads the driver results, starts a history when none exists, and writes the report', () => {const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'perf-trend-'));@@ -304,6 +467,10 @@ describe('runReport', () => {path.join(results, 'table.json'),JSON.stringify({scene: 'table', samples: [SCENE], median: SCENE}),);+ fs.writeFileSync(+ path.join(results, 'runner.json'),+ JSON.stringify(RUNNER_A),+ );const out = path.join(dir, 'out');const {report, summary, earlierRuns} = runReport({resultsDir: results,@@ -318,6 +485,9 @@ describe('runReport', () => {fs.readFileSync(path.join(out, 'perf-history.json'), 'utf8'),);expect(written.runs).toHaveLength(1);+ // runner.json reaches the history and the summary.+ expect(written.runs[0].runner).toEqual(RUNNER_A);+ expect(summary).toContain(`Runner: ${CPU_A}`);expect(fs.existsSync(path.join(out, 'report.json'))).toBe(true);fs.rmSync(dir, {recursive: true, force: true});});diff --git a/apps/sandbox/perf/scenes.perf.spec.ts b/apps/sandbox/perf/scenes.perf.spec.tsindex 2fd5c7d93b..ba8620723e 100644--- a/apps/sandbox/perf/scenes.perf.spec.ts+++ b/apps/sandbox/perf/scenes.perf.spec.ts@@ -7,7 +7,10 @@* PERF_RESULTS_DIR (default test-results/perf), PERF_CPU_THROTTLE (default* 1: Chromium's CPU slowed this many times, to check that a count does not* follow the runner's speed)- * @output One JSON file per scene: every sample and the per-metric median+ * @output One JSON file per scene: every sample and the per-metric median;+ * and runner.json: the runner's CPU model and a calibration score (the+ * median time of a fixed script in Chromium), so the trend compares timing+ * metrics only between runs on the same CPU model* @position The perf scenes' measurement driver. Run locally with* `pnpm build && pnpm -F @astryxdesign/sandbox build` then* `pnpm exec playwright test --config playwright.perf.config.ts`.@@ -21,6 +24,7 @@*/import fs from 'node:fs';+import os from 'node:os';import path from 'node:path';import {expect, test, type Page} from '@playwright/test';import {@@ -50,13 +54,49 @@ const OVERLAY_CYCLES = 50;const ENTRANCE_SETTLE_MS = 250;const SANDBOX_DIR = 'apps/sandbox/out';+const CALIBRATION_RUNS = 5;++/**+ * The median time, in ms, of a fixed CPU-bound script in a blank Chromium+ * page. It describes the runner and gates nothing.+ */+async function calibrate(page: Page): Promise<number> {+ const times: number[] = [];+ for (let run = 0; run < CALIBRATION_RUNS; run++) {+ times.push(+ await page.evaluate(() => {+ const start = performance.now();+ let sum = 0;+ for (let i = 0; i < 20_000_000; i++) sum += Math.sqrt(i);+ // Using the sum keeps the loop from being optimized away.+ return performance.now() - start + (sum < 0 ? 1 : 0);+ }),+ );+ }+ return Math.round(median(times) * 10) / 10;+}+let server: StaticServer | undefined;-test.beforeAll(async () => {+test.beforeAll(async ({browser}) => {server = await serveStatic(SANDBOX_DIR, {sentinel: 'pages/perf-scenes/index.html',missing: root =>`No built Sandbox with the perf scenes at ${root}. Run \`pnpm build && pnpm -F @astryxdesign/sandbox build\` first.`,});+ const context = await browser.newContext();+ try {+ const runner = {+ cpu: os.cpus()[0]?.model.trim() || null,+ calibrationMs: await calibrate(await context.newPage()),+ };+ fs.mkdirSync(RESULTS_DIR, {recursive: true});+ fs.writeFileSync(+ path.join(RESULTS_DIR, 'runner.json'),+ `${JSON.stringify(runner, null, 2)}\n`,+ );+ } finally {+ await context.close();+ }});test.afterAll(async () => {await server?.close();diff --git a/docs/specs/AST-030/spec.md b/docs/specs/AST-030/spec.mdindex a0e661b3ad..527f475aeb 100644--- a/docs/specs/AST-030/spec.md+++ b/docs/specs/AST-030/spec.md@@ -440,7 +440,13 @@ they are separately named.listeners left after unmount, as the median of several samples. Its result istrend data: it reports no required context and gates no merge or release. Anightly or dispatched run on `main` is compared with the median of `main`'s- recorded runs in the seven days before it; a metric more than 10% worse, and+ recorded runs in the seven days before it, as follows: each run records its+ CPU model and a calibration score; a timing metric (mount long tasks,+ interaction latency) is compared only with those runs recorded on the same+ CPU model, and with fewer than three of them, that metric has no baseline,+ informational and never a pass; a calibration-normalized comparison may be+ shown beside it but gates nothing; count metrics are compared with all of+ them. A metric more than 10% worse, andworse by at least that metric's floor, on that run and on the recorded runbefore it opens the one open regression issue or comments on it, naming thecommits since the last run with no metric over the threshold. A metric over@@ -664,6 +670,7 @@ The nightly perf lane is the one scheduled measurement outside them (FR18).| FR17 | `ci-pr-gate.test.mjs` over every `pull_request` workflow and the shared conditions | branch here, fork with and without `ci:run`, another label, draft with the label, ready, push, merge group, dispatch | a job that can start on a pull request without the condition, a label trigger, a required job that skips for a pull request that may not run CI, or a draft or unlabelled fork that runs fails || FR18 | `perf-nightly-workflow.test.mjs`, `perf-trend.test.mjs` and `run-labels.test.mjs` | nightly and dispatch; labelled, unlabelled, draft and unvouched-fork pull requests; write, read and no access; newest label event; failed lookup; 10% boundary; metric floors; seven-day window edges; fewer than three runs; a metric over once, twice in a row, or a different metric before; recorded and pull request runs | a run on an unlabelled pull request, a label honoured from read access, a regression called at exactly 10%, under its floor or on one run alone, a run outside the window in the baseline, a pull request run that records, or a second regression issue fails || FR18 | `overlay-churn-settled` on one commit, five samples per run | medians within 1% between a standard run and a `PERF_CPU_THROTTLE=4` run on the same runner (Chromium's CPU slowed four times) | interaction-layout medians more than 1% apart fail |+| FR18 | `perf-trend.test.mjs` same-CPU cases | a run on a second CPU model whose timing metrics are about 75% higher on the same commit; a timing regression on one CPU model; a count metric across CPU models; a first run, and a run with no CPU model, with no timing baseline | a slower CPU model reported as a regression, a same-CPU timing regression missed, a count metric compared on one CPU model only, or a timing metric with no baseline that passes silently fails || FR19 | `ci-impact.test.mjs`, `pr-preview.test.mjs` and the maintenance template | CI change and non-CI change; standard, non-standard and expression runners; added, removed and changed jobs; trigger change | a CI change reports no impact, a move onto a non-standard runner or a pool or time-to-green rise past its threshold goes unflagged, or the section names a price || FR20 | `ci-heavy-deferral.test.mjs` over ci.yml, lint.yml and pr-comment.yml | agent push; marked ready; opened; reopened; re-run; another author; release branch; merge-back; spec-only change; Lab-only change; a release-check and an opt-in label run, where the decision skips; a failed-jobs re-run of a deferred push | a heavy job runs on a deferred push, a required context passes or skips on one, a ready, reopened or re-run pull request defers, a spec-only or Lab-only change defers, the report hides the deferral, or a job below the decision skips because it skipped || FR21 | `ci-heavy-lanes.test.mjs` dispatch cases, `main-unit-run.test.mjs` over deploy.yml, `release-check-receipt.test.mjs` | push run; dispatched unit run; tip with the scheduler's or a person's release-check, or a person's maintenance capture; unit run cancelled, skipped or timed out; newer recheck or person's run of the tip; a person's validation of an older commit; cut commit with and without a passing unit run | a push runs the unit suites, a push cancels a unit run, a release-check comes without a unit run of its commit, an incomplete run goes unreported or waits a window, or a cut publishes without a passing unit run |