pixel-perfect-kit 0.1.0

package/harness/benchmarks/README.md

@@ -0,0 +1,34 @@
+# benchmarks — score the gate's detection power (the scientific instrument)
+
+Fixtures lock in *one* past miss each. This battery scores the gate across *all* known
+defect classes at once, so a proposed change to the gate can be judged objectively:
+**did it catch more without inventing false positives?**
+
+- **`battery.js`** — a fixed, labelled corpus of snapshot pairs: DEFECTS (a correct gate
+  must FAIL) and CONTROLS incl. adversarial false-positive hunters (a correct gate must
+  PASS). Each case traces to a `LEARNINGS.md` entry. Extend it whenever a new class of
+  miss — or a new false-positive risk — is found.
+- **`detection-power.js`** — the runner, two modes:
+
+```sh
+# ABSOLUTE (CI guard, run by harness/regression.js): the current gate must catch every
+# defect and flag no control. Exit 0 = clean.
+node harness/benchmarks/detection-power.js
+
+# A/B: compare a baseline gate to the working-tree gate, case by case. Run this BEFORE
+# adopting a gate change — it isolates exactly what the change adds or breaks.
+node harness/benchmarks/detection-power.js --vs HEAD
+node harness/benchmarks/detection-power.js --vs path/to/old/pixel-diff.js
+```
+
+## The rule for changing the gate (the method)
+
+Never adopt a gate change on "looks better." Score it:
+
+1. Add the new defect (and any false-positive risk it introduces) as cases in `battery.js`.
+2. `--vs HEAD` — the bar is **+N defect classes gained, 0 regressions** (0 missed defects,
+   0 new false positives). A single-variable diff is ideal.
+3. If it shows a regression (e.g. an adversarial control now flags), fix the gate and
+   re-run until the A/B is clean — *then* commit. The backdrop-colour gate (`bg`, #16) was
+   adopted this way: the naive version false-positived on translucent/whitespace controls;
+   the battery caught it before commit.

package/harness/benchmarks/battery.js

@@ -0,0 +1,86 @@
+// battery.js — the fixed set of known visual DEFECTS + negative CONTROLS the gate is
+// scored against. This is the kit's detection-power *instrument*: a labelled corpus,
+// separate from any one target, so a proposed gate change can be measured objectively
+// (see detection-power.js). Each case is a pair of snapshots differing by exactly one
+// thing:
+//   • DEFECT  → a visibly wrong clone; a correct gate must FAIL it (catch it). A miss is
+//     a defect that would slip a green run and cost a human round.
+//   • CONTROL → visually identical; a correct gate must PASS it. A flag here is a FALSE
+//     POSITIVE — friction the gate invented, which can regress a previously-green clone.
+// Add a case whenever a new class of miss (or a new false-positive risk) is found — the
+// battery is how "did this change improve detection without adding noise?" becomes a
+// number instead of a vibe. Zero deps, no DOM, fully deterministic.
+
+const textEl = (over = {}) => ({
+  present: true,
+  rect: { x: 100, y: 80, w: 180, h: 17, top: 80, right: 280, bottom: 97, fromRight: 200 },
+  font: { family: "proxima-nova", weight: "600", size: 14, line: 18.2, spacing: 0.7,
+          transform: "uppercase", color: "rgb(0,0,0)", decoration: "none", smoothing: "antialiased",
+          underline: false, ...(over.font || {}) },
+  box: { padT: 0, padB: 0 }, layout: { display: "flex", position: "static" }, parent: { display: "flex", gap: 8 },
+  text: { x: 100, right: 280, top: 80, bottom: 97, w: 180, h: 17, ...(over.text || {}) },
+  underline: over.underline !== undefined ? over.underline : { present: false },
+  bg: over.bg !== undefined ? over.bg : "rgb(255,255,255)",
+});
+const gfxEl = (over = {}) => ({
+  present: true,
+  rect: { x: 100, y: 79, w: 20, h: 20, top: 79, right: 120, bottom: 99, fromRight: 200 },
+  font: {}, box: {}, layout: { display: "inline-block", position: "static" }, parent: { display: "flex", gap: 8 },
+  glyph: { cx: 110, cy: 89, w: 20, h: 20, bgPos: "0% 0%", ...(over.glyph || {}) },
+  bg: over.bg !== undefined ? over.bg : "rgb(255,255,255)",
+});
+const snap = (el) => ({ viewport: { width: 1728 }, elements: { t: el } });
+
+const UL = { present: true, thickness: 2, x: 90, right: 280, w: 190, top: 99, bottom: 101 };
+
+// [name, kind, liveEl, cloneEl, note, mods?].  Each name should trace to a LEARNINGS entry.
+// mods = optional snapshot-level overrides for page-level props: { liveMode, cloneMode }.
+const battery = [
+  // ── DEFECTS — a correct gate FAILS each ──
+  ["backdrop-color",     "defect", textEl({ bg: "rgb(113,198,235)" }), textEl({ bg: "rgb(255,0,0)" }), "blue bar vs red bar (#16)"],
+  ["text-color",         "defect", textEl(), textEl({ font: { color: "rgb(255,255,255)" } }), "black vs white text (#10)"],
+  ["underline-missing",  "defect", textEl({ underline: UL, font: { underline: true } }), textEl({ underline: { present: false }, font: { underline: false } }), "underline present vs gone (#11)"],
+  ["underline-thin",     "defect", textEl({ underline: UL }), textEl({ underline: { ...UL, thickness: 1 } }), "2px vs 1px (#12)"],
+  ["underline-short",    "defect", textEl({ underline: UL }), textEl({ underline: { ...UL, w: 150, right: 240 } }), "190 vs 150 wide (#12)"],
+  ["underline-y",        "defect", textEl({ underline: UL }), textEl({ underline: { ...UL, top: 103, bottom: 105 } }), "shifted 4px down (#12)"],
+  ["smoothing",          "defect", textEl(), textEl({ font: { smoothing: "auto" } }), "antialiased vs auto (#13)"],
+  ["glyph-cy",           "defect", gfxEl(), gfxEl({ glyph: { cy: 92 } }), "icon 3px low (#9)"],
+  ["glyph-cx",           "defect", gfxEl(), gfxEl({ glyph: { cx: 114 } }), "icon 4px right (#1/#9)"],
+  ["line-height",        "defect", textEl(), textEl({ font: { line: 14 } }), "18.2 vs 14 (#2)"],
+  ["line-strut",         "defect", textEl({ font: { strut: 16 } }), textEl({ font: { strut: "normal" } }), "container 16px vs normal, leaf matches (#17)"],
+  ["line-strut-numeric", "defect", textEl({ font: { strut: 16 } }), textEl({ font: { strut: 18 } }), "container 16 vs 18 (#17)"],
+  ["compat-mode",        "defect", textEl(), textEl(), "quirks vs standards doc mode (#18)", { liveMode: "BackCompat", cloneMode: "CSS1Compat" }],
+  ["letter-spacing",     "defect", textEl(), textEl({ font: { spacing: 2 } }), "0.7 vs 2 (#2)"],
+  ["font-size",          "defect", textEl(), textEl({ font: { size: 16 } }), "14 vs 16 (#3)"],
+  // ── CONTROLS — a correct gate PASSES each (no false positive) ──
+  ["identical-text",     "control", textEl(), textEl(), "same in every paint prop"],
+  ["identical-gfx",      "control", gfxEl(), gfxEl(), "same glyph"],
+  ["structural-only",    "control", textEl(), textEl({ box: { padT: 24, padB: 24 }, layout: { display: "block", position: "relative" }, parent: { display: "block", gap: 0 }, font: { family: "proxima" } }), "flex/pad/alias differ, pixels same (#6)"],
+  ["backdrop-transparent","control", textEl({ bg: "rgba(0, 0, 0, 0)" }), textEl({ bg: "rgba(0, 0, 0, 0)" }), "both transparent → skipped"],
+  // adversarial controls — false-positive hunters for the backdrop gate (#16)
+  ["adv-same-translucent","control", textEl({ bg: "rgba(0, 0, 0, 0.5)" }), textEl({ bg: "rgba(0, 0, 0, 0.5)" }), "same translucent → pass"],
+  ["adv-translucent-vs-solid","control", textEl({ bg: "rgba(0, 0, 0, 0.5)" }), textEl({ bg: "rgb(128,128,128)" }), "translucent vs solid — out of scope, no flag"],
+  ["adv-whitespace",     "control", textEl({ bg: "rgb(113,198,235)" }), textEl({ bg: "rgb(113, 198, 235)" }), "same colour, different spacing"],
+  // adversarial controls — false-positive hunters for the strut gate (#17)
+  ["adv-strut-same-normal","control", textEl({ font: { strut: "normal" } }), textEl({ font: { strut: "normal" } }), "same technique on both → pass"],
+  ["adv-strut-old-schema","control", textEl(), textEl({ font: { strut: 16 } }), "one capture predates strut → skipped, no flag"],
+  // adversarial controls — false-positive hunters for the compat-mode gate (#18)
+  ["adv-mode-same",      "control", textEl(), textEl(), "both quirks → pass", { liveMode: "BackCompat", cloneMode: "BackCompat" }],
+  ["adv-mode-old-schema","control", textEl(), textEl(), "one capture predates mode → skipped, no flag", { liveMode: "BackCompat" }],
+];
+
+// Score a gate (a diffSnapshots fn) over the battery. Returns per-case rows + totals.
+function scoreGate(diffSnapshots) {
+  let caught = 0, defects = 0, falsePos = 0, controls = 0;
+  const rows = battery.map(([name, kind, live, clone, note, mods]) => {
+    const L = snap(live), C = snap(clone);
+    if (mods) { if (mods.liveMode) L.mode = mods.liveMode; if (mods.cloneMode) C.mode = mods.cloneMode; }
+    const pass = diffSnapshots(L, C, { visual: true }).ok;
+    if (kind === "defect") { defects++; if (!pass) caught++; }
+    else { controls++; if (!pass) falsePos++; }
+    return { name, kind, pass, note, correct: kind === "defect" ? !pass : pass };
+  });
+  return { rows, caught, defects, falsePos, controls };
+}
+
+module.exports = { battery, scoreGate, snap };

package/harness/benchmarks/detection-power.js

@@ -0,0 +1,75 @@
+// detection-power.js — score the gate's detection power against the fixed battery.
+//
+// This is the kit's SCIENTIFIC instrument for gate changes: "did this change catch more
+// defects without inventing false positives?" as a number, not a vibe. Two modes:
+//
+//   node harness/benchmarks/detection-power.js
+//       ABSOLUTE (CI guard): score the CURRENT gate. Exit 0 only if every DEFECT is
+//       caught and NO control is flagged. Wired into harness/regression.js.
+//
+//   node harness/benchmarks/detection-power.js --vs HEAD
+//   node harness/benchmarks/detection-power.js --vs <path/to/old/pixel-diff.js>
+//       A/B: compare a BASELINE gate (a git ref's tools/pixel-diff.js, or a file) to the
+//       current working-tree gate, case by case. Use this BEFORE adopting a gate change —
+//       it isolates exactly what the change adds (caught) or breaks (false positive). A
+//       single-variable diff (one new row of ← DIFFERENCE, zero new FALSE+) is the bar.
+//
+// Zero deps, deterministic, no DOM. Extend the corpus in battery.js.
+
+const path = require("path");
+const { scoreGate } = require("./battery.js");
+const NEW = require("../../tools/pixel-diff.js");
+
+const args = process.argv.slice(2);
+const vsIdx = args.indexOf("--vs");
+const pad = (s, n) => String(s).padEnd(n);
+
+if (vsIdx === -1) {
+  // ── ABSOLUTE mode ── current gate must catch all defects and flag no controls.
+  const r = scoreGate(NEW.diffSnapshots);
+  console.log(pad("case", 24) + pad("kind", 9) + "result");
+  console.log("─".repeat(52));
+  for (const row of r.rows)
+    console.log(pad(row.name, 24) + pad(row.kind, 9) +
+      (row.correct ? (row.kind === "defect" ? "caught ✓" : "pass ✓") : (row.kind === "defect" ? "MISS ✗" : "FALSE+ ✗")));
+  console.log("─".repeat(52));
+  console.log(`defects caught:  ${r.caught}/${r.defects}`);
+  console.log(`false positives: ${r.falsePos}/${r.controls}`);
+  const ok = r.caught === r.defects && r.falsePos === 0;
+  console.log(ok
+    ? `\n✓ detection-power: all ${r.defects} defect classes caught, 0 false positives.`
+    : `\n❌ detection-power: ${r.defects - r.caught} missed, ${r.falsePos} false positive(s).`);
+  process.exit(ok ? 0 : 1);
+}
+
+// ── A/B mode ── load a baseline gate and compare it to the current one.
+const ref = args[vsIdx + 1];
+if (!ref) { console.error("usage: --vs <git-ref | path/to/pixel-diff.js>"); process.exit(2); }
+let baselinePath = ref;
+if (!ref.includes("/") && !ref.endsWith(".js")) {
+  // treat as a git ref → materialise its tools/pixel-diff.js to a temp file we can require
+  const { execFileSync } = require("child_process");
+  const os = require("os"), fs = require("fs");
+  const src = execFileSync("git", ["show", `${ref}:tools/pixel-diff.js`], { cwd: path.resolve(__dirname, "..", "..") });
+  baselinePath = path.join(os.tmpdir(), `pixel-diff.${ref.replace(/[^a-z0-9]/gi, "_")}.js`);
+  fs.writeFileSync(baselinePath, src);
+}
+const OLD = require(path.resolve(baselinePath));
+const a = scoreGate(OLD.diffSnapshots), b = scoreGate(NEW.diffSnapshots);
+
+console.log(pad("case", 24) + pad("kind", 9) + pad(`OLD (${ref})`, 16) + pad("NEW (worktree)", 16) + "note");
+console.log("─".repeat(92));
+let gained = 0, broke = 0;
+for (let i = 0; i < a.rows.length; i++) {
+  const ra = a.rows[i], rb = b.rows[i];
+  const mark = (row) => row.kind === "defect" ? (row.pass ? "MISS" : "caught") : (row.pass ? "pass" : "FALSE+");
+  let flag = "";
+  if (ra.kind === "defect" && !ra.pass !== !rb.pass) { flag = rb.correct ? "  ← GAINED" : "  ← LOST"; rb.correct ? gained++ : broke++; }
+  if (ra.kind === "control" && ra.pass && !rb.pass) { flag = "  ← NEW FALSE+"; broke++; }
+  console.log(pad(ra.name, 24) + pad(ra.kind, 9) + pad(mark(ra), 16) + pad(mark(rb), 16) + ra.note + flag);
+}
+console.log("─".repeat(92));
+console.log(`defects caught:   OLD ${a.caught}/${a.defects}   NEW ${b.caught}/${b.defects}`);
+console.log(`false positives:  OLD ${a.falsePos}/${a.controls}   NEW ${b.falsePos}/${b.controls}`);
+console.log(`\nverdict: +${gained} defect class(es) gained, ${broke} regression(s) (missed defect or new false positive).`);
+process.exit(broke ? 1 : 0);

package/harness/capture-build-selftest.js

@@ -0,0 +1,134 @@
+// harness/capture-build-selftest.js — guards the capture-build tool (the default build
+// strategy, LEARNINGS #19). Runs capture-build end-to-end against a file:// "live site"
+// (offline, socket-free — sandboxes that block loopback connects can still run it) and
+// asserts every contract:
+//   - doctype PRESERVED byte-for-byte — absent stays absent (quirks, #18), present stays present
+//   - <script>/script-preloads/CSP <meta>/<base> stripped
+//   - stylesheets downloaded + self-hosted; SRI/crossorigin dropped from rewritten links
+//   - fonts downloaded to /assets/fonts/ with REAL bytes (the assets gate checks wOF2 magic)
+//   - every other ref absolutized (src/srcset/poster/inline-style url()); data: untouched;
+//     anchor hrefs untouched; loading=lazy → eager
+//   - a failed stylesheet download exits nonzero (pixel-determining, never silent)
+// Run: node harness/capture-build-selftest.js   (regression.js runs it too)
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { execFileSync } = require("child_process");
+const { pathToFileURL } = require("url");
+
+const TOOL = path.join(__dirname, "capture-build.js");
+let failed = 0;
+const check = (label, ok, detail) => {
+  console.log(`${ok ? "✓" : "✗"} ${label}${ok || !detail ? "" : ` — ${detail}`}`);
+  if (!ok) failed++;
+};
+
+const work = fs.mkdtempSync(path.join(os.tmpdir(), "ppk-capbuild-"));
+
+// ── a tiny live-site stand-in on disk (served via file:// — no sockets) ───────
+const site = path.join(work, "site");
+fs.mkdirSync(path.join(site, "assets"), { recursive: true });
+fs.writeFileSync(path.join(site, "assets", "brand.woff2"), Buffer.concat([Buffer.from("wOF2"), Buffer.alloc(28, 7)]));
+fs.writeFileSync(path.join(site, "assets", "site.css"), [
+  '@font-face{font-family:X;src:url(./brand.woff2) format("woff2")}',
+  "@import url(./extra.css);",
+  ".rel{background:url(./img/rel.png)}",
+  ".abs{background:url(https://cdn.example.com/pic.png)}",
+  ".data{background:url(data:image/png;base64,AAAA)}",
+].join("\n"));
+const origin = pathToFileURL(site).href; // file:///…/site — target.json url = `${origin}/`
+
+function domHtml(doctype, cssHref) {
+  return `${doctype}<html><head>
+<meta http-equiv="Content-Security-Policy" content="default-src 'self'">
+<base href="https://example.com/">
+<link rel="preload" href="./app.js" as="script">
+<link rel="modulepreload" href="./chunk.mjs">
+<link rel="stylesheet" href="${cssHref}" integrity="sha384-bogus" crossorigin="anonymous">
+<link rel="preconnect" href="https://cdn.example.com/css2?family=A&amp;family=B&amp;display=swap">
+<style>.inline{background:url(/img/inline.png)}</style>
+<script src="./app.js"></script>
+<script>window.hydrate()</script>
+</head><body>
+<img loading="lazy" src="./img/a.png" srcset="./img/a.png 1x, ./img/a@2x.png 2x">
+<video poster="./img/poster.jpg"><source src="./vid/v.mp4"></video>
+<a href="/pricing">Pricing</a>
+</body></html>`;
+}
+
+// Run capture-build for one synthetic target; returns { status, out, cloneDir }.
+function run(name, doctype, cssHref, extraFlags) {
+  const dir = path.join(work, "targets", name);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, "target.json"), JSON.stringify({ name, url: `${origin}/`, width: 1280 }));
+  fs.writeFileSync(path.join(dir, "dom.html"), domHtml(doctype, cssHref));
+  let out = "", status = 0;
+  try { out = execFileSync("node", [TOOL, name, ...(extraFlags || [])], { cwd: work, stdio: "pipe" }).toString(); }
+  catch (e) { status = e.status; out = (e.stdout || "").toString() + (e.stderr || "").toString(); }
+  return { status, out, cloneDir: path.join(dir, "clone") };
+}
+
+// ── case 1: quirks-mode capture (no doctype) — the full contract ──────────────
+const r1 = run("quirks", "", "./assets/site.css");
+check("quirks build exits 0", r1.status === 0, r1.out);
+const idx = fs.readFileSync(path.join(r1.cloneDir, "index.html"), "utf8");
+check("absent doctype PRESERVED (quirks stays quirks, #18)", /^<html/.test(idx));
+check("no <script> survives", !/<script/i.test(idx));
+check("CSP <meta> stripped", !/content-security-policy/i.test(idx));
+check("<base> stripped", !/<base\b/i.test(idx));
+check("script preload + modulepreload stripped", !/app\.js|chunk\.mjs/.test(idx));
+check("stylesheet href rewritten to self-hosted path", idx.includes('href="/assets/css/00-site.css"'));
+check("SRI + crossorigin dropped from rewritten link", !/integrity=|crossorigin=/i.test(idx));
+check("inline <style> root-relative url() absolutized", idx.includes("url(file:///img/inline.png)"));
+check("img src absolutized", idx.includes(`src="${origin}/img/a.png"`));
+check("srcset entries absolutized", idx.includes(`srcset="${origin}/img/a.png 1x, ${origin}/img/a@2x.png 2x"`));
+// Link hrefs are entity-decoded BEFORE url-parsing — without the decode, "&amp;" inside a
+// multi-param href becomes a bogus "amp;family" param and every family after the first is
+// silently dropped (astryx: 1 of 15 Google Fonts families loaded, ~74 visual fails from a
+// system-font fallback — the gate caught it live; this locks the fix in)
+check("&amp;-encoded link href decoded before parsing (astryx Google Fonts miss)", idx.includes('href="https://cdn.example.com/css2?family=A&family=B&display=swap"'));
+check("video poster + source absolutized", idx.includes(`poster="${origin}/img/poster.jpg"`) && idx.includes(`src="${origin}/vid/v.mp4"`));
+check("anchor href untouched (doesn't paint)", idx.includes('href="/pricing"'));
+check('loading="lazy" forced to eager', idx.includes('loading="eager"') && !/loading\s*=\s*"lazy"/i.test(idx));
+check("no scaffold TODO (build gate would pass)", !/TODO: build to spec/.test(idx));
+
+const css = fs.readFileSync(path.join(r1.cloneDir, "assets", "css", "00-site.css"), "utf8");
+check("font ref rewritten to self-hosted path", css.includes("url(/assets/fonts/brand.woff2)"));
+check("relative css ref absolutized against the CSS URL", css.includes(`url(${origin}/assets/img/rel.png)`));
+check("already-absolute css ref untouched", css.includes("url(https://cdn.example.com/pic.png)"));
+check("data: uri untouched", css.includes("url(data:image/png;base64,AAAA)"));
+check("@import absolutized + reported (not recursed)", css.includes(`${origin}/assets/extra.css`) && r1.out.includes("@import"));
+const font = fs.readFileSync(path.join(r1.cloneDir, "assets", "fonts", "brand.woff2"));
+check("font self-hosted with REAL wOF2 magic (assets gate)", font.subarray(0, 4).toString("latin1") === "wOF2");
+check("report names the quirks mode", /QUIRKS/i.test(r1.out));
+
+// ── case 2: standards-mode capture — doctype preserved verbatim ───────────────
+const r2 = run("standards", "<!DOCTYPE html>\n", "./assets/site.css");
+const idx2 = fs.readFileSync(path.join(r2.cloneDir, "index.html"), "utf8");
+check("present doctype PRESERVED verbatim", r2.status === 0 && /^<!DOCTYPE html>/i.test(idx2));
+
+// ── case 3: a failing stylesheet download is LOUD (exit 1), never silent ──────
+const r3 = run("broken", "", "./assets/missing.css");
+check("missing stylesheet → exit 1 + named in the report", r3.status === 1 && r3.out.includes("missing.css"));
+
+// ── case 4: --fixes wires clone/fixes.js and reports it; without the flag it's absent ──
+const r4a = run("nofixes", "", "./assets/site.css");
+const idx4a = fs.readFileSync(path.join(r4a.cloneDir, "index.html"), "utf8");
+check("without --fixes: no fixes.js script tag, no scaffold file", !/fixes\.js/i.test(idx4a) && !fs.existsSync(path.join(r4a.cloneDir, "fixes.js")));
+const r4b = run("withfixes", "", "./assets/site.css", ["--fixes"]);
+const idx4b = fs.readFileSync(path.join(r4b.cloneDir, "index.html"), "utf8");
+check("--fixes wires <script src=\"fixes.js\" defer> before </body>", /<script src="fixes\.js" defer><\/script><\/body>/i.test(idx4b));
+check("--fixes scaffolds a starter clone/fixes.js when none exists", fs.existsSync(path.join(r4b.cloneDir, "fixes.js")));
+check("report confirms fixes.js wired", /fixes\.js:\s+wired/.test(r4b.out));
+// re-running --fixes must be idempotent: no duplicate tag, and a hand-edited fixes.js survives
+fs.writeFileSync(path.join(r4b.cloneDir, "fixes.js"), "// hand-written behavior code\n");
+const r4c = run("withfixes", "", "./assets/site.css", ["--fixes"]);
+const idx4c = fs.readFileSync(path.join(r4c.cloneDir, "index.html"), "utf8");
+check("re-running --fixes doesn't duplicate the script tag", (idx4c.match(/src="fixes\.js"/g) || []).length === 1);
+check("re-running --fixes never overwrites a hand-edited fixes.js", fs.readFileSync(path.join(r4c.cloneDir, "fixes.js"), "utf8").includes("hand-written behavior code"));
+
+fs.rmSync(work, { recursive: true, force: true });
+console.log(failed ? `\n❌ capture-build selftest: ${failed} check(s) failed.` : "\n✓ capture-build selftest: all checks pass.");
+process.exit(failed ? 1 : 0);