@bounded-systems/conformance-kit 0.3.0 → 0.5.0

package/README.md

@@ -14,7 +14,7 @@ hardcodes `robertdelanghe.dev`, `bounded.tools`, an account, or an email.
 integrity/    verify-site · verify (sigstore) · gen-sitemanifest · gen-provenance · structure-audit · http-probe
 gates/        sbom (gen + completeness) · shacl-runner · seo-gate · axe-gate (axe-core a11y) · vuln-gate (npm audit) · html-validator-gate (vnu) · baseline-gate (web-features) · jargon-gate (plain-language) · readability-gate · commonmark-runner · semantic (lone)
 gates/conformance/  conformance-report — lone's conformance() projection (Node port of jsr:@bounded-systems/lone@0.4) + a generic HTML renderer
-generators/   gen-cid (IPFS UnixFS) · gen-identity (did:web + VC) · gen-snapshots (reader/markdown) · openapi (static-API helper core)
+generators/   gen-cid (IPFS UnixFS) · gen-identity (did:web + VC) · gen-snapshots (reader/markdown) · gen-print-snapshots (PDF) · openapi (static-API helper core)
 emitters/     reprDigest (RFC 9530) · securityTxt (RFC 9116) · webManifest · markdown-sibling headers
 lib/          schema-validate (zero-dep JSON Schema) · config (env/arg helpers)
 fixtures/ test/  isolated verification of the generic logic
@@ -77,6 +77,7 @@ in-process verifier). The Deno semantic runner pins its imports in
 | `vuln-gate.mjs` | `node …/vuln-gate.mjs [projectDir]` | `$VULN_ROOT` (lockfile lives here, default `.`). Optional `$VULN_OMIT_DEV` (`true`→production deps only, default `true`), `$VULN_THRESHOLD` (highest tolerated known critical/high, default `0`), `$VULN_REPORT` (write the JSON report). Runs **`npm audit`** and **fails closed** when the known critical/high count exceeds the threshold. The report's `vulns: { knownCriticalOrHighVulns }` envelope is what `conformance-report`'s `security.no-critical-vulns` criterion consumes. |
 | `html-validator-gate.mjs` | `node …/html-validator-gate.mjs [distDir]` | `$HTML_DIST`. Optional `$HTML_PAGES` (comma list, default: every `*.html`), `$HTML_THRESHOLD` (default `0`), `$HTML_REPORT`. Runs **vnu** (the Nu Html Checker, a self-contained Java jar — needs a JRE) `--errors-only` over the built pages and **fails closed** above the threshold. The report's `htmlValidator: { errors }` envelope is what `conformance-report`'s `html.validator-clean` criterion consumes. |
 | `baseline-gate.mjs` | `node …/baseline-gate.mjs [cssGlob]` | `$BASELINE_CSS` (default `dist/**/*.css`). Optional `$BASELINE_TARGET` (`widely`/`newly`, default `widely`), `$BASELINE_REPORT`. Maps the shipped CSS to **web-features Baseline** data (via `stylelint-plugin-use-baseline` — headless, no browser) and **fails closed** when the site-wide status is below target. A feature behind an `@supports` query is a tested fallback and doesn't count against it. The report's `baseline: { status, fallbackTested }` envelope is what `conformance-report`'s `compatibility.baseline` criterion consumes. |
+| `palette-gate.mjs` | `node …/palette-gate.mjs <tokens.(json\|css)> <pairings.json>` | **Two inputs the consumer supplies**: a token map (a DTCG `tokens.json` — primitive→semantic aliases resolved — or a `tokens.css` of `--name: #hex` custom properties) and a `pairings.json` declaring the fg/bg pairs that actually co-occur (`{ "pairings":[{fg,bg,kind,size?,weight?,name?}], "categorical":[…], "thresholds":{…} }`; `kind` ∈ `text`\|`large-text`\|`ui`, `fg`/`bg` are token names or literal `#hex`). Runs **static colour-palette analysis** — zero-dep, every primitive computed by hand: (1) **CVD-safe contrast** — simulates each colour under deuteranopia/protanopia/tritanopia (**Machado-2009** matrices), recomputes the WCAG ratio per pair under each, and flags any pair dropping below AA, plus **categorical collapse** (CIEDE2000 ΔE below `$PALETTE_COLLAPSE_DELTAE`, default 10) post-transform; (2) **APCA** — implements **APCA-W3 ~0.1.9**, reports `Lc` per text pair against a font-size/weight-aware (or baseline `$PALETTE_MIN_LC_TEXT` 60 / `$PALETTE_MIN_LC_LARGE` 45) minimum, **alongside** the WCAG-2 ratio (complement, not replacement); (3) **non-text contrast** — `kind:'ui'` pairs require ≥3:1 (WCAG 2.2 **SC 1.4.11**). Thresholds are config-driven (`pairings.json` `thresholds` ⊕ `$PALETTE_MIN_RATIO_{TEXT,LARGE,UI}`) and it **fails closed** on any failure. `$PALETTE_REPORT` writes the per-pair JSON (WCAG ratio · APCA Lc · per-CVD ratios · pass/fail per check). The report's `palette: { cvdSafe, apcaBaseline, nonTextContrast }` envelope is what a future `palette.*` criterion consumes. |
 | `jargon-gate.mjs` | `node …/jargon-gate.mjs [distDir] [--strict]` | `$JARGON_DIST`. Optional `$JARGON_ALLOWLIST` (comma list of accepted terms), `$JARGON_MIN_LENGTH` (default `3`), `$JARGON_THRESHOLD` (default `0`, for `--strict`), `$JARGON_REPORT`. Flags **undefined jargon** in the prose: words not in a 275k-word English dictionary (compounds/possessives atomized first) that the page does not **define** via `<abbr title>`, `<dfn>`, or a `<dl>` glossary — for W3C COGA / WCAG 3.1.3 Unusual Words and for AI readers. WARN-only by default; `--strict` fails closed. Report carries a `plainLanguage: { undefinedJargon, glossaryPresent }` envelope (for a future `cognitive.plain-language` criterion). |
 | `readability-gate.mjs` | `node …/readability-gate.mjs <corpus.json> [--strict]` | **The corpus is an input** the site assembles from its copy: a JSON array of `{id,text}` or an `{id:text}` map. Optional `$READABILITY_THRESHOLDS`, `$READABILITY_MIN_WORDS`, `$READABILITY_KNOWN_ACRONYMS`. WARN-only unless `--strict`. |
 | `commonmark-runner.mjs` | `node …/commonmark-runner.mjs <renderer.mjs> [fixtures.json]` | **The site's markdown renderer module** (export `renderMarkdown`, or set `$COMMONMARK_RENDER_EXPORT`). Default fixtures pin a safe CommonMark subset + 4 hostile-HTML escapes; a site with a different renderer supplies its own `fixtures.json`. |
@@ -97,6 +98,7 @@ criteria are reported + summarised per area but never widen the headline claim.
 | `gen-cid.mjs` | `DIST=dist node …/gen-cid.mjs` | `$DIST`. Walks the `site.sha256` file set (or `dist`), computes the IPFS UnixFS dir CIDv1 with no daemon, records it into `$DIST/provenance.json`. |
 | `gen-identity.mjs` | `IDENTITY_DOMAIN=… IDENTITY_REPO=owner/repo node …/gen-identity.mjs` | `$IDENTITY_DOMAIN`, `$IDENTITY_REPO` (cert-identity regexp), `$IDENTITY_SUBJECT` (the credentialSubject JSON, default `$DIST/resume.json`), optional `$IDENTITY_SUBJECT_SCHEMA`, `$IDENTITY_VC_NAME/DESCRIPTION`, `$IDENTITY_VALID_FROM_PATH`. Emits `did.json` + a W3C VC 2.0. |
 | `gen-snapshots.mjs` | `node …/gen-snapshots.mjs [distDir]` | `$SNAPSHOT_DIST` (default `dist`). Optional `$SNAPSHOT_PAGES`, `$SNAPSHOT_BASE_URL` (recorded as `source` in the front-matter), `$SNAPSHOT_SUFFIX` (default `.reader`). For every built page, runs **@mozilla/readability** (the Firefox/Safari Reader engine, via `linkedom` — headless, no browser) and writes a clean reader **`<page>.reader.html`** + an analysis-friendly **`<page>.reader.md`** (YAML front-matter + Markdown via `turndown`). The Markdown is the durable, diffable twin of the page — far easier to run NLP/LLM analysis over than scraping live HTML — and doubles as the AI-readable Markdown sibling. (The printed/PDF view needs a print-CSS renderer and is a separate generator.) |
+| `gen-print-snapshots.mjs` | `node …/gen-print-snapshots.mjs [distDir]` | `$PRINT_DIST` (default `dist`). Optional `$PRINT_PAGES`, `$PRINT_RENDERER` (default `tezcatl`, or a `"cmd {url} {out}"` template), `$PRINT_WAIT` (default `600`), `$PRINT_SUFFIX` (default `.print`). The print/PDF twin of `gen-snapshots`: serves `dist` over an ephemeral origin (so assets resolve) and renders each page's `@media print` view to **`<page>.print.pdf`** via **tezcatl** (macOS-native WebKit — no Chromium). A LOCAL / macOS-deploy artifact: on a host without the renderer (e.g. a Linux CI runner) it **SKIPS** with a note. |
 | `openapi.mjs` | `import { sortKeys, writeApiFile, embedSchema, jsonResponse, validateOpenapi }` | The **generic core** of a static-API generator. The per-endpoint projection of a site's contracts (profile/posts/corpus/VC, etc.) stays in the site's build; this module provides deterministic JSON output, schema embedding, and OpenAPI 3.1/3.2 well-formedness validation. Pair with `lib/schema-validate.mjs` to self-check emitted docs. |
 
 ### emitters/
@@ -122,7 +124,7 @@ deno run -A jsr:@bounded-systems/verify https://your-site
 ## Test
 
 ```
-npm install && npm test    # 13 cases against fixtures/, in isolation
+npm install && npm test    # cases against fixtures/, in isolation
 ```
 
 The suite verifies the generic logic end-to-end: gen-sbom against a sample lockfile;

package/gates/palette-gate.mjs

@@ -0,0 +1,601 @@
+#!/usr/bin/env node
+// Palette gate — STATIC colour-palette analysis over a site/brand's design tokens.
+// Three high-value checks that a per-page a11y scan (axe) cannot do, because they
+// reason about the PALETTE itself — the colour math, not the rendered DOM:
+//
+//   1. CVD-SAFE CONTRAST — simulate every used colour under deuteranopia /
+//      protanopia / tritanopia (Machado-2009 matrices), recompute WCAG contrast
+//      for each declared pair under each CVD type, and FAIL any pair that drops
+//      below AA for someone with that colour-vision deficiency. Also flag
+//      CATEGORICAL colours that COLLAPSE (become indistinguishable, CIEDE2000 ΔE
+//      below a threshold) once a CVD transform is applied.
+//   2. APCA — the perceptual contrast metric (APCA-W3 ~0.1.9) the next WCAG (WCAG 3
+//      / "Silver") is built around. Compute Lc per text pair, check against a
+//      font-size/weight-aware minimum (or the documented baseline floor), and
+//      report BOTH the APCA Lc AND the WCAG-2 ratio — complement, not replacement.
+//   3. NON-TEXT CONTRAST (WCAG 2.2 SC 1.4.11) — UI pairs (borders, focus rings,
+//      icon glyphs, control boundaries) require ≥ 3:1 against what they sit on.
+//
+// Zero-dependency: every colour-science primitive (sRGB→linear, relative
+// luminance, WCAG ratio, CIE Lab, CIEDE2000, APCA-W3, the CVD matrices) is
+// computed here by hand and CITED in-line, exactly like the kit's other gates.
+//
+//   node gates/palette-gate.mjs [tokens] [pairings]    # build gate (exit 1 on any failure)
+//
+// INPUTS the consumer supplies (nothing about any one brand is hard-coded):
+//   argv[2] / $PALETTE_TOKENS    a token map: a DTCG `tokens.json` (primitive →
+//                                semantic aliases resolved) OR a `tokens.css`
+//                                (`--name: #hex;` custom properties).
+//   argv[3] / $PALETTE_PAIRINGS  a `pairings.json` the consumer authors, declaring
+//                                the fg/bg pairs that actually CO-OCCUR in the UI:
+//                                  { "thresholds": { … optional overrides … },
+//                                    "pairings": [ { "fg","bg","kind","size?","weight?","name?" } ],
+//                                    "categorical": [ "tokenA","tokenB", … ] }
+//                                `kind` ∈ text | large-text | ui. `fg`/`bg` are a
+//                                token name (resolved from the map) or a literal #hex.
+//                                `categorical` = colours that must stay mutually
+//                                distinguishable (chart series, status colours, …).
+//   $PALETTE_REPORT              path to write the machine-readable JSON report.
+//
+// Thresholds are config-driven (pairings.json `thresholds` ⊕ env) and FAIL CLOSED:
+//   $PALETTE_MIN_RATIO_TEXT  (default 4.5)   WCAG AA, normal text   (SC 1.4.3)
+//   $PALETTE_MIN_RATIO_LARGE (default 3.0)   WCAG AA, large text    (SC 1.4.3)
+//   $PALETTE_MIN_RATIO_UI    (default 3.0)   non-text contrast      (SC 1.4.11)
+//   $PALETTE_MIN_LC_TEXT     (default 60)    APCA baseline, body
+//   $PALETTE_MIN_LC_LARGE    (default 45)    APCA baseline, large/headline
+//   $PALETTE_COLLAPSE_DELTAE (default 10)    min CIEDE2000 ΔE between categorical
+//                                            colours after a CVD transform
+//
+// The pure functions are exported for unit testing; the CLI is a thin wrapper.
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 1. sRGB ↔ linear, relative luminance, WCAG-2 contrast ratio
+//    Refs: WCAG 2.2 — "relative luminance" + "contrast ratio" definitions
+//      https://www.w3.org/TR/WCAG22/#dfn-relative-luminance
+//      https://www.w3.org/TR/WCAG22/#dfn-contrast-ratio
+//    IEC 61966-2-1:1999 (sRGB) transfer function.
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** Parse a #rgb / #rrggbb (or bare-hex) string → [r,g,b] in 0..255. */
+export function parseHex(s) {
+  let h = String(s).trim().replace(/^#/, "");
+  if (/^[0-9a-fA-F]{3}$/.test(h)) h = h.split("").map((c) => c + c).join("");
+  if (!/^[0-9a-fA-F]{6}$/.test(h)) throw new Error(`not a hex colour: "${s}"`);
+  return [0, 2, 4].map((i) => parseInt(h.slice(i, i + 2), 16));
+}
+
+/** [r,g,b] 0..255 → "#rrggbb" (clamped + rounded). */
+export function toHex(rgb) {
+  return "#" + rgb.map((v) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, "0")).join("");
+}
+
+/** sRGB channel 0..255 → linear-light 0..1. WCAG/IEC 61966-2-1 transfer fn. */
+export function srgbToLinear(c) {
+  const cs = c / 255;
+  return cs <= 0.04045 ? cs / 12.92 : Math.pow((cs + 0.055) / 1.055, 2.4);
+}
+
+/** linear-light 0..1 → sRGB channel 0..255 (inverse transfer fn). */
+export function linearToSrgb(c) {
+  const v = c <= 0.0031308 ? 12.92 * c : 1.055 * Math.pow(c, 1 / 2.4) - 0.055;
+  return Math.max(0, Math.min(255, v * 255));
+}
+
+/** WCAG relative luminance of an sRGB [r,g,b]. L = 0.2126R+0.7152G+0.0722B (linear). */
+export function relativeLuminance(rgb) {
+  const [r, g, b] = rgb.map(srgbToLinear);
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+
+/** WCAG-2 contrast ratio of two sRGB colours: (L_light+0.05)/(L_dark+0.05), 1..21. */
+export function wcagContrast(a, b) {
+  const la = relativeLuminance(a), lb = relativeLuminance(b);
+  const hi = Math.max(la, lb), lo = Math.min(la, lb);
+  return (hi + 0.05) / (lo + 0.05);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 2. CIE Lab + CIEDE2000 colour difference
+//    Refs: sRGB→XYZ (D65) matrix, IEC 61966-2-1 / Bruce Lindbloom.
+//      CIEDE2000: Sharma, Wu, Dalal (2005), "The CIEDE2000 Color-Difference
+//      Formula: Implementation Notes, Supplementary Test Data, and Mathematical
+//      Observations", Color Res. Appl. 30(1). http://www.ece.rochester.edu/~gsharma/ciede2000/
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** sRGB [r,g,b] 0..255 → CIE L*a*b* (D65 reference white). */
+export function rgbToLab(rgb) {
+  const [r, g, b] = rgb.map(srgbToLinear);
+  // linear sRGB → XYZ (D65), IEC 61966-2-1 / sRGB→XYZ matrix.
+  const X = 0.4124564 * r + 0.3575761 * g + 0.1804375 * b;
+  const Y = 0.2126729 * r + 0.7151522 * g + 0.0721750 * b;
+  const Z = 0.0193339 * r + 0.1191920 * g + 0.9503041 * b;
+  // D65 reference white.
+  const Xn = 0.95047, Yn = 1.0, Zn = 1.08883;
+  const e = 216 / 24389, k = 24389 / 27; // CIE standard ε, κ
+  const f = (t) => (t > e ? Math.cbrt(t) : (k * t + 16) / 116);
+  const fx = f(X / Xn), fy = f(Y / Yn), fz = f(Z / Zn);
+  return [116 * fy - 16, 500 * (fx - fy), 200 * (fy - fz)];
+}
+
+/** CIEDE2000 ΔE between two CIE Lab colours (Sharma et al. 2005 reference impl). */
+export function ciede2000(lab1, lab2) {
+  const [L1, a1, b1] = lab1, [L2, a2, b2] = lab2;
+  const rad = Math.PI / 180, deg = 180 / Math.PI;
+  const kL = 1, kC = 1, kH = 1;
+  const C1 = Math.hypot(a1, b1), C2 = Math.hypot(a2, b2);
+  const Cbar = (C1 + C2) / 2;
+  const Cbar7 = Math.pow(Cbar, 7);
+  const G = 0.5 * (1 - Math.sqrt(Cbar7 / (Cbar7 + Math.pow(25, 7))));
+  const a1p = (1 + G) * a1, a2p = (1 + G) * a2;
+  const C1p = Math.hypot(a1p, b1), C2p = Math.hypot(a2p, b2);
+  const hp = (b, ap) => {
+    if (b === 0 && ap === 0) return 0;
+    let h = Math.atan2(b, ap) * deg;
+    return h < 0 ? h + 360 : h;
+  };
+  const h1p = hp(b1, a1p), h2p = hp(b2, a2p);
+  const dLp = L2 - L1;
+  const dCp = C2p - C1p;
+  let dhp;
+  if (C1p * C2p === 0) dhp = 0;
+  else {
+    dhp = h2p - h1p;
+    if (dhp > 180) dhp -= 360;
+    else if (dhp < -180) dhp += 360;
+  }
+  const dHp = 2 * Math.sqrt(C1p * C2p) * Math.sin((dhp * rad) / 2);
+  const Lbarp = (L1 + L2) / 2;
+  const Cbarp = (C1p + C2p) / 2;
+  let hbarp;
+  if (C1p * C2p === 0) hbarp = h1p + h2p;
+  else if (Math.abs(h1p - h2p) <= 180) hbarp = (h1p + h2p) / 2;
+  else hbarp = h1p + h2p < 360 ? (h1p + h2p + 360) / 2 : (h1p + h2p - 360) / 2;
+  const T =
+    1 -
+    0.17 * Math.cos((hbarp - 30) * rad) +
+    0.24 * Math.cos(2 * hbarp * rad) +
+    0.32 * Math.cos((3 * hbarp + 6) * rad) -
+    0.20 * Math.cos((4 * hbarp - 63) * rad);
+  const dTheta = 30 * Math.exp(-Math.pow((hbarp - 275) / 25, 2));
+  const Cbarp7 = Math.pow(Cbarp, 7);
+  const RC = 2 * Math.sqrt(Cbarp7 / (Cbarp7 + Math.pow(25, 7)));
+  const SL = 1 + (0.015 * Math.pow(Lbarp - 50, 2)) / Math.sqrt(20 + Math.pow(Lbarp - 50, 2));
+  const SC = 1 + 0.045 * Cbarp;
+  const SH = 1 + 0.015 * Cbarp * T;
+  const RT = -Math.sin(2 * dTheta * rad) * RC;
+  return Math.sqrt(
+    Math.pow(dLp / (kL * SL), 2) +
+      Math.pow(dCp / (kC * SC), 2) +
+      Math.pow(dHp / (kH * SH), 2) +
+      RT * (dCp / (kC * SC)) * (dHp / (kH * SH)),
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 3. APCA-W3 (Accessible Perceptual Contrast Algorithm), constants ~0.1.9 / 0.98G-4g.
+//    Ref: Andrew Somers (Myndex), APCA-W3 / SAPC — https://github.com/Myndex/apca-w3
+//    and https://github.com/Myndex/SAPC-APCA . Output `Lc` is a polarity-signed
+//    "lightness contrast" roughly in [-108, 106]; conformance uses |Lc|.
+//    APCA is a CANDIDATE method (WCAG 3 / "Silver"), reported ALONGSIDE — not in
+//    place of — the WCAG-2 ratio.
+// ─────────────────────────────────────────────────────────────────────────────
+
+const SA98G = {
+  mainTRC: 2.4,
+  sRco: 0.2126729, sGco: 0.7151522, sBco: 0.0721750,
+  normBG: 0.56, normTXT: 0.57, revTXT: 0.62, revBG: 0.65,
+  blkThrs: 0.022, blkClmp: 1.414,
+  scaleBoW: 1.14, scaleWoB: 1.14,
+  loBoWoffset: 0.027, loWoBoffset: 0.027,
+  deltaYmin: 0.0005, loClip: 0.1,
+};
+
+/** sRGB [r,g,b] 0..255 → APCA screen luminance Ys (simple power-curve, not WCAG luminance). */
+export function apcaY(rgb) {
+  const s = SA98G;
+  return (
+    s.sRco * Math.pow(rgb[0] / 255, s.mainTRC) +
+    s.sGco * Math.pow(rgb[1] / 255, s.mainTRC) +
+    s.sBco * Math.pow(rgb[2] / 255, s.mainTRC)
+  );
+}
+
+/** APCA-W3 contrast Lc for text-luminance over background-luminance. */
+export function apcaContrastY(txtY, bgY) {
+  const s = SA98G;
+  if (Math.min(txtY, bgY) < 0) return 0.0;
+  // Soft-clamp near-black (low-luminance offset).
+  if (txtY < s.blkThrs) txtY += Math.pow(s.blkThrs - txtY, s.blkClmp);
+  if (bgY < s.blkThrs) bgY += Math.pow(s.blkThrs - bgY, s.blkClmp);
+  if (Math.abs(bgY - txtY) < s.deltaYmin) return 0.0;
+  let out;
+  if (bgY > txtY) {
+    // normal polarity: dark text on light bg
+    const SAPC = (Math.pow(bgY, s.normBG) - Math.pow(txtY, s.normTXT)) * s.scaleBoW;
+    out = SAPC < s.loClip ? 0.0 : SAPC - s.loBoWoffset;
+  } else {
+    // reverse polarity: light text on dark bg
+    const SAPC = (Math.pow(bgY, s.revBG) - Math.pow(txtY, s.revTXT)) * s.scaleWoB;
+    out = SAPC > -s.loClip ? 0.0 : SAPC + s.loWoBoffset;
+  }
+  return out * 100;
+}
+
+/** APCA Lc for a text fg over a bg, both sRGB [r,g,b]. Signed (polarity-aware). */
+export function apcaContrast(fg, bg) {
+  return apcaContrastY(apcaY(fg), apcaY(bg));
+}
+
+/**
+ * Minimum |Lc| a text pair must clear. If size (px) / weight are given, use a
+ * conservative font-aware tier derived from the APCA readability guidance ("Bronze"
+ * use-case levels: Lc 90 ideal body, 75 min body column, 60 large/content, 45
+ * large+bold/headline, 30 spot). Otherwise fall back to the baseline floor by kind.
+ * Cited: APCA "Font Size & Weight" guidance, https://git.myndex.com/ (use-cases).
+ * This is intentionally conservative (rounds UP a requirement, never down); a
+ * consumer can override exactly via a per-pairing `minLc`.
+ */
+export function apcaMinLc({ kind, sizePx, weight, baseText = 60, baseLarge = 45 }) {
+  if (sizePx != null) {
+    const w = weight ?? 400;
+    if (sizePx >= 36 || (sizePx >= 24 && w >= 700)) return baseLarge;       // big display
+    if (sizePx >= 24 || (sizePx >= 18.5 && w >= 600)) return baseText;       // large text
+    if (sizePx >= 18) return 75;                                             // body
+    if (sizePx >= 16) return 90;                                             // small body
+    return 100;                                                             // < 16px: max
+  }
+  return kind === "large-text" ? baseLarge : baseText;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 4. Colour-vision-deficiency simulation — Machado 2009, severity 1.0 (dichromacy).
+//    Ref: G. M. Machado, M. M. Oliveira, L. A. F. Fernandes (2009), "A
+//    Physiologically-based Model for Simulation of Color Vision Deficiency",
+//    IEEE Trans. Vis. Comput. Graph. 15(6). Matrices operate on LINEAR-light sRGB.
+//    http://www.inf.ufrgs.br/~oliveira/pubs_files/CVD_Simulation/CVD_Simulation.html
+// ─────────────────────────────────────────────────────────────────────────────
+
+export const CVD_MATRICES = {
+  // protanopia (severity 1.0)
+  protanopia: [
+    [0.152286, 1.052583, -0.204868],
+    [0.114503, 0.786281, 0.099216],
+    [-0.003882, -0.048116, 1.051998],
+  ],
+  // deuteranopia (severity 1.0)
+  deuteranopia: [
+    [0.367322, 0.860646, -0.227968],
+    [0.280085, 0.672501, 0.047413],
+    [-0.011820, 0.042940, 0.968881],
+  ],
+  // tritanopia (severity 1.0)
+  tritanopia: [
+    [1.255528, -0.076749, -0.178779],
+    [-0.078411, 0.930809, 0.147602],
+    [0.004733, 0.691367, 0.303900],
+  ],
+};
+
+export const CVD_TYPES = Object.keys(CVD_MATRICES);
+
+/** Simulate how an sRGB [r,g,b] colour appears to someone with the given CVD type. */
+export function simulateCVD(rgb, type) {
+  const M = CVD_MATRICES[type];
+  if (!M) throw new Error(`unknown CVD type: ${type}`);
+  const lin = rgb.map(srgbToLinear); // Machado matrices act on linear light
+  const out = M.map((row) => row[0] * lin[0] + row[1] * lin[1] + row[2] * lin[2]);
+  return out.map((c) => Math.round(linearToSrgb(Math.max(0, Math.min(1, c)))));
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 5. Threshold model + per-pair evaluation (pure)
+// ─────────────────────────────────────────────────────────────────────────────
+
+export const DEFAULT_THRESHOLDS = {
+  minRatioText: 4.5,   // WCAG 2.2 SC 1.4.3 (AA, normal text)
+  minRatioLarge: 3.0,  // WCAG 2.2 SC 1.4.3 (AA, large text)
+  minRatioUi: 3.0,     // WCAG 2.2 SC 1.4.11 (non-text contrast)
+  minLcText: 60,       // APCA baseline floor, body
+  minLcLarge: 45,      // APCA baseline floor, large
+  collapseDeltaE: 10,  // categorical CIEDE2000 collapse floor
+};
+
+/** The WCAG-AA ratio floor for a pairing kind. */
+export function ratioFloor(kind, t) {
+  if (kind === "ui") return t.minRatioUi;
+  if (kind === "large-text") return t.minRatioLarge;
+  return t.minRatioText; // text (default)
+}
+
+/**
+ * Evaluate ONE resolved pairing (fg/bg already hex) against all three checks.
+ * Pure: (pairing, thresholds) → per-pair report. `kind` drives which checks apply:
+ *   text / large-text → WCAG AA ratio, APCA Lc, and CVD-safe AA under every CVD.
+ *   ui                → WCAG 1.4.11 (≥3:1), and CVD-safe ≥3:1 under every CVD.
+ */
+export function evaluatePair(pairing, thresholds = DEFAULT_THRESHOLDS) {
+  const t = { ...DEFAULT_THRESHOLDS, ...thresholds };
+  const kind = pairing.kind || "text";
+  const fgRgb = parseHex(pairing.fgHex), bgRgb = parseHex(pairing.bgHex);
+  const floor = ratioFloor(kind, t);
+
+  const ratio = wcagContrast(fgRgb, bgRgb);
+  const wcagPass = ratio + 1e-9 >= floor;
+
+  // CVD-safe contrast: recompute the WCAG ratio with BOTH colours simulated.
+  const cvd = { normalRatio: round2(ratio) };
+  let cvdPass = true;
+  for (const type of CVD_TYPES) {
+    const r = wcagContrast(simulateCVD(fgRgb, type), simulateCVD(bgRgb, type));
+    const pass = r + 1e-9 >= floor;
+    cvd[type] = { ratio: round2(r), floor, pass };
+    if (!pass) cvdPass = false;
+  }
+  cvd.pass = cvdPass;
+
+  const checks = {};
+  const isText = kind === "text" || kind === "large-text";
+
+  checks.wcagAA = wcagPass;
+
+  let apca = null;
+  if (isText) {
+    const Lc = apcaContrast(fgRgb, bgRgb);
+    const minLc = pairing.minLc ?? apcaMinLc({
+      kind, sizePx: pairing.size, weight: pairing.weight,
+      baseText: t.minLcText, baseLarge: t.minLcLarge,
+    });
+    const apcaPass = Math.abs(Lc) + 1e-9 >= minLc;
+    apca = { Lc: round1(Lc), absLc: round1(Math.abs(Lc)), min: minLc, pass: apcaPass };
+    checks.apca = apcaPass;
+  } else {
+    checks.apca = null;
+  }
+
+  checks.nonText = kind === "ui" ? wcagPass : null;
+  checks.cvdSafe = cvdPass;
+
+  const passed =
+    checks.wcagAA &&
+    (checks.apca !== false) &&
+    (checks.nonText !== false) &&
+    cvdPass;
+
+  return {
+    name: pairing.name || `${pairing.fg} on ${pairing.bg}`,
+    fg: { ref: pairing.fg, hex: toHex(fgRgb) },
+    bg: { ref: pairing.bg, hex: toHex(bgRgb) },
+    kind,
+    size: pairing.size ?? null,
+    weight: pairing.weight ?? null,
+    wcag: { ratio: round2(ratio), min: floor, pass: wcagPass },
+    apca,
+    cvd,
+    checks,
+    passed,
+  };
+}
+
+/**
+ * Detect CATEGORICAL collapse: every unordered pair of categorical colours must
+ * stay ≥ collapseDeltaE apart (CIEDE2000) under NORMAL vision AND under every CVD
+ * transform. A pair that collapses post-transform is reported. Pure.
+ */
+export function evaluateCategorical(colors, thresholds = DEFAULT_THRESHOLDS) {
+  const t = { ...DEFAULT_THRESHOLDS, ...thresholds };
+  const collapses = [];
+  const list = colors.map((c) => ({ ref: c.ref, rgb: parseHex(c.hex), hex: toHex(parseHex(c.hex)) }));
+  for (let i = 0; i < list.length; i++) {
+    for (let j = i + 1; j < list.length; j++) {
+      const A = list[i], B = list[j];
+      const conditions = { normal: ciede2000(rgbToLab(A.rgb), rgbToLab(B.rgb)) };
+      for (const type of CVD_TYPES) {
+        conditions[type] = ciede2000(rgbToLab(simulateCVD(A.rgb, type)), rgbToLab(simulateCVD(B.rgb, type)));
+      }
+      for (const [cond, dE] of Object.entries(conditions)) {
+        if (dE + 1e-9 < t.collapseDeltaE) {
+          collapses.push({
+            a: A.ref, b: B.ref, aHex: A.hex, bHex: B.hex,
+            condition: cond, deltaE: round2(dE), min: t.collapseDeltaE,
+          });
+        }
+      }
+    }
+  }
+  return { threshold: t.collapseDeltaE, count: collapses.length, collapses };
+}
+
+/** Whole-palette evaluation: pairs + categorical collapse → fail-closed report. Pure. */
+export function evaluatePalette({ pairings = [], categorical = [], thresholds = DEFAULT_THRESHOLDS } = {}) {
+  const t = { ...DEFAULT_THRESHOLDS, ...thresholds };
+  const pairs = pairings.map((p) => evaluatePair(p, t));
+  const cat = evaluateCategorical(categorical, t);
+
+  const summary = {
+    pairs: pairs.length,
+    failingPairs: pairs.filter((p) => !p.passed).length,
+    wcagFailures: pairs.filter((p) => !p.checks.wcagAA).length,
+    cvdFailures: pairs.filter((p) => !p.cvd.pass).length,
+    apcaFailures: pairs.filter((p) => p.checks.apca === false).length,
+    nonTextFailures: pairs.filter((p) => p.checks.nonText === false).length,
+    categoricalCollapses: cat.count,
+  };
+  const passed = summary.failingPairs === 0 && cat.count === 0;
+
+  return {
+    passed,
+    thresholds: t,
+    summary,
+    pairs,
+    categorical: cat,
+    // Envelope a future lone `palette.cvd-safe` / `palette.apca` criterion can consume.
+    palette: {
+      cvdSafe: summary.cvdFailures === 0 && cat.count === 0,
+      apcaBaseline: summary.apcaFailures === 0,
+      nonTextContrast: summary.nonTextFailures === 0,
+    },
+  };
+}
+
+const round1 = (n) => Math.round(n * 10) / 10;
+const round2 = (n) => Math.round(n * 100) / 100;
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 6. Token / pairing loading (impure; deterministic, no network/browser)
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** Flatten a DTCG-ish tokens.json (primitive → semantic aliases) to { dotted.name → #hex }. */
+export function tokensFromDTCG(json) {
+  const flat = {}; // dotted path → raw $value (may be an alias or hex)
+  const walk = (node, path) => {
+    if (node && typeof node === "object") {
+      if (typeof node.$value === "string" && (node.$type === "color" || /^#|^\{/.test(node.$value))) {
+        flat[path.join(".")] = node.$value;
+      }
+      for (const [k, v] of Object.entries(node)) {
+        if (k.startsWith("$")) continue;
+        walk(v, [...path, k]);
+      }
+    }
+  };
+  walk(json, []);
+  const resolve1 = (v, seen = new Set()) => {
+    const m = /^\{(.+)\}$/.exec(String(v).trim());
+    if (!m) return v;
+    if (seen.has(m[1])) throw new Error(`alias cycle at {${m[1]}}`);
+    if (!(m[1] in flat)) throw new Error(`unresolved alias {${m[1]}}`);
+    return resolve1(flat[m[1]], new Set([...seen, m[1]]));
+  };
+  const out = {};
+  for (const [k, v] of Object.entries(flat)) {
+    let resolved;
+    try { resolved = resolve1(v); } catch { continue; }
+    if (/^#?[0-9a-fA-F]{3}$|^#?[0-9a-fA-F]{6}$/.test(String(resolved).replace(/^#/, "#"))) {
+      out[k] = String(resolved).startsWith("#") ? resolved : "#" + resolved;
+    }
+  }
+  return out;
+}
+
+/** Parse a tokens.css for `--name: #hex;` custom properties → { name(no --) → #hex }. */
+export function tokensFromCSS(css) {
+  const out = {};
+  const re = /--([a-zA-Z0-9-]+)\s*:\s*(#[0-9a-fA-F]{3,8})\s*;/g;
+  let m;
+  while ((m = re.exec(css))) out[m[1]] = m[2];
+  return out;
+}
+
+/** Load a token map from a .json (DTCG) or .css path. */
+export async function loadTokens(path) {
+  const raw = await readFile(path, "utf8");
+  if (path.endsWith(".json")) return tokensFromDTCG(JSON.parse(raw));
+  if (path.endsWith(".css")) return tokensFromCSS(raw);
+  // Best-effort: try JSON, else CSS.
+  try { return tokensFromDTCG(JSON.parse(raw)); } catch { return tokensFromCSS(raw); }
+}
+
+/**
+ * Resolve a colour REFERENCE (a token name or a literal #hex) against the map.
+ * Tolerant of the brand's short names: tries the exact key, then common prefixes
+ * (`bs-color-`, `bs-grade-`, `color.`, `bs-`), then a case-insensitive match.
+ */
+export function resolveColor(map, ref) {
+  const r = String(ref).trim();
+  if (/^#[0-9a-fA-F]{3,8}$/.test(r)) return r;
+  if (r in map) return map[r];
+  for (const p of ["bs-color-", "bs-grade-", "color.", "primitive.", "bs-"]) {
+    if (p + r in map) return map[p + r];
+  }
+  const lc = r.toLowerCase();
+  for (const [k, v] of Object.entries(map)) {
+    if (k.toLowerCase() === lc || k.toLowerCase().endsWith("-" + lc) || k.toLowerCase().endsWith("." + lc)) return v;
+  }
+  throw new Error(`unresolved colour reference: "${ref}"`);
+}
+
+/** Resolve a pairings.json spec (token names → hex) against a token map. */
+export function resolvePairings(spec, map) {
+  const pairings = (spec.pairings || []).map((p) => ({
+    ...p,
+    fgHex: resolveColor(map, p.fg),
+    bgHex: resolveColor(map, p.bg),
+  }));
+  const categorical = (spec.categorical || []).map((ref) => ({ ref, hex: resolveColor(map, ref) }));
+  return { pairings, categorical, thresholds: spec.thresholds || {} };
+}
+
+/** Full run: load tokens + pairings → resolve → evaluate. Exposed for tests. */
+export async function runPaletteGate({ tokens, pairings, thresholds = {} }) {
+  const map = typeof tokens === "string" ? await loadTokens(tokens) : tokens;
+  const spec = typeof pairings === "string" ? JSON.parse(await readFile(pairings, "utf8")) : pairings;
+  const resolved = resolvePairings(spec, map);
+  return evaluatePalette({
+    pairings: resolved.pairings,
+    categorical: resolved.categorical,
+    thresholds: { ...DEFAULT_THRESHOLDS, ...resolved.thresholds, ...thresholds },
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 7. CLI
+// ─────────────────────────────────────────────────────────────────────────────
+
+function envThresholds() {
+  const t = {};
+  const num = (e) => (process.env[e] != null ? Number(process.env[e]) : undefined);
+  const set = (k, e) => { const v = num(e); if (v != null && !Number.isNaN(v)) t[k] = v; };
+  set("minRatioText", "PALETTE_MIN_RATIO_TEXT");
+  set("minRatioLarge", "PALETTE_MIN_RATIO_LARGE");
+  set("minRatioUi", "PALETTE_MIN_RATIO_UI");
+  set("minLcText", "PALETTE_MIN_LC_TEXT");
+  set("minLcLarge", "PALETTE_MIN_LC_LARGE");
+  set("collapseDeltaE", "PALETTE_COLLAPSE_DELTAE");
+  return t;
+}
+
+async function main() {
+  const argv = process.argv.slice(2).filter((a) => !a.startsWith("--"));
+  const tokens = argv[0] || process.env.PALETTE_TOKENS;
+  const pairings = argv[1] || process.env.PALETTE_PAIRINGS;
+  if (!tokens || !pairings) {
+    console.error("✗ palette-gate: usage: palette-gate.mjs <tokens.(json|css)> <pairings.json>");
+    console.error("  (or set $PALETTE_TOKENS and $PALETTE_PAIRINGS)");
+    process.exit(2);
+  }
+
+  const report = await runPaletteGate({ tokens, pairings, thresholds: envThresholds() });
+  if (process.env.PALETTE_REPORT) {
+    await writeFile(resolve(process.env.PALETTE_REPORT), JSON.stringify(report, null, 2) + "\n");
+  }
+
+  const s = report.summary;
+  const line =
+    `palette-gate: ${s.pairs} pair(s) — ${s.failingPairs} failing ` +
+    `(WCAG ${s.wcagFailures}, CVD ${s.cvdFailures}, APCA ${s.apcaFailures}, non-text ${s.nonTextFailures}) · ` +
+    `${s.categoricalCollapses} categorical collapse(s)`;
+
+  const detail = (p) => {
+    const bits = [`WCAG ${p.wcag.ratio}:1 (min ${p.wcag.min})`];
+    if (p.apca) bits.push(`APCA |Lc| ${p.apca.absLc} (min ${p.apca.min})`);
+    const cvdBad = CVD_TYPES.filter((c) => !p.cvd[c].pass).map((c) => `${c} ${p.cvd[c].ratio}:1`);
+    if (cvdBad.length) bits.push(`CVD-fail: ${cvdBad.join(", ")}`);
+    return `  · ${p.name} [${p.kind}] ${p.fg.hex}/${p.bg.hex} — ${bits.join("; ")}`;
+  };
+
+  if (!report.passed) {
+    console.error(`✗ ${line}`);
+    for (const p of report.pairs) if (!p.passed) console.error(detail(p));
+    for (const c of report.categorical.collapses) {
+      console.error(`  · collapse: ${c.a} vs ${c.b} (${c.aHex}/${c.bHex}) under ${c.condition} — ΔE ${c.deltaE} < ${c.min}`);
+    }
+    process.exit(1);
+  }
+  console.log(`✓ ${line}`);
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((e) => { console.error("✗ palette-gate: error —", e.stack || e.message); process.exit(1); });
+}

package/generators/gen-print-snapshots.mjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+// Printed-view snapshot generator — the print/PDF twin of gen-snapshots (which does
+// the headless reader/Markdown view). For every built page it renders the page's
+// `@media print` view to a durable `<page>.print.pdf`, so the printed artifact is
+// archived + content-addressable alongside the served bytes.
+//
+// Unlike the reader view, a PDF needs a real print-CSS renderer. The default is
+// `tezcatl` (macOS-native WebKit, no Chromium download) — the same engine the kit's
+// axe gate uses locally. So this generator is a LOCAL / macOS-deploy artifact: on a
+// host without the renderer (e.g. a Linux CI runner) it SKIPS with a clear note.
+//
+//   node generators/gen-print-snapshots.mjs [distDir]
+//
+// Config-driven; NOTHING about any one site is hard-coded:
+//   argv / $PRINT_DIST        built output dir                  (default: "dist")
+//   $PRINT_PAGES             comma list of page paths under dist (default: every *.html)
+//   $PRINT_RENDERER          renderer command                  (default: "tezcatl")
+//   $PRINT_WAIT              ms to let JS/layout settle         (default: 600)
+//   $PRINT_SUFFIX            output basename suffix             (default: ".print")
+//
+// The pure path/arg functions are exported for unit testing without a renderer.
+import { readdir, access, stat } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { spawn, spawnSync } from "node:child_process";
+import { resolve, join, relative, dirname, basename, extname } from "node:path";
+
+// ── Pure core (renderer-free; unit-testable) ─────────────────────────────────
+
+const MIME = {
+  ".html": "text/html", ".css": "text/css", ".js": "text/javascript",
+  ".json": "application/json", ".svg": "image/svg+xml", ".png": "image/png",
+  ".jpg": "image/jpeg", ".webp": "image/webp", ".woff2": "font/woff2",
+  ".woff": "font/woff", ".ico": "image/x-icon", ".txt": "text/plain",
+};
+export const mimeFor = (p) => MIME[extname(p).toLowerCase()] || "application/octet-stream";
+
+/** Output PDF path for a built page: dist/blog/x.html → dist/blog/x.print.pdf. */
+export function pdfOutPath(file, suffix = ".print") {
+  return join(dirname(file), basename(file, extname(file)) + suffix + ".pdf");
+}
+
+/** The renderer command + args. Pure: (renderer, url, out, wait) → [cmd, args]. */
+export function rendererCommand(renderer, url, out, wait = 600) {
+  if (renderer === "tezcatl") return ["tezcatl", [url, `--pdf=${out}`, `--wait=${wait}`]];
+  // A custom $PRINT_RENDERER is a command template: "cmd {url} {out}".
+  const parts = renderer.split(/\s+/).map((t) => t.replace("{url}", url).replace("{out}", out).replace("{wait}", String(wait)));
+  return [parts[0], parts.slice(1)];
+}
+
+// ── Impure: static origin + renderer ─────────────────────────────────────────
+
+/** Serve `root` over an ephemeral localhost origin so absolute asset paths resolve. */
+function startServer(root) {
+  return new Promise((res) => {
+    const server = createServer(async (req, res2) => {
+      try {
+        let p = join(root, decodeURIComponent((req.url || "/").split("?")[0]));
+        try { if ((await stat(p)).isDirectory()) p = join(p, "index.html"); } catch { p = join(root, "404.html"); }
+        res2.writeHead(200, { "content-type": mimeFor(p) });
+        res2.end(readFileSync(p));
+      } catch { res2.writeHead(404); res2.end(); }
+    });
+    server.listen(0, "127.0.0.1", () => res({ origin: `http://127.0.0.1:${server.address().port}`, close: () => server.close() }));
+  });
+}
+
+function render(renderer, url, out, wait) {
+  const [cmd, args] = rendererCommand(renderer, url, out, wait);
+  return new Promise((res, rej) => {
+    const ch = spawn(cmd, args, { stdio: ["ignore", "ignore", "pipe"] });
+    let err = "";
+    ch.stderr.on("data", (d) => (err += d));
+    ch.on("error", (e) => rej(new Error(`renderer "${cmd}" not runnable (on PATH?): ${e.message}`)));
+    ch.on("close", (code) => (code === 0 ? res() : rej(new Error(`renderer "${cmd}" exit ${code}: ${err.trim().slice(0, 200)}`))));
+  });
+}
+
+async function walkHtml(dir) {
+  const out = [];
+  for (const e of await readdir(dir, { withFileTypes: true })) {
+    const p = join(dir, e.name);
+    if (e.isDirectory()) out.push(...await walkHtml(p));
+    else if (e.name.endsWith(".html")) out.push(p);
+  }
+  return out;
+}
+
+/** Render each page → PDF. Exposed for programmatic use. */
+export async function genPrintSnapshots({ dist, pages, renderer = "tezcatl", wait = 600, suffix = ".print" }) {
+  const distAbs = resolve(dist);
+  const files = pages && pages.length ? pages.map((p) => resolve(distAbs, p)) : (await walkHtml(distAbs)).sort();
+  const { origin, close } = await startServer(distAbs);
+  const written = [];
+  try {
+    for (const file of files) {
+      const rel = relative(distAbs, file);
+      const out = pdfOutPath(file, suffix);
+      await render(renderer, `${origin}/${rel}`, out, wait);
+      written.push(relative(distAbs, out));
+    }
+  } finally { close(); }
+  return written;
+}
+
+// ── CLI ──────────────────────────────────────────────────────────────────────
+
+async function main() {
+  const distArg = process.argv.slice(2).find((a) => !a.startsWith("--"));
+  const dist = resolve(distArg || process.env.PRINT_DIST || "dist");
+  const exists = async (p) => { try { await access(p); return true; } catch { return false; } };
+  if (!(await exists(dist))) { console.error(`✗ gen-print-snapshots: ${dist} not found — build first.`); process.exit(2); }
+
+  const renderer = (process.env.PRINT_RENDERER || "tezcatl").trim();
+  const wait = Number.parseInt(process.env.PRINT_WAIT ?? "600", 10);
+  const suffix = process.env.PRINT_SUFFIX || ".print";
+  const pages = (process.env.PRINT_PAGES || "").split(",").map((s) => s.trim().replace(/^\//, "")).filter(Boolean);
+
+  // Renderer present? If not, SKIP (this is a local/macOS-deploy artifact, not CI).
+  const cmd0 = rendererCommand(renderer, "", "", wait)[0];
+  if (spawnSync(cmd0, ["--help"], { stdio: "ignore" }).error) {
+    console.log(`✓ gen-print-snapshots: renderer "${cmd0}" not on PATH — SKIPPED (run on a host with it, e.g. macOS + tezcatl).`);
+    return;
+  }
+
+  const written = await genPrintSnapshots({ dist, pages, renderer, wait, suffix });
+  for (const w of written) console.log(`  ✓ ${w}`);
+  console.log(`✓ gen-print-snapshots: ${written.length} printed PDF snapshot(s) via ${cmd0}.`);
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((e) => { console.error("✗ gen-print-snapshots: error —", e.stack || e.message); process.exit(1); });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bounded-systems/conformance-kit",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Standalone, site-agnostic web-conformance toolkit: integrity tooling + build gates + provenance generators, all parameterized so a site vendors one kit instead of duplicating scripts.",
   "type": "module",
   "license": "MIT",
@@ -9,25 +9,27 @@
     "url": "git+https://github.com/bounded-systems/conformance-kit.git"
   },
   "bin": {
-    "ck-gen-sitemanifest": "./integrity/gen-sitemanifest.mjs",
-    "ck-gen-provenance": "./integrity/gen-provenance.mjs",
-    "ck-verify-site": "./integrity/verify-site.mjs",
-    "ck-http-probe": "./integrity/http-probe.mjs",
-    "ck-structure-audit": "./integrity/structure-audit/audit.mjs",
-    "ck-gen-sbom": "./gates/sbom/gen-sbom.mjs",
-    "ck-check-sbom": "./gates/sbom/check-sbom.mjs",
-    "ck-shacl-runner": "./gates/shacl-runner.mjs",
-    "ck-seo-gate": "./gates/seo-gate.mjs",
-    "ck-axe-gate": "./gates/axe-gate.mjs",
-    "ck-vuln-gate": "./gates/vuln-gate.mjs",
-    "ck-html-validator-gate": "./gates/html-validator-gate.mjs",
-    "ck-baseline-gate": "./gates/baseline-gate.mjs",
-    "ck-jargon-gate": "./gates/jargon-gate.mjs",
-    "ck-readability-gate": "./gates/readability-gate.mjs",
-    "ck-commonmark-runner": "./gates/commonmark-runner.mjs",
-    "ck-gen-cid": "./generators/gen-cid.mjs",
-    "ck-gen-identity": "./generators/gen-identity.mjs",
-    "ck-gen-snapshots": "./generators/gen-snapshots.mjs"
+    "ck-gen-sitemanifest": "integrity/gen-sitemanifest.mjs",
+    "ck-gen-provenance": "integrity/gen-provenance.mjs",
+    "ck-verify-site": "integrity/verify-site.mjs",
+    "ck-http-probe": "integrity/http-probe.mjs",
+    "ck-structure-audit": "integrity/structure-audit/audit.mjs",
+    "ck-gen-sbom": "gates/sbom/gen-sbom.mjs",
+    "ck-check-sbom": "gates/sbom/check-sbom.mjs",
+    "ck-shacl-runner": "gates/shacl-runner.mjs",
+    "ck-seo-gate": "gates/seo-gate.mjs",
+    "ck-axe-gate": "gates/axe-gate.mjs",
+    "ck-vuln-gate": "gates/vuln-gate.mjs",
+    "ck-html-validator-gate": "gates/html-validator-gate.mjs",
+    "ck-baseline-gate": "gates/baseline-gate.mjs",
+    "ck-palette-gate": "gates/palette-gate.mjs",
+    "ck-jargon-gate": "gates/jargon-gate.mjs",
+    "ck-readability-gate": "gates/readability-gate.mjs",
+    "ck-commonmark-runner": "gates/commonmark-runner.mjs",
+    "ck-gen-cid": "generators/gen-cid.mjs",
+    "ck-gen-identity": "generators/gen-identity.mjs",
+    "ck-gen-snapshots": "generators/gen-snapshots.mjs",
+    "ck-gen-print-snapshots": "generators/gen-print-snapshots.mjs"
   },
   "scripts": {
     "test": "node test/run.mjs"