ultra11y 2.22.0 → 2.24.0

package/scripts/ultra11y.mjs

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { realpathSync as realpathSync4, writeFileSync as writeFileSync13, mkdirSync as mkdirSync10, existsSync as existsSync21, readFileSync as readFileSync17, appendFileSync } from "fs";
-import { join as join36, relative as relative3, sep as sep6, dirname as dirname10 } from "path";
+import { realpathSync as realpathSync4, writeFileSync as writeFileSync14, mkdirSync as mkdirSync11, existsSync as existsSync22, readFileSync as readFileSync19, appendFileSync } from "fs";
+import { join as join38, relative as relative3, sep as sep6, dirname as dirname11 } from "path";
 import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL3 } from "url";
 
 // src/types.ts
-var VERSION = "2.22.0";
+var VERSION = "2.24.0";
 var SCHEMA_VERSION = 2;
 
 // src/audit.ts
@@ -385,7 +385,7 @@ var wcag_default = {
       level: "AA",
       addedIn: "2.1",
       automatability: "needs-rendering",
-      ruleIds: [],
+      ruleIds: ["rendered-orientation-lock"],
       understanding: "https://www.w3.org/WAI/WCAG22/Understanding/orientation.html"
     },
     {
@@ -410,7 +410,7 @@ var wcag_default = {
       level: "A",
       addedIn: "2.0",
       automatability: "needs-rendering",
-      ruleIds: [],
+      ruleIds: ["rendered-link-colour-only"],
       understanding: "https://www.w3.org/WAI/WCAG22/Understanding/use-of-color.html",
       techniques: ["C15", "F14", "F26", "F73", "F78", "G111", "G117", "G138", "G14", "G140", "G149", "G165", "G182", "G183", "G195", "G205", "G96", "SCR31"]
     },
@@ -436,7 +436,7 @@ var wcag_default = {
       level: "AA",
       addedIn: "2.0",
       automatability: "needs-rendering",
-      ruleIds: ["contrast-literal"],
+      ruleIds: ["contrast-literal", "rendered-contrast", "rendered-contrast-pixel"],
       understanding: "https://www.w3.org/WAI/WCAG22/Understanding/contrast-minimum.html",
       techniques: ["C29", "F24", "G136", "G145", "G148", "G174", "G18"]
     },
@@ -488,7 +488,7 @@ var wcag_default = {
       level: "AA",
       addedIn: "2.1",
       automatability: "needs-rendering",
-      ruleIds: [],
+      ruleIds: ["rendered-nontext-contrast"],
       understanding: "https://www.w3.org/WAI/WCAG22/Understanding/non-text-contrast.html",
       techniques: ["F78", "G145", "G174", "G18", "G183", "G195", "G207"]
     },
@@ -745,7 +745,7 @@ var wcag_default = {
       level: "AA",
       addedIn: "2.0",
       automatability: "needs-rendering",
-      ruleIds: [],
+      ruleIds: ["rendered-focus-not-visible"],
       understanding: "https://www.w3.org/WAI/WCAG22/Understanding/focus-visible.html",
       techniques: ["C15", "F42", "F54", "F55", "F73", "F78", "G149", "G165", "G183", "G195", "G202", "G90", "SCR2", "SCR20", "SCR29", "SCR31", "SCR35"]
     },
@@ -1770,6 +1770,9 @@ function scsByGuideline() {
 function techniques(id) {
   return byId.get(id)?.techniques ?? [];
 }
+function understanding(id) {
+  return byId.get(id)?.understanding;
+}
 function meta() {
   return {
     wcagVersion: data.wcagVersion,
@@ -1779,6 +1782,15 @@ function meta() {
     criteriaSource: data.criteriaSource
   };
 }
+function compareSC(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i2 = 0; i2 < Math.max(pa.length, pb.length); i2++) {
+    const d = (pa[i2] ?? 0) - (pb[i2] ?? 0);
+    if (d) return d;
+  }
+  return 0;
+}
 function techniquesFor(id) {
   return getSC(id)?.techniques ?? [];
 }
@@ -10708,12 +10720,12 @@ var Tokenizer2 = class extends CommentsParser {
           continue;
         }
         ++this.state.pos;
-        const esc = this.readCodePoint(true);
-        if (esc !== null) {
-          if (!identifierCheck(esc)) {
+        const esc3 = this.readCodePoint(true);
+        if (esc3 !== null) {
+          if (!identifierCheck(esc3)) {
             this.raise(Errors.EscapedCharNotAnIdentifier, escStart);
           }
-          word += String.fromCodePoint(esc);
+          word += String.fromCodePoint(esc3);
         }
         chunkStart = this.state.pos;
       } else {
@@ -18794,6 +18806,15 @@ function readText(path) {
 function ext(path) {
   return extname(path).toLowerCase();
 }
+function isUrlPath(file) {
+  return /^https?:\/\//i.test(file);
+}
+function repoRelative(file, baseDir) {
+  const posix3 = file.split("\\").join("/").replace(/^\.\//, "");
+  const base = baseDir.split("\\").join("/").replace(/\/+$/, "");
+  if (base && posix3.startsWith(`${base}/`)) return posix3.slice(base.length + 1);
+  return posix3;
+}
 async function readStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) chunks.push(chunk);
@@ -31494,13 +31515,13 @@ function computeDelta(graph, symbols, diff, depth = DEFAULT_DELTA_DEPTH) {
       const shown = exportedNames.slice(0, 3).join(", ") + (exportedNames.length > 3 ? ", \u2026" : "");
       reasons.push(exportedNames.length === 1 ? `exported symbol ${shown} changed` : `exported symbols ${shown} changed`);
     }
-    const pct = percentile(metricValues, metricOf(m));
-    if (pct >= 0.9) {
+    const pct2 = percentile(metricValues, metricOf(m));
+    if (pct2 >= 0.9) {
       score += RISK_WEIGHTS.hubHigh;
-      reasons.push(`${metricName} p${Math.round(pct * 100)} hub`);
-    } else if (pct >= 0.75) {
+      reasons.push(`${metricName} p${Math.round(pct2 * 100)} hub`);
+    } else if (pct2 >= 0.75) {
       score += RISK_WEIGHTS.hubMed;
-      reasons.push(`${metricName} p${Math.round(pct * 100)} hub`);
+      reasons.push(`${metricName} p${Math.round(pct2 * 100)} hub`);
     }
     const depthByRel = /* @__PURE__ */ new Map();
     const impModules = /* @__PURE__ */ new Set();
@@ -32456,6 +32477,8 @@ function formatCaptureComment(prov) {
   if (prov.component) attrs.push(`component="${escapeCommentValue(prov.component)}"`);
   if (prov.test) attrs.push(`test="${escapeCommentValue(prov.test)}"`);
   if (prov.name) attrs.push(`name="${escapeCommentValue(prov.name)}"`);
+  if (prov.page) attrs.push(`page="${escapeCommentValue(prov.page)}"`);
+  if (prov.url) attrs.push(`url="${escapeCommentValue(prov.url)}"`);
   return `<!-- ultra11y:capture ${attrs.join(" ")} -->`;
 }
 var SCAN_LIMIT = 4096;
@@ -32478,7 +32501,9 @@ function parseCaptureProvenance(source) {
     ...kv.has("source") ? { sourceFile: kv.get("source") } : {},
     ...kv.has("component") ? { component: kv.get("component") } : {},
     ...kv.has("test") ? { test: kv.get("test") } : {},
-    ...kv.has("name") ? { name: kv.get("name") } : {}
+    ...kv.has("name") ? { name: kv.get("name") } : {},
+    ...kv.has("page") ? { page: kv.get("page") } : {},
+    ...kv.has("url") ? { url: kv.get("url") } : {}
   };
 }
 function pathMatch(a, b) {
@@ -32579,6 +32604,271 @@ function parseSourceWithAst(source, file, opts = {}) {
   return { doc, ast: null };
 }
 
+// src/snapshot.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync10, readdirSync as readdirSync4, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname5, join as join21 } from "path";
+var SNAPSHOT_VERSION = 1;
+var PAGES_DIR = ".ultra11y/pages";
+var ID_RE = /^[a-z0-9][a-z0-9-]*$/i;
+function validateSnapshotMeta(raw) {
+  const issues = [];
+  const err2 = (path, message) => {
+    issues.push({ path, message });
+  };
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    err2("meta", "meta must be an object { v, id, name, url, \u2026 }");
+    return { ok: false, issues };
+  }
+  const m = raw;
+  const v = typeof m.v === "number" ? m.v : Number.NaN;
+  if (!Number.isFinite(v) || v < 1) err2("meta.v", "v must be a positive integer snapshot-format version");
+  else if (v > SNAPSHOT_VERSION) err2("meta.v", `snapshot format v${v} is newer than this engine understands (v${SNAPSHOT_VERSION}) \u2014 upgrade ultra11y`);
+  if (typeof m.id !== "string" || !m.id.trim()) err2("meta.id", "id must be a non-empty string");
+  else if (!ID_RE.test(m.id)) err2("meta.id", `id "${m.id}" must match ${ID_RE} (it becomes a directory name)`);
+  if (typeof m.name !== "string" || !m.name.trim()) err2("meta.name", "name must be a non-empty string");
+  if (typeof m.url !== "string" || !m.url.trim()) err2("meta.url", "url must be a non-empty string");
+  if (m.auth !== void 0 && typeof m.auth !== "boolean") err2("meta.auth", "auth must be a boolean");
+  if (m.route !== void 0 && typeof m.route !== "string") err2("meta.route", "route must be a string");
+  if (m.notes !== void 0 && typeof m.notes !== "string") err2("meta.notes", "notes must be a string");
+  if (m.sources !== void 0 && (!Array.isArray(m.sources) || m.sources.some((s) => typeof s !== "string")))
+    err2("meta.sources", "sources must be an array of strings");
+  if (issues.length) return { ok: false, issues };
+  return {
+    ok: true,
+    issues,
+    meta: {
+      v,
+      id: m.id,
+      name: m.name,
+      url: m.url,
+      ...typeof m.route === "string" ? { route: m.route } : {},
+      ...typeof m.auth === "boolean" ? { auth: m.auth } : {},
+      ...m.viewport && typeof m.viewport === "object" ? { viewport: m.viewport } : {},
+      ...typeof m.capturedAt === "string" ? { capturedAt: m.capturedAt } : {},
+      ...typeof m.runner === "string" ? { runner: m.runner } : {},
+      ...Array.isArray(m.sources) ? { sources: m.sources } : {},
+      ...typeof m.notes === "string" ? { notes: m.notes } : {}
+    }
+  };
+}
+function snapshotDir(root, id) {
+  return join21(root, PAGES_DIR, id);
+}
+function writeSnapshot(root, snap) {
+  const dir = snapshotDir(root, snap.meta.id);
+  mkdirSync4(dir, { recursive: true });
+  writeFileSync5(join21(dir, "meta.json"), `${JSON.stringify(snap.meta, null, 2)}
+`);
+  const comment = formatCaptureComment({
+    v: 1,
+    page: snap.meta.id,
+    url: snap.meta.url,
+    ...snap.meta.sources?.[0] ? { sourceFile: snap.meta.sources[0] } : {},
+    name: snap.meta.name
+  });
+  writeFileSync5(join21(dir, "dom.html"), `${comment}
+${snap.dom}
+`);
+  if (snap.styles) writeFileSync5(join21(dir, "styles.json"), `${JSON.stringify(snap.styles)}
+`);
+  if (snap.boxes) writeFileSync5(join21(dir, "boxes.json"), `${JSON.stringify(snap.boxes)}
+`);
+  if (snap.axtree) writeFileSync5(join21(dir, "axtree.json"), `${JSON.stringify(snap.axtree)}
+`);
+  if (snap.css) writeFileSync5(join21(dir, "css.json"), `${JSON.stringify(snap.css)}
+`);
+  return dir;
+}
+function readJson2(file) {
+  try {
+    return JSON.parse(readFileSync10(file, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function readSnapshot(dir) {
+  const rawMeta = readJson2(join21(dir, "meta.json"));
+  if (rawMeta === void 0) return null;
+  const v = validateSnapshotMeta(rawMeta);
+  if (!v.ok || !v.meta) return null;
+  let dom;
+  try {
+    dom = readFileSync10(join21(dir, "dom.html"), "utf8");
+  } catch {
+    return null;
+  }
+  const styles = readJson2(join21(dir, "styles.json"));
+  const boxes = readJson2(join21(dir, "boxes.json"));
+  const axtree = readJson2(join21(dir, "axtree.json"));
+  const css = readJson2(join21(dir, "css.json"));
+  const shot = join21(dir, "screen.png");
+  return {
+    meta: v.meta,
+    dom,
+    ...styles ? { styles } : {},
+    ...boxes ? { boxes } : {},
+    ...axtree ? { axtree } : {},
+    ...css ? { css } : {},
+    ...existsSync9(shot) ? { screenshot: "screen.png" } : {}
+  };
+}
+function readSnapshots(root) {
+  const base = join21(root, PAGES_DIR);
+  let dirs;
+  try {
+    dirs = readdirSync4(base, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return [];
+  }
+  const out2 = [];
+  for (const d of dirs.sort()) {
+    const s = readSnapshot(join21(base, d));
+    if (s) out2.push(s);
+  }
+  return out2;
+}
+var COLLECTED_CSS = [
+  "color",
+  "backgroundColor",
+  "backgroundImage",
+  "fontSize",
+  "fontWeight",
+  "fontStyle",
+  "textDecorationLine",
+  "textTransform",
+  "lineHeight",
+  "letterSpacing",
+  "wordSpacing",
+  "whiteSpace",
+  "display",
+  "visibility",
+  "opacity",
+  "position",
+  "overflowX",
+  "overflowY",
+  "outlineStyle",
+  "outlineWidth",
+  "outlineColor",
+  // All four borders + the box shadow: WCAG 1.4.11 asks whether a control's BOUNDARY is
+  // perceivable, and a boundary can be drawn by any side, by the fill, by an outline or by a
+  // shadow. Collecting only one side would manufacture non-conformities on the other three.
+  "borderTopStyle",
+  "borderRightStyle",
+  "borderBottomStyle",
+  "borderLeftStyle",
+  "borderTopWidth",
+  "borderRightWidth",
+  "borderBottomWidth",
+  "borderLeftWidth",
+  "borderTopColor",
+  "borderRightColor",
+  "borderBottomColor",
+  "borderLeftColor",
+  "boxShadow",
+  "cursor"
+];
+var COLLECT_MAX_ELEMENTS = 5e3;
+var COLLECT_SNAPSHOT = `(() => {
+  const PROPS = ${JSON.stringify(COLLECTED_CSS)};
+  const MAX = ${COLLECT_MAX_ELEMENTS};
+  const els = document.querySelectorAll('*');
+  const styles = [];
+  const boxes = [];
+  const n = Math.min(els.length, MAX);
+  for (let i = 0; i < n; i++) {
+    const el = els[i];
+    const tag = el.tagName.toLowerCase();
+    const cs = getComputedStyle(el);
+    const css = {};
+    for (const p of PROPS) {
+      const v = cs[p];
+      if (v !== undefined && v !== null && v !== '') css[p] = String(v);
+    }
+    styles.push({ i: i, tag: tag, css: css });
+    const r = el.getBoundingClientRect();
+    boxes.push({ i: i, tag: tag, x: Math.round(r.left), y: Math.round(r.top), w: Math.round(r.width), h: Math.round(r.height) });
+  }
+  // The page's own stylesheets. Some criteria are properties of the STYLESHEET rather than of
+  // any element's computed style \u2014 focus styling removed with no replacement (2.4.7), a media
+  // query that locks the orientation (1.3.4) \u2014 and this is the only place they exist.
+  // A cross-origin sheet throws on .cssRules: COUNT those instead of ignoring them, so a rule
+  // reading this digest can tell "nothing there" apart from "I could not look".
+  const cssRules = [];
+  let unreadable = 0;
+  const MAXR = 4000;
+  const camel = (p) => p.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+  const walk = (list, media) => {
+    for (const r of list) {
+      if (cssRules.length >= MAXR) return;
+      if (typeof r.selectorText === 'string' && r.style) {
+        const decls = {};
+        for (let i = 0; i < r.style.length; i++) {
+          const prop = r.style[i];
+          decls[camel(prop)] = r.style.getPropertyValue(prop);
+        }
+        cssRules.push(media ? { selector: r.selectorText, media: media, decls: decls } : { selector: r.selectorText, decls: decls });
+      } else if (r.cssRules) {
+        const cond = r.conditionText || (r.media && r.media.mediaText) || media;
+        walk(r.cssRules, cond);
+      }
+    }
+  };
+  for (const sheet of document.styleSheets) {
+    try {
+      walk(sheet.cssRules, undefined);
+    } catch (e) {
+      unreadable++;
+    }
+  }
+
+  const truncated = els.length > MAX;
+  return {
+    dom: document.documentElement.outerHTML,
+    css: { v: 1, rules: cssRules, unreadable: unreadable, truncated: cssRules.length >= MAXR },
+    title: document.title,
+    lang: document.documentElement.getAttribute('lang') || '',
+    url: location.href,
+    viewport: { width: window.innerWidth, height: window.innerHeight },
+    styles: { v: 1, entries: styles, truncated: truncated },
+    boxes: { v: 1, entries: boxes, truncated: truncated }
+  };
+})()`;
+function isSnapshotDom(file) {
+  const posix3 = file.split("\\").join("/");
+  return posix3.endsWith("/dom.html") && posix3.includes(`${PAGES_DIR}/`);
+}
+function align(doc, entries) {
+  const out2 = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const el = doc.elements[e.i];
+    if (!el || el.tag !== e.tag) return null;
+    out2.set(e.i, e);
+  }
+  return out2;
+}
+function attachSignals(doc) {
+  if (!isSnapshotDom(doc.file)) return;
+  const dir = dirname5(doc.file);
+  const styles = readJson2(join21(dir, "styles.json"));
+  const boxes = readJson2(join21(dir, "boxes.json"));
+  const axtree = readJson2(join21(dir, "axtree.json"));
+  const css = readJson2(join21(dir, "css.json"));
+  const shot = join21(dir, "screen.png");
+  const alignedStyleMap = styles ? align(doc, styles.entries) : null;
+  const alignedBoxMap = boxes ? align(doc, boxes.entries) : null;
+  const truncated = Boolean(styles?.truncated || boxes?.truncated);
+  const signals = {
+    ...alignedStyleMap ? { styles: alignedStyleMap } : {},
+    ...alignedBoxMap ? { boxes: alignedBoxMap } : {},
+    ...axtree ? { axtree } : {},
+    // Not element-indexed, so it needs no alignment — it is a property of the stylesheet.
+    ...css ? { css } : {},
+    ...existsSync9(shot) ? { screenshot: shot } : {},
+    ...truncated ? { truncated } : {}
+  };
+  if (Object.keys(signals).length) doc.signals = signals;
+}
+
 // src/messages.ts
 var MSG_CATALOG = {
   // ---- Theme 1 — Images (src/rules/images.ts) ---------------------------------
@@ -32824,6 +33114,69 @@ var MSG_CATALOG = {
       en: (p) => `Darken the text or lighten the background to reach at least ${p.min}:1 (contrast computed from literal inline colours).`
     }
   },
+  // ---- Rendered tier (src/rules/rendered.ts) — decided from a page snapshot's signals -----
+  // These say WHERE the measurement came from, because that is what makes them auditable: a
+  // computed style, or a region of the screenshot. An auditor can go and re-check either.
+  "rendered-contrast": {
+    message: {
+      fr: (p) => `Contraste insuffisant au rendu : ratio ${p.ratio}:1 entre le texte et son fond effectif (minimum ${p.min}:1 pour du texte ${p.textSize === "large" ? "large" : "normal"}).`,
+      en: (p) => `Insufficient contrast at render: ${p.ratio}:1 between the text and its effective background (minimum ${p.min}:1 for ${p.textSize === "large" ? "large" : "normal"} text).`
+    },
+    remediation: {
+      fr: (p) => `Assombrissez le texte ou \xE9claircissez le fond pour atteindre au moins ${p.min}:1 (mesur\xE9 sur les styles calcul\xE9s de la page rendue).`,
+      en: (p) => `Darken the text or lighten the background to reach at least ${p.min}:1 (measured from the rendered page's computed styles).`
+    }
+  },
+  "rendered-contrast-pixel": {
+    message: {
+      fr: (p) => `Contraste insuffisant mesur\xE9 sur la capture d'\xE9cran : ratio ${p.ratio}:1 (minimum ${p.min}:1 pour du texte ${p.textSize === "large" ? "large" : "normal"}). Le fond vient d'une image ou d'un d\xE9grad\xE9, invisible aux styles calcul\xE9s.`,
+      en: (p) => `Insufficient contrast measured on the screenshot: ${p.ratio}:1 (minimum ${p.min}:1 for ${p.textSize === "large" ? "large" : "normal"} text). The background comes from an image or gradient, which computed styles cannot express.`
+    },
+    remediation: {
+      fr: (p) => `Garantissez au moins ${p.min}:1 sur toute la zone : ajoutez un fond opaque sous le texte, un voile, ou une ombre port\xE9e. Le fond a \xE9t\xE9 mesur\xE9 sur les pixels de la zone occup\xE9e par le texte.`,
+      en: (p) => `Guarantee at least ${p.min}:1 across the whole area: add an opaque backing behind the text, a scrim, or a text shadow. The background was measured on the pixels of the text's own box.`
+    }
+  },
+  "rendered-link-colour-only": {
+    message: {
+      fr: (p) => `Lien dans un bloc de texte distingu\xE9 par la COULEUR SEULE (\xE9cart de ${p.ratio}:1 avec le texte environnant, sans soulignement, bordure ni fond) \u2014 invisible pour qui ne per\xE7oit pas cette diff\xE9rence de couleur.`,
+      en: (p) => `Link inside a text block distinguished by COLOUR ALONE (${p.ratio}:1 apart from the surrounding text, with no underline, border or background) \u2014 invisible to anyone who does not perceive that colour difference.`
+    },
+    remediation: {
+      fr: () => `Ajoutez un indice non chromatique : text-decoration: underline (le plus simple), une bordure basse, ou une graisse nettement sup\xE9rieure. \xC0 d\xE9faut, un contraste d'au moins 3:1 avec le texte environnant ET un indice au survol/focus.`,
+      en: () => `Add a non-colour cue: text-decoration: underline (simplest), a bottom border, or a distinctly heavier weight. Failing that, at least 3:1 contrast with the surrounding text AND a cue on hover/focus.`
+    }
+  },
+  "rendered-nontext-contrast": {
+    message: {
+      fr: (p) => `Limite du composant <${p.control}> non perceptible : ni son fond (${p.ratio}:1 avec l'environnement) ni sa bordure n'atteignent 3:1 \u2014 rien n'indique visuellement o\xF9 commence le champ.`,
+      en: (p) => `The <${p.control}> boundary is not perceivable: neither its fill (${p.ratio}:1 against its surroundings) nor its border reaches 3:1 \u2014 nothing shows visually where the control begins.`
+    },
+    remediation: {
+      fr: () => `Donnez au composant une bordure visible contrastant \xE0 3:1 avec le fond environnant, ou un fond distinct du fond environnant \xE0 3:1. Un box-shadow ou un outline visible conviennent aussi.`,
+      en: () => `Give the control a visible border at 3:1 against the surrounding background, or a fill distinct from it at 3:1. A visible box-shadow or outline also qualifies.`
+    }
+  },
+  "rendered-focus-not-visible": {
+    message: {
+      fr: (p) => `La feuille de styles supprime l'indicateur de focus (\`${p.selector}\`) et aucune r\xE8gle \`:focus\` ne le remplace \u2014 un utilisateur au clavier ne peut plus savoir o\xF9 il se trouve.`,
+      en: (p) => `The stylesheet removes the focus indicator (\`${p.selector}\`) and no \`:focus\` rule puts one back \u2014 a keyboard user can no longer tell where they are.`
+    },
+    remediation: {
+      fr: () => `Ne supprimez jamais outline sans remplacement. Si le style par d\xE9faut ne convient pas, remplacez-le : \`:focus-visible { outline: 2px solid <couleur contrast\xE9e>; outline-offset: 2px }\`.`,
+      en: () => `Never remove outline without a replacement. If the default does not fit, replace it: \`:focus-visible { outline: 2px solid <contrasting colour>; outline-offset: 2px }\`.`
+    }
+  },
+  "rendered-orientation-lock": {
+    message: {
+      fr: (p) => `Le contenu est verrouill\xE9 dans une seule orientation : \`@media ${p.media}\` applique \`transform: ${p.transform}\` au document \u2014 l'utilisateur ne peut pas consulter la page dans l'orientation de son choix.`,
+      en: (p) => `Content is locked to a single orientation: \`@media ${p.media}\` applies \`transform: ${p.transform}\` to the document \u2014 the user cannot view the page in the orientation they need.`
+    },
+    remediation: {
+      fr: () => `Supprimez la rotation et rendez la mise en page responsive dans les deux orientations. Un verrouillage n'est admis que si l'orientation est essentielle (piano, ch\xE8que bancaire).`,
+      en: () => `Remove the rotation and make the layout work in both orientations. Locking is only acceptable where the orientation is essential (a piano keyboard, a bank cheque).`
+    }
+  },
   // ---- Theme 5 — Data tables (src/rules/tables.ts) ----------------------------
   "data-table-no-headers.no-th": {
     message: {
@@ -33566,6 +33919,9 @@ function toFinding(doc, ruleId, def, rf, ruleAdvisory) {
     // Capture findings are rendered ground truth (NOT preliminary): re-attribute them
     // to the source component recorded in the capture's provenance.
     ...doc.capture ? { origin: { capture: doc.file, sourceFile: doc.capture.sourceFile, component: doc.capture.component } } : {},
+    // A PAGE snapshot's capture carries which page it is; stamp it so the per-page grid can
+    // key on the finding directly (src/pages.ts). Component captures carry no page.
+    ...doc.capture?.page ? { page: doc.capture.page } : {},
     // Non-normative recommendation: the per-finding override (rf.advisory) wins over the
     // rule-level default (ruleAdvisory); only stamp the flag when it is actually true, so
     // a normative finding stays byte-identical (no `advisory: false` noise in the JSON).
@@ -36282,6 +36638,422 @@ var contrastLiteral = {
 };
 var colorsRules = [contrastLiteral];
 
+// src/rules/rendered.ts
+import { readFileSync as readFileSync11 } from "fs";
+
+// src/pixel.ts
+import { inflateSync } from "zlib";
+var SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
+function paeth(a, b, c2) {
+  const p = a + b - c2;
+  const pa = Math.abs(p - a);
+  const pb = Math.abs(p - b);
+  const pc = Math.abs(p - c2);
+  if (pa <= pb && pa <= pc) return a;
+  return pb <= pc ? b : c2;
+}
+function decodePng(buf) {
+  if (buf.length < 8 + 25) return null;
+  for (let i2 = 0; i2 < SIGNATURE.length; i2++) if (buf[i2] !== SIGNATURE[i2]) return null;
+  let width = 0;
+  let height = 0;
+  let bitDepth = 0;
+  let colorType = 0;
+  let interlace = 0;
+  const idat = [];
+  let off = 8;
+  while (off + 8 <= buf.length) {
+    const len = buf.readUInt32BE(off);
+    const type = buf.toString("ascii", off + 4, off + 8);
+    const dataStart = off + 8;
+    const dataEnd = dataStart + len;
+    if (dataEnd + 4 > buf.length) return null;
+    if (type === "IHDR") {
+      if (len < 13) return null;
+      width = buf.readUInt32BE(dataStart);
+      height = buf.readUInt32BE(dataStart + 4);
+      bitDepth = buf[dataStart + 8] ?? 0;
+      colorType = buf[dataStart + 9] ?? 0;
+      interlace = buf[dataStart + 12] ?? 0;
+    } else if (type === "IDAT") {
+      idat.push(buf.subarray(dataStart, dataEnd));
+    } else if (type === "IEND") {
+      break;
+    }
+    off = dataEnd + 4;
+  }
+  if (!width || !height || !idat.length) return null;
+  if (bitDepth !== 8) return null;
+  if (colorType !== 2 && colorType !== 6) return null;
+  if (interlace !== 0) return null;
+  const channels = colorType === 6 ? 4 : 3;
+  let raw;
+  try {
+    raw = inflateSync(Buffer.concat(idat));
+  } catch {
+    return null;
+  }
+  const stride = width * channels;
+  if (raw.length < height * (stride + 1)) return null;
+  const out2 = Buffer.alloc(height * stride);
+  for (let y = 0; y < height; y++) {
+    const filter = raw[y * (stride + 1)] ?? 0;
+    const lineIn = y * (stride + 1) + 1;
+    const lineOut = y * stride;
+    const prevOut = lineOut - stride;
+    for (let i2 = 0; i2 < stride; i2++) {
+      const x = raw[lineIn + i2] ?? 0;
+      const a = i2 >= channels ? out2[lineOut + i2 - channels] ?? 0 : 0;
+      const b = y > 0 ? out2[prevOut + i2] ?? 0 : 0;
+      const c2 = y > 0 && i2 >= channels ? out2[prevOut + i2 - channels] ?? 0 : 0;
+      let v;
+      switch (filter) {
+        case 0:
+          v = x;
+          break;
+        case 1:
+          v = x + a;
+          break;
+        case 2:
+          v = x + b;
+          break;
+        case 3:
+          v = x + (a + b >> 1);
+          break;
+        case 4:
+          v = x + paeth(a, b, c2);
+          break;
+        default:
+          return null;
+      }
+      out2[lineOut + i2] = v & 255;
+    }
+  }
+  return {
+    width,
+    height,
+    at(x, y) {
+      if (x < 0 || y < 0 || x >= width || y >= height) return void 0;
+      const p = y * stride + x * channels;
+      return {
+        r: out2[p] ?? 0,
+        g: out2[p + 1] ?? 0,
+        b: out2[p + 2] ?? 0,
+        a: channels === 4 ? (out2[p + 3] ?? 255) / 255 : 1
+      };
+    }
+  };
+}
+function clamp(img, r) {
+  const x = Math.max(0, Math.round(r.x));
+  const y = Math.max(0, Math.round(r.y));
+  const x2 = Math.min(img.width, Math.round(r.x + r.w));
+  const y2 = Math.min(img.height, Math.round(r.y + r.h));
+  if (x2 <= x || y2 <= y) return null;
+  return { x, y, w: x2 - x, h: y2 - y };
+}
+var MAX_SAMPLES = 4096;
+var DOMINANCE = 0.6;
+var BUCKET = 16;
+function dominantBackground(img, rect) {
+  const r = clamp(img, rect);
+  if (!r) return null;
+  const step = Math.max(1, Math.floor(Math.sqrt(r.w * r.h / MAX_SAMPLES)));
+  const counts = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (let y = r.y; y < r.y + r.h; y += step) {
+    for (let x = r.x; x < r.x + r.w; x += step) {
+      const p = img.at(x, y);
+      if (!p) continue;
+      const key = Math.round(p.r / BUCKET) << 16 | Math.round(p.g / BUCKET) << 8 | Math.round(p.b / BUCKET);
+      const cur = counts.get(key) ?? { n: 0, r: 0, g: 0, b: 0 };
+      cur.n++;
+      cur.r += p.r;
+      cur.g += p.g;
+      cur.b += p.b;
+      counts.set(key, cur);
+      total++;
+    }
+  }
+  if (!total) return null;
+  let best = null;
+  for (const c2 of counts.values()) if (!best || c2.n > best.n) best = c2;
+  if (!best || best.n / total < DOMINANCE) return null;
+  return { r: Math.round(best.r / best.n), g: Math.round(best.g / best.n), b: Math.round(best.b / best.n), a: 1 };
+}
+
+// src/rules/rendered.ts
+var SKIP_TAGS2 = /* @__PURE__ */ new Set(["script", "style", "head", "title", "meta", "noscript", "link", "html", "br", "wbr"]);
+function styleAt(doc, i2) {
+  return doc.signals?.styles?.get(i2);
+}
+function hasDirectText2(el) {
+  return el.children.some((c2) => c2.type === "text" && c2.data.trim() !== "");
+}
+function invisible(css) {
+  if (css.display === "none" || css.visibility === "hidden") return true;
+  const op = Number.parseFloat(css.opacity ?? "1");
+  return Number.isFinite(op) && op === 0;
+}
+function backdropOf(doc, index, el) {
+  for (let p = el; p; p = p.parent) {
+    const i2 = index.get(p);
+    if (i2 === void 0) continue;
+    const css = styleAt(doc, i2)?.css;
+    if (!css) continue;
+    const img = css.backgroundImage;
+    if (img && img !== "none") return void 0;
+    const c2 = parseColor(css.backgroundColor ?? "");
+    if (c2 && c2.a >= 1) return { color: c2, fromImage: false };
+  }
+  return void 0;
+}
+function isLargeText(css) {
+  const px = Number.parseFloat(css.fontSize ?? "");
+  if (!Number.isFinite(px)) return false;
+  const weight = Number.parseInt(css.fontWeight ?? "400", 10);
+  const bold = Number.isFinite(weight) ? weight >= 700 : css.fontWeight === "bold";
+  return px >= 24 || px >= 18.66 && bold;
+}
+function elementIndex(doc) {
+  const m = /* @__PURE__ */ new Map();
+  doc.elements.forEach((el, i2) => m.set(el, i2));
+  return m;
+}
+var renderedContrast = {
+  id: "rendered-contrast",
+  criteria: ["1.4.3"],
+  severity: "majeur",
+  run(doc) {
+    if (!doc.signals?.styles) return [];
+    const index = elementIndex(doc);
+    const out2 = [];
+    for (const [el, i2] of index) {
+      if (SKIP_TAGS2.has(el.tag) || !hasDirectText2(el)) continue;
+      const css = styleAt(doc, i2)?.css;
+      if (!css || invisible(css)) continue;
+      const fg = parseColor(css.color ?? "");
+      if (!fg || fg.a < 1) continue;
+      const bd = backdropOf(doc, index, el);
+      if (!bd) continue;
+      const ratio = contrastRatio(fg, bd.color);
+      const large = isLargeText(css);
+      const min = large ? 3 : 4.5;
+      if (ratio >= min) continue;
+      out2.push({
+        criteriaId: "1.4.3",
+        el,
+        msgId: "rendered-contrast",
+        params: { ratio: ratio.toFixed(2), min, textSize: large ? "large" : "normal" }
+      });
+    }
+    return out2;
+  }
+};
+var renderedContrastPixel = {
+  id: "rendered-contrast-pixel",
+  criteria: ["1.4.3"],
+  severity: "majeur",
+  run(doc) {
+    const shot = doc.signals?.screenshot;
+    const boxes = doc.signals?.boxes;
+    if (!shot || !boxes || !doc.signals?.styles) return [];
+    let img = null;
+    try {
+      img = decodePng(readFileSync11(shot));
+    } catch {
+      return [];
+    }
+    if (!img) return [];
+    const index = elementIndex(doc);
+    const out2 = [];
+    for (const [el, i2] of index) {
+      if (SKIP_TAGS2.has(el.tag) || !hasDirectText2(el)) continue;
+      const css = styleAt(doc, i2)?.css;
+      if (!css || invisible(css)) continue;
+      if (backdropOf(doc, index, el)) continue;
+      const fg = parseColor(css.color ?? "");
+      if (!fg || fg.a < 1) continue;
+      const box = boxes.get(i2);
+      if (!box || box.w < 4 || box.h < 4) continue;
+      const bg = dominantBackground(img, box);
+      if (!bg) continue;
+      const ratio = contrastRatio(fg, bg);
+      const large = isLargeText(css);
+      const min = large ? 3 : 4.5;
+      if (ratio >= min) continue;
+      out2.push({
+        criteriaId: "1.4.3",
+        el,
+        msgId: "rendered-contrast-pixel",
+        params: { ratio: ratio.toFixed(2), min, textSize: large ? "large" : "normal" }
+      });
+    }
+    return out2;
+  }
+};
+function hasNonColourAffordance(css, parentCss) {
+  const deco = css.textDecorationLine ?? "";
+  if (deco && deco !== "none") return true;
+  if ((css.borderBottomStyle ?? "none") !== "none" && Number.parseFloat(css.borderBottomWidth ?? "0") > 0) return true;
+  const bg = parseColor(css.backgroundColor ?? "");
+  if (bg && bg.a > 0) return true;
+  const w = Number.parseInt(css.fontWeight ?? "400", 10);
+  const pw = Number.parseInt(parentCss?.fontWeight ?? "400", 10);
+  if (Number.isFinite(w) && Number.isFinite(pw) && w >= pw + 200) return true;
+  return false;
+}
+var TEXT_BLOCK = /* @__PURE__ */ new Set(["p", "li", "dd", "dt", "td", "th", "blockquote", "figcaption", "caption"]);
+var renderedLinkColourOnly = {
+  id: "rendered-link-colour-only",
+  criteria: ["1.4.1"],
+  severity: "majeur",
+  run(doc) {
+    if (!doc.signals?.styles) return [];
+    const index = elementIndex(doc);
+    const out2 = [];
+    for (const [el, i2] of index) {
+      if (el.tag !== "a" || !hasDirectText2(el)) continue;
+      const parent = el.parent;
+      if (!parent || !TEXT_BLOCK.has(parent.tag)) continue;
+      const css = styleAt(doc, i2)?.css;
+      const pi = index.get(parent);
+      const parentCss = pi === void 0 ? void 0 : styleAt(doc, pi)?.css;
+      if (!css || !parentCss || invisible(css)) continue;
+      if (hasNonColourAffordance(css, parentCss)) continue;
+      const linkColor = parseColor(css.color ?? "");
+      const textColor = parseColor(parentCss.color ?? "");
+      if (!linkColor || !textColor) continue;
+      const distinct = contrastRatio(linkColor, textColor);
+      if (distinct <= 1.02) continue;
+      out2.push({
+        criteriaId: "1.4.1",
+        el,
+        msgId: "rendered-link-colour-only",
+        params: { ratio: distinct.toFixed(2) }
+      });
+    }
+    return out2;
+  }
+};
+var BOUNDED_CONTROLS = /* @__PURE__ */ new Set(["input", "select", "textarea", "button"]);
+var SIDES = ["Top", "Right", "Bottom", "Left"];
+function borderColours(css) {
+  const out2 = [];
+  for (const s of SIDES) {
+    const style = css[`border${s}Style`];
+    const width = Number.parseFloat(css[`border${s}Width`] ?? "0");
+    if (!style || style === "none" || style === "hidden" || !(width > 0)) continue;
+    const c2 = parseColor(css[`border${s}Color`] ?? "");
+    if (c2 && c2.a >= 1) out2.push(c2);
+  }
+  return out2;
+}
+var renderedNonTextContrast = {
+  id: "rendered-nontext-contrast",
+  criteria: ["1.4.11"],
+  severity: "majeur",
+  run(doc) {
+    if (!doc.signals?.styles) return [];
+    const index = elementIndex(doc);
+    const out2 = [];
+    for (const [el, i2] of index) {
+      if (!BOUNDED_CONTROLS.has(el.tag)) continue;
+      const type = (el.attribs.type ?? "").toLowerCase();
+      if (el.tag === "input" && (type === "hidden" || type === "image")) continue;
+      const css = styleAt(doc, i2)?.css;
+      if (!css || invisible(css)) continue;
+      if (css.boxShadow && css.boxShadow !== "none") continue;
+      if ((css.outlineStyle ?? "none") !== "none" && Number.parseFloat(css.outlineWidth ?? "0") > 0) continue;
+      const surrounding = el.parent ? backdropOf(doc, index, el.parent) : void 0;
+      if (!surrounding) continue;
+      const own = parseColor(css.backgroundColor ?? "");
+      const fill = own && own.a >= 1 ? own : surrounding.color;
+      if (contrastRatio(fill, surrounding.color) >= 3) continue;
+      const borders = borderColours(css);
+      if (borders.some((b) => contrastRatio(b, surrounding.color) >= 3 || contrastRatio(b, fill) >= 3)) continue;
+      out2.push({
+        criteriaId: "1.4.11",
+        el,
+        msgId: "rendered-nontext-contrast",
+        params: { ratio: contrastRatio(fill, surrounding.color).toFixed(2), control: el.tag }
+      });
+    }
+    return out2;
+  }
+};
+var FOCUS_SEL = /:focus(-visible|-within)?\b/;
+function killsOutline(d) {
+  const o = (d.outline ?? "").trim();
+  if (o === "none" || /^0(px)?( |$)/.test(o) || /\bnone\b/.test(o)) return true;
+  if ((d.outlineStyle ?? "") === "none") return true;
+  return d.outlineWidth !== void 0 && Number.parseFloat(d.outlineWidth) === 0;
+}
+function restoresIndicator(d) {
+  if (d.boxShadow && d.boxShadow !== "none") return true;
+  if (d.outlineStyle && d.outlineStyle !== "none" && Number.parseFloat(d.outlineWidth ?? "1") > 0) return true;
+  if (d.outline && !killsOutline(d)) return true;
+  if (d.textDecorationLine && d.textDecorationLine !== "none") return true;
+  for (const k of Object.keys(d)) {
+    if (/^border(Top|Right|Bottom|Left)?(Color|Width|Style)?$/.test(k) && d[k] && d[k] !== "none") return true;
+    if (/^background(Color|Image)?$/.test(k) && d[k] && d[k] !== "none" && d[k] !== "rgba(0, 0, 0, 0)") return true;
+  }
+  return d.filter !== void 0 || d.transform !== void 0 || d.color !== void 0;
+}
+var renderedFocusNotVisible = {
+  id: "rendered-focus-not-visible",
+  criteria: ["2.4.7"],
+  severity: "majeur",
+  scope: "page",
+  run(doc) {
+    const css = doc.signals?.css;
+    if (!css || css.unreadable > 0 || css.truncated) return [];
+    const focusRules = css.rules.filter((r) => FOCUS_SEL.test(r.selector));
+    if (!focusRules.length) return [];
+    if (!focusRules.some((r) => killsOutline(r.decls))) return [];
+    if (focusRules.some((r) => restoresIndicator(r.decls))) return [];
+    const anchor = doc.elements.find((e) => ["a", "button", "input", "select", "textarea"].includes(e.tag));
+    if (!anchor) return [];
+    const killer = focusRules.find((r) => killsOutline(r.decls));
+    return [{ criteriaId: "2.4.7", el: doc.elements[0] ?? anchor, msgId: "rendered-focus-not-visible", params: { selector: killer?.selector ?? ":focus" } }];
+  }
+};
+var DOC_SEL = /^\s*(\*|:root|html|body)\s*$/i;
+function quarterTurn(transform) {
+  const m = /rotate[ZY]?\(\s*(-?[\d.]+)deg\s*\)/i.exec(transform);
+  if (!m) return false;
+  const deg = Math.abs(Number.parseFloat(m[1])) % 180;
+  return Math.abs(deg - 90) < 1;
+}
+var renderedOrientationLock = {
+  id: "rendered-orientation-lock",
+  criteria: ["1.3.4"],
+  severity: "majeur",
+  scope: "page",
+  run(doc) {
+    const css = doc.signals?.css;
+    if (!css || css.unreadable > 0) return [];
+    for (const r of css.rules) {
+      if (!r.media || !/orientation\s*:/i.test(r.media)) continue;
+      if (!r.selector.split(",").some((s) => DOC_SEL.test(s))) continue;
+      const t2 = r.decls.transform ?? "";
+      if (!quarterTurn(t2)) continue;
+      const el = doc.elements[0];
+      if (!el) continue;
+      return [{ criteriaId: "1.3.4", el, msgId: "rendered-orientation-lock", params: { media: r.media, transform: t2 } }];
+    }
+    return [];
+  }
+};
+var renderedRules = [
+  renderedContrast,
+  renderedContrastPixel,
+  renderedLinkColourOnly,
+  renderedNonTextContrast,
+  renderedFocusNotVisible,
+  renderedOrientationLock
+];
+
 // src/rules/timing.ts
 var metaRefreshRedirect = {
   id: "meta-refresh-redirect",
@@ -36329,6 +37101,7 @@ var timingRules = [metaRefreshRedirect, blinkMarquee];
 // src/rules/registry.ts
 var ALL_RULES = [
   ...colorsRules,
+  ...renderedRules,
   ...imagesRules,
   ...framesRules,
   ...scriptsAriaRules,
@@ -36390,7 +37163,7 @@ function crossToFinding(doc, ruleId, def, cf) {
 import { resolve as absPath } from "path";
 
 // src/graph/resolve.ts
-import { dirname as dirname5, join as join21 } from "path";
+import { dirname as dirname6, join as join22 } from "path";
 var EXT_ORDER = [".tsx", ".jsx", ".ts", ".js"];
 function candidates(base) {
   const out2 = [base];
@@ -36400,7 +37173,7 @@ function candidates(base) {
     for (const e of EXT_ORDER) out2.push(stripped + e);
   }
   for (const e of EXT_ORDER) out2.push(base + e);
-  for (const e of EXT_ORDER) out2.push(join21(base, `index${e}`));
+  for (const e of EXT_ORDER) out2.push(join22(base, `index${e}`));
   return out2;
 }
 function matchKnown(base, known) {
@@ -36412,7 +37185,7 @@ function matchKnown(base, known) {
 }
 function resolveSpecifier(fromFile, spec, known, aliases) {
   if (spec.startsWith(".")) {
-    return matchKnown(join21(dirname5(toPosix(fromFile)), spec), known);
+    return matchKnown(join22(dirname6(toPosix(fromFile)), spec), known);
   }
   if (aliases?.length) {
     for (const rule of aliases) {
@@ -36420,7 +37193,7 @@ function resolveSpecifier(fromFile, spec, known, aliases) {
         if (!spec.startsWith(rule.prefix)) continue;
         const rest = spec.slice(rule.prefix.length);
         for (const base of rule.bases) {
-          const hit = matchKnown(join21(base, rest), known);
+          const hit = matchKnown(join22(base, rest), known);
           if (hit) return hit;
         }
       } else if (spec === rule.prefix) {
@@ -36435,11 +37208,11 @@ function resolveSpecifier(fromFile, spec, known, aliases) {
 }
 
 // src/graph/tsconfig.ts
-import { existsSync as existsSync9, readFileSync as readFileSync10 } from "fs";
-import { dirname as dirname6, join as join22, resolve as resolve3, relative } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync12 } from "fs";
+import { dirname as dirname7, join as join23, resolve as resolve3, relative } from "path";
 function readJsonish(path) {
   try {
-    const raw = readFileSync10(path, "utf8").replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/[^\n]*/g, "$1").replace(/,(\s*[}\]])/g, "$1");
+    const raw = readFileSync12(path, "utf8").replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/[^\n]*/g, "$1").replace(/,(\s*[}\]])/g, "$1");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -36448,9 +37221,9 @@ function readJsonish(path) {
 function findTsconfig(startDir) {
   let dir = resolve3(startDir);
   for (let i2 = 0; i2 < 30; i2++) {
-    const p = join22(dir, "tsconfig.json");
-    if (existsSync9(p)) return p;
-    const parent = dirname6(dir);
+    const p = join23(dir, "tsconfig.json");
+    if (existsSync10(p)) return p;
+    const parent = dirname7(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -36466,15 +37239,15 @@ function tsconfigChain(startDir) {
     const p = queue.shift();
     if (seen.has(p)) continue;
     seen.add(p);
-    if (!existsSync9(p)) continue;
+    if (!existsSync10(p)) continue;
     out2.push(p);
     const cfg = readJsonish(p);
     const exts = Array.isArray(cfg?.extends) ? cfg.extends : typeof cfg?.extends === "string" ? [cfg.extends] : [];
-    const dir = dirname6(p);
+    const dir = dirname7(p);
     for (const e of exts) {
       if (typeof e !== "string") continue;
       const cands = e.endsWith(".json") ? [resolve3(dir, e)] : [resolve3(dir, `${e}.json`), resolve3(dir, e, "tsconfig.json")];
-      const hit = cands.find((c2) => existsSync9(c2));
+      const hit = cands.find((c2) => existsSync10(c2));
       if (hit) queue.push(hit);
     }
   }
@@ -36483,7 +37256,7 @@ function tsconfigChain(startDir) {
 function readTsAliases(startDir, cwd = process.cwd()) {
   const tsconfigPath = findTsconfig(startDir);
   if (!tsconfigPath) return [];
-  const root = dirname6(tsconfigPath);
+  const root = dirname7(tsconfigPath);
   const cfg = readJsonish(tsconfigPath);
   if (!cfg) return [];
   let co = cfg.compilerOptions ?? {};
@@ -36507,7 +37280,7 @@ function readTsAliases(startDir, cwd = process.cwd()) {
     const bases = targets.map((t2) => {
       const star = t2.indexOf("*");
       const tp = wildcard && star >= 0 ? t2.slice(0, star) : t2;
-      return toPosix(relative(cwd, join22(baseAbs, tp))) || ".";
+      return toPosix(relative(cwd, join23(baseAbs, tp))) || ".";
     });
     out2.push({ prefix: prefix2, wildcard, bases });
   }
@@ -36967,6 +37740,56 @@ var rgaa_default = {
         en: "State the file format and size in the link text, e.g. \u201CAnnual report (PDF, 2 MB)\u201D.",
         fr: "Indiquez le format et le poids du fichier dans l\u2019intitul\xE9 du lien, par exemple \xAB Rapport annuel (PDF, 2 Mo) \xBB."
       }
+    },
+    {
+      id: "optgroup-without-label",
+      criterion: "11.8",
+      wcag: ["1.3.1"],
+      severity: "majeur",
+      match: {
+        tag: "optgroup",
+        attrs: [
+          {
+            name: "label",
+            op: "absent"
+          }
+        ]
+      },
+      message: {
+        en: "<optgroup> without a label attribute \u2014 the group of options is unnamed (RGAA test 11.8.2).",
+        fr: "<optgroup> sans attribut label \u2014 le regroupement d\u2019options n\u2019est pas nomm\xE9 (test RGAA 11.8.2)."
+      },
+      remediation: {
+        en: 'Add label="\u2026" naming what the options in this group have in common, e.g. <optgroup label="Europe">.',
+        fr: 'Ajoutez label="\u2026" nommant ce que les options du groupe ont en commun, par ex. <optgroup label="Europe">.'
+      }
+    },
+    {
+      id: "dir-value-invalid",
+      criterion: "8.10",
+      wcag: ["1.3.2"],
+      severity: "majeur",
+      match: {
+        attrs: [
+          {
+            name: "dir",
+            op: "present"
+          },
+          {
+            name: "dir",
+            op: "matches",
+            value: "^(?!(rtl|ltr|auto)$).+$"
+          }
+        ]
+      },
+      message: {
+        en: "dir attribute with a value that is not rtl, ltr or auto \u2014 the reading direction change is not declared conformantly (RGAA test 8.10.2).",
+        fr: "Attribut dir dont la valeur n\u2019est ni rtl, ni ltr, ni auto \u2014 le changement de sens de lecture n\u2019est pas d\xE9clar\xE9 conform\xE9ment (test RGAA 8.10.2)."
+      },
+      remediation: {
+        en: 'Use dir="rtl" or dir="ltr" (or dir="auto"), matching the reading direction of the text it carries.',
+        fr: 'Utilisez dir="rtl" ou dir="ltr" (ou dir="auto"), en accord avec le sens de lecture du texte port\xE9.'
+      }
     }
   ],
   themes: [
@@ -37697,10 +38520,16 @@ var rgaa_default = {
         ]
       },
       techniques: ["G18", "G136", "G148", "G174", "G145", "C29"],
-      particularCases: ["Dans ces situations, les crit\xE8res sont non applicables pour ces \xE9l\xE9ments\xA0:", "[object Object]"],
+      particularCases: [
+        "Dans ces situations, les crit\xE8res sont non applicables pour ces \xE9l\xE9ments\xA0:",
+        "- Le texte fait partie d\u2019un logo ou d\u2019un nom de marque d\u2019un organisme ou d\u2019une soci\xE9t\xE9\xA0;",
+        "- Le texte ou l\u2019image de texte est purement d\xE9coratif\xA0;",
+        "- Le texte fait partie d\u2019une image v\xE9hiculant une information mais le texte lui-m\xEAme n\u2019apporte aucune information essentielle\xA0;",
+        "- Le texte ou l\u2019image de texte fait partie d\u2019un \xE9l\xE9ment d\u2019interface sur lequel aucune action n\u2019est possible (par exemple un bouton avec l\u2019attribut `disabled`)."
+      ],
       wcag: ["1.4.3"],
       appliesTo: {
-        ruleIds: ["axe:color-contrast", "axe:color-contrast-enhanced", "contrast-literal"]
+        ruleIds: ["axe:color-contrast", "axe:color-contrast-enhanced", "contrast-literal", "rendered-contrast", "rendered-contrast-pixel"]
       }
     },
     {
@@ -37733,10 +38562,19 @@ var rgaa_default = {
         ]
       },
       techniques: ["G18", "G195", "G207", "G174", "G145", "G183", "F78"],
-      particularCases: ["Les cas suivants sont non applicables pour ce crit\xE8re\xA0:", "[object Object]"],
+      particularCases: [
+        "Les cas suivants sont non applicables pour ce crit\xE8re\xA0:",
+        "- Composant d\u2019interface inactif (par exemple, un bouton avec un attribut `disabled`) sur lequel aucune action n\u2019est possible\xA0;",
+        "- Composant d\u2019interface pour lequel l\u2019apparence est g\xE9r\xE9e par les styles natifs du navigateur sans aucune modification par l\u2019auteur (par exemple, le style au focus natif dans Chrome ou Firefox)\xA0;",
+        "- Composant d\u2019interface pour lequel la couleur n\u2019est pas n\xE9cessaire pour identifier le composant ou son \xE9tat (par exemple, un groupe de liens faisant office de navigation dont la position dans la page, la taille et la couleur du texte permettent de comprendre qu\u2019il s\u2019agit de liens m\xEAme si la couleur du soulignement des liens avec le fond blanc n\u2019a pas un ratio de 3:1 et que le texte lui a un ratio de 4.5:1)\xA0;",
+        "- [\xC9l\xE9ment graphique](#element-graphique) ou parties d\u2019\xE9l\xE9ment graphique non porteur d\u2019information ou ayant une alternative (description longue, informations identiques visibles dans la page)\xA0;",
+        "- [\xC9l\xE9ment graphique](#element-graphique) ou parties d\u2019\xE9l\xE9ment graphique faisant partie d\u2019un logo ou du nom de marque d\u2019un organisme ou d\u2019une soci\xE9t\xE9\xA0;",
+        "- [\xC9l\xE9ment graphique](#element-graphique) ou parties d\u2019\xE9l\xE9ment graphique dont la pr\xE9sentation est essentielle \xE0 l\u2019information v\xE9hicul\xE9e (par exemple, drapeaux, logotypes, photos de personnes ou de sc\xE8nes, captures d\u2019\xE9cran, diagrammes m\xE9dicaux, carte de chaleurs)\xA0;",
+        "- [\xC9l\xE9ment graphique](#element-graphique) ou parties d\u2019\xE9l\xE9ment graphique dynamiques dont le contraste au survol / focus est suffisant."
+      ],
       wcag: ["1.4.11"],
       appliesTo: {
-        ruleIds: []
+        ruleIds: ["rendered-nontext-contrast"]
       }
     },
     {
@@ -37774,7 +38612,13 @@ var rgaa_default = {
       techniques: ["G58", "G69", "G78", "G158", "G159", "G173", "G8", "G166", "H96", "SM6", "SM7"],
       particularCases: [
         "Il existe une gestion de cas particulier lorsque\xA0:",
-        "[object Object]",
+        "- Le [m\xE9dia temporel](#media-temporel-type-son-video-et-synchronise) est utilis\xE9 \xE0 des fins d\xE9coratives (c\u2019est-\xE0-dire qu\u2019il n\u2019apporte aucune information)\xA0;",
+        "- Le [m\xE9dia temporel](#media-temporel-type-son-video-et-synchronise) est lui-m\xEAme une alternative \xE0 un contenu de la page (une vid\xE9o en langue des signes ou la vocalisation d\u2019un texte, par exemple)\xA0;",
+        "- Le [m\xE9dia temporel](#media-temporel-type-son-video-et-synchronise) est utilis\xE9 pour acc\xE9der \xE0 une version agrandie\xA0;",
+        "- Le [m\xE9dia temporel](#media-temporel-type-son-video-et-synchronise) est utilis\xE9 comme un [CAPTCHA](#captcha)\xA0;",
+        "- Le [m\xE9dia temporel](#media-temporel-type-son-video-et-synchronise) fait partie d\u2019un test qui deviendrait inutile si la [transcription textuelle](#transcription-textuelle-media-temporel), les [sous-titres synchronis\xE9s](#sous-titres-synchronises-objet-multimedia) ou l\u2019[audiodescription](#audiodescription-synchronisee-media-temporel) \xE9taient communiqu\xE9s\xA0;",
+        "- Pour les services de l\u2019\xC9tat, les collectivit\xE9s territoriales et leurs \xE9tablissements\xA0: si le [m\xE9dia temporel](#media-temporel-type-son-video-et-synchronise) a \xE9t\xE9 publi\xE9 entre le 23 septembre 2019 et le 23 septembre 2020 sur un site internet, intranet ou extranet cr\xE9\xE9 depuis le 23 septembre 2018, il est exempt\xE9 de l\u2019obligation d\u2019accessibilit\xE9\xA0;",
+        "- Pour les personnes de droit priv\xE9 mentionn\xE9es aux 2\xB0 \xE0 4\xB0 du I de l\u2019article 47 de la loi du 11 f\xE9vrier 2005\xA0: si le [m\xE9dia temporel](#media-temporel-type-son-video-et-synchronise) a \xE9t\xE9 publi\xE9 avant le 23 septembre 2020, il est exempt\xE9 de l\u2019obligation d\u2019accessibilit\xE9.",
         "Dans ces situations, le crit\xE8re est non applicable.",
         "Ce cas particulier s\u2019applique \xE9galement aux crit\xE8res 4.2, 4.3, 4.5."
       ],
@@ -37959,7 +38803,13 @@ var rgaa_default = {
         ]
       },
       techniques: ["H35", "H46"],
-      particularCases: ["Il existe une gestion de cas particulier lorsque\xA0:", "[object Object]", "Dans ces situations, le crit\xE8re est non applicable."],
+      particularCases: [
+        "Il existe une gestion de cas particulier lorsque\xA0:",
+        "- Le [m\xE9dia non temporel](#media-non-temporel) est utilis\xE9 \xE0 des fins d\xE9coratives (c\u2019est-\xE0-dire qu\u2019il n\u2019apporte aucune information)\xA0;",
+        "- Le [m\xE9dia non temporel](#media-non-temporel) est diffus\xE9 dans un [environnement ma\xEEtris\xE9](#environnement-maitrise)\xA0;",
+        "- Le [m\xE9dia non temporel](#media-non-temporel) est ins\xE9r\xE9 via JavaScript en v\xE9rifiant la pr\xE9sence et la version du plug-in, en remplacement d\u2019un [contenu alternatif](#contenu-alternatif) d\xE9j\xE0 pr\xE9sent.",
+        "Dans ces situations, le crit\xE8re est non applicable."
+      ],
       wcag: ["1.1.1"],
       appliesTo: {
         ruleIds: []
@@ -38340,14 +39190,18 @@ var rgaa_default = {
       techniques: ["H30", "H78", "H79", "H80", "H81", "G53", "G91", "F63", "F89", "ARIA7", "ARIA8"],
       technicalNote: [
         "Lorsque l\u2019intitul\xE9 visible est compl\xE9t\xE9 par une autre expression dans le nom accessible\xA0:",
-        "[object Object]",
+        "- WCAG insiste sur le placement de l\u2019intitul\xE9 visible au d\xE9but du nom accessible sans toutefois r\xE9server l\u2019exclusivit\xE9 de cet emplacement\xA0;",
+        "- WCAG consid\xE8re comme un cas d\u2019\xE9chec une correspondance non exacte de la cha\xEEne de caract\xE8res de l\u2019intitul\xE9 visible au sein du nom accessible.",
         "Par exemple, si l\u2019on consid\xE8re l\u2019intitul\xE9 visible \xAB\xA0Commander maintenant\xA0\xBB compl\xE9t\xE9 dans le nom accessible par l\u2019expression \xAB\xA0produit X\xA0\xBB, on peut avoir les diff\xE9rents cas suivants\xA0:",
-        "[object Object]"
+        "- \xAB\xA0Commander maintenant produit X\xA0\xBB est valide (bonne pratique)\xA0;",
+        "- \xAB\xA0Produit X : commander maintenant\xA0\xBB est valide\xA0;",
+        "- \xAB\xA0Commander produit X maintenant\xA0\xBB est non valide."
       ],
       particularCases: [
         "Il existe une gestion de cas particuliers pour les tests 6.1.1, 6.1.2, 6.1.3 et 6.1.4 lorsque le lien est [ambigu pour tout le monde](#ambigu-pour-tout-le-monde). Dans cette situation, o\xF9 il n\u2019est pas possible de rendre le lien explicite dans son contexte, le crit\xE8re est non applicable.",
         "Il existe une gestion de cas particuliers pour le test 6.1.5 lorsque\xA0:",
-        "[object Object]",
+        "- La ponctuation et les lettres majuscules sont pr\xE9sentes dans le texte de l\u2019[intitul\xE9 visible](#intitule-visible)\xA0: elles peuvent \xEAtre ignor\xE9es dans le nom accessible sans porter \xE0 cons\xE9quence\xA0;",
+        "- Le texte de l\u2019[intitul\xE9 visible](#intitule-visible) sert de symbole\xA0: le texte ne doit pas \xEAtre interpr\xE9t\xE9 litt\xE9ralement au niveau du nom accessible. Le nom doit exprimer la fonction v\xE9hicul\xE9e par le symbole (par exemple, \u201CB\u201D au niveau d\u2019un \xE9diteur de texte aura pour nom accessible \u201CMettre en gras\u201D, le signe \u201C>\u201D en fonction du contexte signifiera \u201CSuivant\u201D ou \u201CLancer la vid\xE9o\u201D). Le cas des symboles math\xE9matiques fait cependant exception (voir la note ci-dessous).",
         "Note\xA0: si l\u2019\xE9tiquette visible repr\xE9sente une expression math\xE9matique, les symboles math\xE9matiques peuvent \xEAtre repris litt\xE9ralement pour servir d\u2019\xE9tiquette au nom accessible (ex.\xA0: \u201CA>B\u201D). Il est laiss\xE9 \xE0 l\u2019utilisateur le soin d\u2019op\xE9rer la correspondance entre l\u2019expression et ce qu\u2019il doit \xE9peler compte tenu de la connaissance qu\u2019il a du fonctionnement de son logiciel de saisie vocale (\u201CA plus grand que B\u201D ou \u201CA sup\xE9rieur \xE0 B\u201D)."
       ],
       wcag: ["1.1.1", "2.4.4", "2.5.3"],
@@ -38411,7 +39265,8 @@ var rgaa_default = {
       ],
       particularCases: [
         "Il existe une gestion de cas particuliers pour le test 7.1.3 lorsque\xA0:",
-        "[object Object]",
+        "- La ponctuation et les lettres majuscules sont pr\xE9sentes dans le texte de l\u2019intitul\xE9 visible : elles peuvent \xEAtre ignor\xE9es dans le nom accessible sans porter \xE0 cons\xE9quence\xA0;",
+        "- Le texte de l\u2019intitul\xE9 visible sert de symbole : le texte ne doit pas \xEAtre interpr\xE9t\xE9 litt\xE9ralement au niveau du nom accessible. Le nom doit exprimer la fonction v\xE9hicul\xE9e par le symbole (par exemple, \u201CB\u201D au niveau d\u2019un \xE9diteur de texte aura pour nom accessible \u201CMettre en gras\u201D, le signe \u201C>\u201D en fonction du contexte signifiera \u201CSuivant\u201D ou \u201CLancer la vid\xE9o\u201D). Le cas des symboles math\xE9matiques fait cependant exception (voir la note ci-dessous).",
         "Note\xA0: si l\u2019\xE9tiquette visible repr\xE9sente une expression math\xE9matique, les symboles math\xE9matiques peuvent \xEAtre repris litt\xE9ralement pour servir d\u2019\xE9tiquette au nom accessible (ex.\xA0: \u201CA>B\u201D). Il est laiss\xE9 \xE0 l\u2019utilisateur le soin d\u2019op\xE9rer la correspondance entre l\u2019expression et ce qu\u2019il doit \xE9peler compte tenu de la connaissance qu\u2019il a du fonctionnement de son logiciel de saisie vocale (\u201CA plus grand que B\u201D ou \u201CA sup\xE9rieur \xE0 B\u201D)."
       ],
       wcag: ["2.5.3", "4.1.2"],
@@ -38541,7 +39396,9 @@ var rgaa_default = {
       techniques: ["ARIA19", "ARIA22", "ARIA23"],
       technicalNote: [
         "Les r\xF4les WAI-ARIA `log`, `status` et `alert` ont implicitement une valeur d\u2019attribut WAI-ARIA `aria-live` et `aria-atomic`. On pourra donc consid\xE9rer (conform\xE9ment \xE0 la sp\xE9cification WAI-ARIA 1.1) que\xA0:",
-        "[object Object]",
+        '- Un attribut WAI-ARIA `aria-live="polite"` associ\xE9 \xE0 un message de statut peut valoir pour un r\xF4le WAI-ARIA `log`\xA0;',
+        '- Un attribut WAI-ARIA `aria-live="polite"` et un attribut WAI-ARIA `aria-atomic="true"` associ\xE9s \xE0 un message de statut peuvent valoir pour un r\xF4le WAI-ARIA `status`\xA0;',
+        '- Un attribut WAI-ARIA `aria-live="assertive"` et un attribut WAI-ARIA `aria-atomic="true"` associ\xE9s \xE0 un message de statut peuvent valoir pour un r\xF4le WAI-ARIA `alert`.',
         "C\u2019est sous r\xE9serve que la nature du message de statut satisfasse bien \xE0 la correspondance implicitement \xE9tablie. Dans le cas d\u2019un message de statut indiquant la progression d\u2019un processus et mat\xE9rialis\xE9 graphiquement par une barre de progression, un r\xF4le WAI-ARIA `progressbar` explicite est n\xE9cessaire."
       ],
       wcag: ["4.1.3"],
@@ -38695,7 +39552,11 @@ var rgaa_default = {
       techniques: ["H58"],
       particularCases: [
         "Il y a une gestion de cas particuliers sur le changement de langue pour les cas suivants\xA0:",
-        "[object Object]",
+        "- Nom propre, le crit\xE8re est non applicable\xA0;",
+        "- Nom commun de langue \xE9trang\xE8re pr\xE9sent dans le dictionnaire officiel de la langue (voir note 1 ci-dessous) par d\xE9faut de la page web, le crit\xE8re est non applicable\xA0;",
+        "- Le terme de langue \xE9trang\xE8re soumis, via un [champ de formulaire](#champ-de-saisie-de-formulaire) et rappel\xE9 dans la page (par exemple comme indication du terme recherch\xE9 dans le cas d\u2019un moteur de recherche), le crit\xE8re est non applicable\xA0;",
+        "- Passage de texte dont la langue ne peut pas \xEAtre d\xE9termin\xE9e : le crit\xE8re est non applicable\xA0;",
+        "- Terme ou passage de texte issus d\u2019une langue morte ou imaginaire pour laquelle il n\u2019existe pas d\u2019interpr\xE9tation vocale : le crit\xE8re est non applicable.",
         "Note 1\xA0: le dictionnaire officiel est celui recommand\xE9 par l\u2019acad\xE9mie en charge de la langue en question. Pour la France, par exemple, le lien vers le dictionnaire officiel se trouve sur le site de l\u2019Acad\xE9mie fran\xE7aise \xE0 l\u2019adresse suivante\xA0: http://www.academie-francaise.fr/le-dictionnaire/la-9e-edition. Pour toute demande aupr\xE8s du service du dictionnaire de l\u2019Acad\xE9mie fran\xE7aise, utiliser le formulaire de contact du service du dictionnaire.",
         "Note 2\xA0: pour les noms communs de langue \xE9trang\xE8re, absents dans le dictionnaire officiel de la langue par d\xE9faut de la page web, et qui sont pass\xE9s dans le langage commun (exemple\xA0: newsletter)\xA0: le crit\xE8re est applicable, uniquement lorsque l\u2019absence d\u2019indication de langue peut provoquer une incompr\xE9hension pour la restitution."
       ],
@@ -38768,7 +39629,7 @@ var rgaa_default = {
       techniques: ["H56"],
       wcag: ["1.3.2"],
       appliesTo: {
-        ruleIds: []
+        ruleIds: ["pack:rgaa:dir-value-invalid"]
       }
     },
     {
@@ -38976,7 +39837,9 @@ var rgaa_default = {
       techniques: ["G146", "G179", "F69", "F80", "SCR34", "C12", "C13", "C14", "C17", "C28"],
       particularCases: [
         "Font exception \xE0 ce crit\xE8re, les contenus pour lesquels l\u2019utilisateur n\u2019a pas de possibilit\xE9 de personnalisation\xA0:",
-        "[object Object]"
+        "- Les sous-titres incrust\xE9s dans une vid\xE9o\xA0;",
+        "- Les textes en image\xA0;",
+        "- Le texte au sein d\u2019une balise `<canvas>`."
       ],
       wcag: ["1.4.4"],
       appliesTo: {
@@ -39006,7 +39869,7 @@ var rgaa_default = {
       techniques: ["F24"],
       wcag: ["1.4.3"],
       appliesTo: {
-        ruleIds: ["axe:color-contrast", "axe:color-contrast-enhanced", "contrast-literal"]
+        ruleIds: ["axe:color-contrast", "axe:color-contrast-enhanced", "contrast-literal", "rendered-contrast", "rendered-contrast-pixel"]
       }
     },
     {
@@ -39029,7 +39892,7 @@ var rgaa_default = {
       techniques: ["G183", "F73"],
       wcag: ["1.4.1"],
       appliesTo: {
-        ruleIds: []
+        ruleIds: ["rendered-link-colour-only"]
       }
     },
     {
@@ -39051,7 +39914,7 @@ var rgaa_default = {
       techniques: ["G149", "G165", "G183", "G195", "F73", "F78", "SCR31", "C15"],
       wcag: ["1.4.1", "2.4.7"],
       appliesTo: {
-        ruleIds: ["dyn-focus-visible"]
+        ruleIds: ["dyn-focus-visible", "rendered-focus-not-visible"]
       }
     },
     {
@@ -39162,7 +40025,11 @@ var rgaa_default = {
       particularCases: [
         "L'objectif de ce crit\xE8re est de garantir un d\xE9filement dans une unique direction pour une lecture facilit\xE9e selon le sens de l'\xE9criture.",
         "Font exception \xE0 ce crit\xE8re, les contenus dont l'agencement requiert deux dimensions pour \xEAtre compris ou utilis\xE9s comme\xA0:",
-        "[object Object]",
+        "- Les images, les graphiques ou les vid\xE9os\xA0;",
+        "- Les jeux (jeux de plateforme, par exemple)\xA0;",
+        "- Les pr\xE9sentations (type diaporama, par exemple)\xA0;",
+        "- Les tableaux de donn\xE9es\xA0;",
+        "- Les interfaces o\xF9 il est n\xE9cessaire d'avoir un ascenseur horizontal lors de la manipulation de l'interface.",
         "Note\xA0: la majorit\xE9 des navigateurs sur les syst\xE8mes d'exploitation sur mobile (Android, iOS) ne g\xE8re pas correctement la redistribution en cas de zoom. Dans ce contexte, le crit\xE8re sera consid\xE9r\xE9 comme non applicable sur ces environnements."
       ],
       wcag: ["1.4.10"],
@@ -39191,7 +40058,9 @@ var rgaa_default = {
       techniques: ["C8", "C21", "C35", "C36"],
       particularCases: [
         "Font exception \xE0 ce crit\xE8re, les contenus pour lesquels l\u2019utilisateur n\u2019a pas de possibilit\xE9 de personnalisation\xA0:",
-        "[object Object]"
+        "- Les sous-titres directement int\xE9gr\xE9s \xE0 une vid\xE9o\xA0;",
+        "- Les images texte\xA0;",
+        "- Le texte au sein d\u2019une balise `<canvas>`."
       ],
       wcag: ["1.4.12"],
       appliesTo: {
@@ -39344,7 +40213,8 @@ var rgaa_default = {
       techniques: ["G82", "G131", "H44", "H65", "ARIA6", "ARIA9", "ARIA14", "ARIA16"],
       particularCases: [
         "Il existe une gestion de cas particuliers pour le test 11.2.5 lorsque\xA0:",
-        "[object Object]",
+        "- La ponctuation et les lettres majuscules sont pr\xE9sentes dans le texte de l\u2019[intitul\xE9 visible](#intitule-visible) : elles peuvent \xEAtre ignor\xE9es dans le nom accessible sans porter \xE0 cons\xE9quence\xA0;",
+        "- Le texte de l\u2019[intitul\xE9 visible](#intitule-visible) sert de symbole\xA0: le texte ne doit pas \xEAtre interpr\xE9t\xE9 litt\xE9ralement au niveau du nom accessible. Le nom doit exprimer la fonction v\xE9hicul\xE9e par le symbole (par exemple, \u201CB\u201D au niveau d\u2019un \xE9diteur de texte aura pour nom accessible \u201CMettre en gras\u201D, le signe \u201C>\u201D en fonction du contexte signifiera \u201CSuivant\u201D ou \u201CLancer la vid\xE9o\u201D). Le cas des symboles math\xE9matiques fait cependant exception (voir la note ci-dessous).",
         "Note\xA0: si l\u2019\xE9tiquette visible repr\xE9sente une expression math\xE9matique, les symboles math\xE9matiques peuvent \xEAtre repris litt\xE9ralement pour servir d\u2019\xE9tiquette au nom accessible (ex.\xA0: \u201CA>B\u201D). Il est laiss\xE9 \xE0 l\u2019utilisateur le soin d\u2019op\xE9rer la correspondance entre l\u2019expression et ce qu\u2019il doit \xE9peler compte tenu de la connaissance qu\u2019il a du fonctionnement de son logiciel de saisie vocale (\u201CA plus grand que B\u201D ou \u201CA sup\xE9rieur \xE0 B\u201D).",
         "Ce cas particulier s\u2019applique \xE9galement au test 11.9.2."
       ],
@@ -39401,7 +40271,13 @@ var rgaa_default = {
         ]
       },
       techniques: ["G162"],
-      particularCases: ["Les tests 11.4.2 et 11.4.3 seront consid\xE9r\xE9s comme non applicables\xA0:", "[object Object]"],
+      particularCases: [
+        "Les tests 11.4.2 et 11.4.3 seront consid\xE9r\xE9s comme non applicables\xA0:",
+        "- Dans le cas o\xF9 l\u2019[\xE9tiquette](#etiquette-de-champ-de-formulaire) m\xE9lange une portion de texte qui se lit de droite \xE0 gauche avec une portion de texte qui se lit de gauche \xE0 droite\xA0;",
+        "- Dans le cas o\xF9 un formulaire contient des labels de plusieurs langues qui se liraient de droite \xE0 gauche et inversement. Par exemple, un formulaire de commande en arabe qui propose une liste de cases \xE0 cocher de produit en langue fran\xE7aise ou mixant des produits en langue arabe ou en langue fran\xE7aise\xA0;",
+        '- Dans le cas o\xF9 les champs de type `radio` ou `checkbox` et les balises ayant un attribut WAI-ARIA `role="checkbox"`, `role="radio"` ou `role="switch"` ne sont pas visuellement pr\xE9sent\xE9s sous forme de bouton radio ou de case \xE0 cocher\xA0;',
+        "- Dans le cas o\xF9 les champs seraient utilis\xE9s dans un contexte o\xF9 il pourrait \xEAtre l\xE9gitime, du point de vue de l\u2019exp\xE9rience utilisateur, de placer les \xE9tiquettes de mani\xE8re diff\xE9rente \xE0 celle requise dans les tests 11.4.2 et 11.4.3."
+      ],
       wcag: ["3.3.2"],
       appliesTo: {
         ruleIds: []
@@ -39488,7 +40364,7 @@ var rgaa_default = {
       ],
       wcag: ["1.3.1"],
       appliesTo: {
-        ruleIds: []
+        ruleIds: ["pack:rgaa:optgroup-without-label"]
       }
     },
     {
@@ -39595,11 +40471,14 @@ var rgaa_default = {
       ],
       technicalNote: [
         "Dans un long formulaire dont la majorit\xE9 des champs sont obligatoires, on pourrait constater que ce sont les quelques champs rest\xE9s facultatifs qui sont explicitement signal\xE9s comme tels. Dans ce cas, il faudrait s\u2019assurer que\xA0:",
-        "[object Object]"
+        "- Un message pr\xE9cise visuellement en haut de formulaire que \u201Ctous les champs sont obligatoires sauf ceux indiqu\xE9s comme \xE9tant facultatifs\u201D\xA0;",
+        "- Une mention \u201Cfacultatif\u201D est pr\xE9sente visuellement dans le libell\xE9 des champs facultatifs ou dans la l\xE9gende d\u2019un groupe de champs facultatifs\xA0;",
+        '- Un attribut `required` ou `aria-required="true"` reste associ\xE9 \xE0 chaque champ qui n\u2019est pas concern\xE9 par ce caract\xE8re facultatif.'
       ],
       particularCases: [
         "Le test 11.10.1 et le test 11.10.2 seront consid\xE9r\xE9s comme non applicables lorsque le formulaire comporte un seul [champ de formulaire](#champ-de-saisie-de-formulaire) ou qu\u2019il indique les champs optionnels de mani\xE8re\xA0:",
-        "[object Object]",
+        "- Visible\xA0;",
+        "- Dans la balise `<label>` ou dans la [l\xE9gende](#legende) associ\xE9e au champ.",
         "Dans le cas o\xF9 l\u2019ensemble des champs d\u2019un formulaire sont obligatoires, les tests 11.10.1 et 11.10.2 restent applicables."
       ],
       wcag: ["3.3.1", "3.3.2"],
@@ -39729,7 +40608,13 @@ var rgaa_default = {
         ]
       },
       techniques: ["G61", "F66"],
-      particularCases: ["Il existe une gestion de cas particuliers lorsque\xA0:", "[object Object]", "Dans ces situations, le crit\xE8re est non applicable."],
+      particularCases: [
+        "Il existe une gestion de cas particuliers lorsque\xA0:",
+        "- La page est la page d\u2019accueil\xA0;",
+        "- Le site web est constitu\xE9 d\u2019une seule page\xA0;",
+        "- Le changement fait suite \xE0 une modification initi\xE9e par l\u2019utilisateur.",
+        "Dans ces situations, le crit\xE8re est non applicable."
+      ],
       wcag: ["3.2.3"],
       appliesTo: {
         ruleIds: []
@@ -40032,7 +40917,11 @@ var rgaa_default = {
         ]
       },
       techniques: ["F15", "G10", "G135"],
-      particularCases: ["Il existe une gestion de cas particuliers\xA0:", "[object Object]", "Dans cette situation, le crit\xE8re est non applicable."],
+      particularCases: [
+        "Il existe une gestion de cas particuliers\xA0:",
+        "- Pour les personnes de droit priv\xE9 mentionn\xE9es aux 2\xB0 \xE0 4\xB0 du I de l\u2019article 47 de la loi du 11 f\xE9vrier 2005\xA0: si les fichiers bureautiques (ex\xA0: PDF, documents Microsoft ou LibreOffice, etc.) ont \xE9t\xE9 publi\xE9s avant le 23 septembre 2018 (sauf si ce sont des documents n\xE9cessaires pour accomplir une d\xE9marche administrative relevant des t\xE2ches effectu\xE9es par l\u2019organisme concern\xE9), ils sont exempt\xE9s de l\u2019obligation d\u2019accessibilit\xE9.",
+        "Dans cette situation, le crit\xE8re est non applicable."
+      ],
       wcag: ["1.1.1", "1.3.1", "1.3.2", "2.4.1", "2.4.3", "3.1.1", "4.1.2"],
       appliesTo: {
         ruleIds: []
@@ -40191,7 +41080,7 @@ var rgaa_default = {
       ],
       wcag: ["1.3.4"],
       appliesTo: {
-        ruleIds: []
+        ruleIds: ["rendered-orientation-lock"]
       }
     },
     {
@@ -40212,7 +41101,11 @@ var rgaa_default = {
         ]
       },
       techniques: ["G215", "G216"],
-      particularCases: ["Il existe une gestion de cas particuliers dans deux types de situation\xA0:", "[object Object]"],
+      particularCases: [
+        "Il existe une gestion de cas particuliers dans deux types de situation\xA0:",
+        "- Le crit\xE8re ne s\u2019applique qu\u2019\xE0 des fonctionnalit\xE9s mises en place par l\u2019auteur du site. Il ne concerne donc pas les gestes requis par l\u2019agent utilisateur ou le syst\xE8me d\u2019exploitation\xA0;",
+        "- Le crit\xE8re ne s\u2019applique pas aux fonctionnalit\xE9s dont la r\xE9alisation d\u2019un geste complexe est essentielle (ex\xE9cuter le trac\xE9 d\u2019une signature, par exemple)."
+      ],
       wcag: ["2.5.1"],
       appliesTo: {
         ruleIds: []
@@ -40238,7 +41131,8 @@ var rgaa_default = {
       techniques: [],
       technicalNote: [
         "Deux exemples de m\xE9canisme mis en place pour annuler ou abandonner une action d\xE9clench\xE9e au moyen d\u2019un dispositif de pointage sur un point unique de l\u2019\xE9cran\xA0:",
-        "[object Object]"
+        "- Une fen\xEAtre modale permettant d\u2019annuler l\u2019action apr\xE8s son ach\xE8vement\xA0;",
+        "- Pour une fonction de glisser/d\xE9poser, le fait d\u2019abandonner l\u2019action si l\u2019utilisateur rel\xE2che l\u2019\xE9l\xE9ment en dehors de la zone cible."
       ],
       particularCases: [
         "Il existe une gestion de cas particulier lorsque la fonctionnalit\xE9 n\xE9cessite que le comportement attendu soit r\xE9alis\xE9 lors d\u2019un \xE9v\xE9nement descendant, par exemple, un \xE9mulateur de clavier dont les touches doivent s\u2019activer \xE0 la pression comme sur un clavier physique. Dans ces situations, le crit\xE8re est non applicable."
@@ -40269,7 +41163,11 @@ var rgaa_default = {
         ]
       },
       techniques: [],
-      particularCases: ["Il existe une gestion de cas particulier lorsque\xA0:", "[object Object]"],
+      particularCases: [
+        "Il existe une gestion de cas particulier lorsque\xA0:",
+        "- Le mouvement est essentiel \xE0 l\u2019accomplissement de la fonctionnalit\xE9 (ex. podom\xE8tre)\xA0;",
+        "- La d\xE9tection du mouvement est utilis\xE9e pour contr\xF4ler une fonctionnalit\xE9 au travers d\u2019une interface compatible avec l\u2019accessibilit\xE9."
+      ],
       wcag: ["2.5.4"],
       appliesTo: {
         ruleIds: []
@@ -41210,6 +42108,9 @@ function loadPack(key) {
 function getPack(key) {
   return registry.get(key)?.pack;
 }
+function packGlossary(key) {
+  return registry.get(key)?.glossary;
+}
 function listStandards() {
   return [CORE_KEY, ...registry.keys()];
 }
@@ -41306,7 +42207,7 @@ function runPackRules(doc, pack) {
 }
 
 // src/graph/build.ts
-import { dirname as dirname7 } from "path";
+import { dirname as dirname8 } from "path";
 
 // src/graph/imports.ts
 var NAME_PROPS2 = /* @__PURE__ */ new Set(["aria-label", "aria-labelledby", "title", "label", "alt"]);
@@ -41604,14 +42505,14 @@ function buildGraphAndDocs(files, opts = {}) {
     }
     nodes.push(extractGraphNode(ast, doc, file, { sfc }));
   }
-  const startDir = files[0] ? dirname7(files[0]) : process.cwd();
+  const startDir = files[0] ? dirname8(files[0]) : process.cwd();
   return { graph: buildGraph2(nodes, readTsAliases(startDir), startDir), docs };
 }
 
 // src/discover.ts
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { execFileSync } from "child_process";
-import { join as join23, relative as relative2 } from "path";
+import { join as join24, relative as relative2 } from "path";
 function git(args2, maxBuffer) {
   try {
     return execFileSync("git", args2, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], ...maxBuffer ? { maxBuffer } : {} });
@@ -41636,7 +42537,7 @@ function gitChangedFiles(ref) {
   add2(git(["diff", "--name-only", "--diff-filter=d", "--cached", base]));
   add2(git(["ls-files", "--others", "--exclude-standard"]));
   const cwd = process.cwd();
-  return [...out2].map((p) => relative2(cwd, join23(repoRoot2, p)));
+  return [...out2].map((p) => relative2(cwd, join24(repoRoot2, p)));
 }
 function gitStagedFiles() {
   const top = git(["rev-parse", "--show-toplevel"]);
@@ -41645,7 +42546,7 @@ function gitStagedFiles() {
   if (out2 === null) return null;
   const repoRoot2 = top.trim();
   const cwd = process.cwd();
-  return out2.split("\n").map((s) => s.trim()).filter(Boolean).map((p) => relative2(cwd, join23(repoRoot2, p)));
+  return out2.split("\n").map((s) => s.trim()).filter(Boolean).map((p) => relative2(cwd, join24(repoRoot2, p)));
 }
 function stagedContent(file) {
   return git(["show", `:./${toPosix(file)}`], 32 * 1024 * 1024);
@@ -41730,7 +42631,7 @@ function discover(inputs, opts = {}) {
     } else {
       const filter = makeFilter(opts);
       const inScope = inScopeMatcher(inputs);
-      files = changed.filter((f) => existsSync10(f) && filter(f) && (!inScope || inScope(f)));
+      files = changed.filter((f) => existsSync11(f) && filter(f) && (!inScope || inScope(f)));
     }
   } else {
     files = expandInputs(inputs, opts);
@@ -41956,7 +42857,9 @@ function runAudit(opts) {
       }
       seen.add(h);
     }
-    foldDoc(acc, reused ?? parseSource(content, file, { forceJsx: opts.forceJsx }), graph);
+    const doc = reused ?? parseSource(content, file, { forceJsx: opts.forceJsx });
+    attachSignals(doc);
+    foldDoc(acc, doc, graph);
   }
   const canonicalFiles = acc.fileCount;
   if (opts.inputs.includes("-") && opts.stdin !== void 0 && !(opts.maxFiles && opts.maxFiles > 0 && acc.fileCount >= opts.maxFiles)) {
@@ -41974,12 +42877,12 @@ function runAudit(opts) {
 }
 
 // src/report.ts
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "fs";
-import { join as join25 } from "path";
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
+import { join as join26 } from "path";
 
 // src/prd.ts
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
-import { join as join24 } from "path";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "fs";
+import { join as join25 } from "path";
 
 // src/standards/pack.ts
 function localize(pack, s, lang) {
@@ -42005,6 +42908,9 @@ function title(pack, c2, lang) {
 function titlePlain(pack, c2, lang) {
   return localize(pack, c2.titlePlain, lang);
 }
+function resolveGlossary(packKey, anchor) {
+  return packGlossary(packKey)?.[anchor];
+}
 function neutralizeCaptureGroups(pattern) {
   let out2 = "";
   for (let i2 = 0; i2 < pattern.length; i2++) {
@@ -42104,11 +43010,29 @@ function derivePackResults(audit2, packKey) {
   };
   const enabledSecondary = (pack.secondaryMappings ?? []).filter((m) => m.enabled === true);
   const secondarySources = enabledSecondary.length ? [...audit2.criteria.flatMap((c2) => c2.findings), ...myPackFindings] : [];
+  const adjudicated = audit2.packAdjudication?.standard === packKey ? new Map(audit2.packAdjudication.criteria.map((c2) => [c2.id, c2])) : void 0;
   return pack.criteria.map((pc) => {
+    const decided = adjudicated?.get(pc.id);
+    if (decided) {
+      return {
+        id: pc.id,
+        theme: pc.theme,
+        status: decided.status,
+        findings: decided.findings,
+        scs: pc.wcag,
+        ...decided.justification ? { justification: decided.justification } : {},
+        decidedBy: "agent"
+      };
+    }
     const base = deriveBase(pc);
     return enabledSecondary.length ? applySecondaryMappings(base, pc, enabledSecondary, secondarySources, pack.defaultLocale) : base;
   });
 }
+function findingsForStandard(audit2, standard) {
+  if (standard === CORE_KEY) return audit2.findings;
+  const mine = (audit2.packFindings ?? []).filter((f) => f.ruleId.startsWith(`pack:${standard}:`));
+  return mine.length ? [...audit2.findings, ...mine] : audit2.findings;
+}
 
 // src/standards/vocabulary.ts
 var DEFAULT = {
@@ -44948,6 +45872,9 @@ var L2 = {
     acWhen: "un utilisateur de technologie d'assistance y acc\xE8de",
     givenElements: (sel) => `les \xE9l\xE9ments ${sel} concern\xE9s`,
     techniques: "Techniques WCAG",
+    toRuleOn: "Crit\xE8res \xE0 trancher",
+    toRuleOnNote: "Le moteur ne peut pas les d\xE9cider : ils rel\xE8vent du jugement ou du rendu. Ce ne sont PAS des non-conformit\xE9s \u2014 ils sont ind\xE9cid\xE9s. G\xE9n\xE9rez la worklist (`verify --manual --standard <pack>`), qui porte l'\xE9nonc\xE9 complet de chaque test.",
+    tests: "tests",
     docNote: "Document d'exigences (PRD) g\xE9n\xE9r\xE9 depuis l'audit statique : une \xE9pop\xE9e par th\xE8me, une user story par crit\xE8re, des crit\xE8res d'acceptation ancr\xE9s sur les intitul\xE9s WCAG. Adjugez les crit\xE8res \xAB \xE0 \xE9valuer \xBB avec `verify --manual` (agent IA, gat\xE9), le rendu via `scan`."
   },
   en: {
@@ -44978,6 +45905,9 @@ var L2 = {
     acWhen: "a user of assistive technology reaches them",
     givenElements: (sel) => `the affected ${sel} elements`,
     techniques: "WCAG techniques",
+    toRuleOn: "Criteria to rule on",
+    toRuleOnNote: "The engine cannot decide these: they are judgment or rendering calls. They are NOT non-conformities \u2014 they are undecided. Generate the worklist (`verify --manual --standard <pack>`), which carries the full wording of every test.",
+    tests: "tests",
     docNote: "Product-requirements document generated from the static audit: one epic per theme, one user story per criterion, acceptance criteria anchored to the WCAG success-criterion text. Adjudicate the \u201Cto assess\u201D criteria with `verify --manual` (AI agent, gated), rendering via `scan`."
   }
 };
@@ -45100,6 +46030,7 @@ function renderBacklog(r, lang = "en", standard = "wcag") {
   const out2 = header(r, lang, s.title(standardLabel(standard)), void 0, ratePct);
   if (!units.length) {
     out2.push(s.none, "");
+    out2.push(...toRuleOnSection(r, standard, lang));
     return out2.join("\n");
   }
   for (const sev of SEV_ORDER2) {
@@ -45153,6 +46084,22 @@ function acceptanceCriteria(unit, standard, lang, opts = {}) {
     return `${prefix2}**${s.given}** ${s.givenElements(hints)} \xB7 **${s.when}** ${s.acWhen} \xB7 **${s.then}** \xAB ${req} \xBB (WCAG ${sc}).`;
   });
 }
+function toRuleOnSection(r, standard, lang) {
+  if (isCore(standard)) return [];
+  const s = L2[lang];
+  const pack = loadPack(standard);
+  const manual = derivePackResults(r, standard).filter((pc) => pc.status === "manual");
+  if (!manual.length) return [];
+  const out2 = [`## ${s.toRuleOn} (${manual.length})`, "", `> ${s.toRuleOnNote}`, ""];
+  for (const pc of manual) {
+    const crit = pack.criteria.find((c2) => c2.id === pc.id);
+    const title2 = crit ? titlePlain(pack, crit, lang) : pc.id;
+    const tests = Object.keys(crit?.tests ?? {});
+    out2.push(`- [ ] **${pack.name} ${pc.id}** \u2014 ${title2}${tests.length ? `  \xB7  ${s.tests}: ${tests.map((k) => `\`${pc.id}.${k}\``).join(" ")}` : ""}`);
+  }
+  out2.push("");
+  return out2;
+}
 function renderPrdDoc(r, lang = "en", standard = "wcag") {
   const s = L2[lang];
   const units = prdUnits(r, standard, lang);
@@ -45162,6 +46109,7 @@ function renderPrdDoc(r, lang = "en", standard = "wcag") {
     out2.push(s.none, "");
     return out2.join("\n");
   }
+  out2.push(...toRuleOnSection(r, standard, lang));
   for (const epic of epicsOf(units, standard, lang)) {
     out2.push(`## ${s.epic} \u2014 ${epic.title}`, "");
     for (const u of epic.units) {
@@ -45183,10 +46131,10 @@ function renderPrdDoc(r, lang = "en", standard = "wcag") {
   return out2.join("\n");
 }
 function writePrd(r, opts) {
-  mkdirSync4(opts.out, { recursive: true });
+  mkdirSync5(opts.out, { recursive: true });
   if (opts.format === "doc") {
-    const p2 = join24(opts.out, `prd-doc-${r.date}.md`);
-    writeFileSync5(p2, renderPrdDoc(r, opts.lang, opts.standard));
+    const p2 = join25(opts.out, `prd-doc-${r.date}.md`);
+    writeFileSync6(p2, renderPrdDoc(r, opts.lang, opts.standard));
     return [p2];
   }
   const remediation = opts.format === "remediation";
@@ -45195,21 +46143,207 @@ function writePrd(r, opts) {
     const files = remediation ? renderPerCriterion(r, opts.lang, opts.standard) : renderAuditorPerCriterion(r, opts.lang, opts.standard, { technical });
     const paths = [];
     for (const f of files) {
-      const p2 = join24(opts.out, f.name);
-      writeFileSync5(p2, f.content);
+      const p2 = join25(opts.out, f.name);
+      writeFileSync6(p2, f.content);
       paths.push(p2);
     }
     return paths;
   }
-  const p = join24(opts.out, `prd-${r.date}.md`);
-  writeFileSync5(p, remediation ? renderBacklog(r, opts.lang, opts.standard) : renderAuditorBacklog(r, opts.lang, opts.standard, { technical }));
+  const p = join25(opts.out, `prd-${r.date}.md`);
+  writeFileSync6(p, remediation ? renderBacklog(r, opts.lang, opts.standard) : renderAuditorBacklog(r, opts.lang, opts.standard, { technical }));
   return [p];
 }
 
+// src/pages.ts
+function pageScopesFrom(snapshots) {
+  return snapshots.map((s) => ({
+    id: s.meta.id,
+    name: s.meta.name,
+    url: s.meta.url,
+    ...s.meta.auth !== void 0 ? { auth: s.meta.auth } : {},
+    ...s.meta.route ? { route: s.meta.route } : {},
+    ...s.meta.sources ? { sources: s.meta.sources } : {},
+    ...s.meta.notes ? { notes: s.meta.notes } : {},
+    basis: "snapshot"
+  }));
+}
+function pageScopesFromSample(sample) {
+  return (sample?.pages ?? []).map((p) => ({
+    id: p.id,
+    name: p.name,
+    url: p.url,
+    ...p.auth !== void 0 ? { auth: p.auth } : {},
+    ...p.notes ? { notes: p.notes } : {},
+    basis: "attributed"
+  }));
+}
+function pagesOf(result) {
+  const fromScope = result.scope.pages ?? [];
+  const ids = new Set(fromScope.map((p) => p.id));
+  const urls = new Set(fromScope.map((p) => p.url));
+  const extra = pageScopesFromSample(result.scope.sample).filter((p) => !ids.has(p.id) && !urls.has(p.url));
+  return [...fromScope, ...extra];
+}
+function pathMatch2(a, b) {
+  const x = a.split("\\").join("/");
+  const y = b.split("\\").join("/");
+  return x === y || x.endsWith(`/${y}`) || y.endsWith(`/${x}`);
+}
+function attributePages(result, pages) {
+  if (!pages.length) return;
+  const byName = new Map(pages.map((p) => [p.name.toLowerCase(), p.id]));
+  const byUrl = new Map(pages.map((p) => [p.url, p.id]));
+  for (const f of [...result.findings, ...result.packFindings ?? []]) {
+    if (f.page) continue;
+    if (isUrlPath(f.file)) {
+      const hit = byUrl.get(f.file);
+      if (hit) f.page = hit;
+      continue;
+    }
+    const sampleName = f.sample?.page?.toLowerCase();
+    if (sampleName && byName.has(sampleName)) {
+      f.page = byName.get(sampleName);
+      continue;
+    }
+    const src = f.origin?.sourceFile ?? f.file;
+    for (const p of pages) {
+      if (p.sources?.some((s) => pathMatch2(src, s))) {
+        f.page = p.id;
+        break;
+      }
+    }
+  }
+}
+function unattributedFindings(result) {
+  return result.findings.filter((f) => !f.page);
+}
+function pageStatus(c2, pageFindings, basis) {
+  if (pageFindings.some((f) => !f.advisory)) return "NC";
+  if (c2.status === "manual") return "manual";
+  if (c2.status === "NA") return "NA";
+  return basis === "snapshot" ? "C" : "manual";
+}
+function pct(criteria) {
+  const c2 = criteria.filter((x) => x.status === "C").length;
+  const nc = criteria.filter((x) => x.status === "NC").length;
+  return c2 + nc === 0 ? 100 : Math.round(c2 / (c2 + nc) * 100);
+}
+function derivePages(result, pages) {
+  if (!pages.length) return [];
+  const out2 = [];
+  for (const p of pages) {
+    const own = result.findings.filter((f) => f.page === p.id);
+    const criteria = result.criteria.map((c2) => {
+      const pf = own.filter((f) => f.criteriaId === c2.id);
+      return {
+        id: c2.id,
+        guideline: c2.guideline,
+        status: pageStatus(c2, pf, p.basis),
+        findings: pf,
+        ...c2.justification ? { justification: c2.justification } : {},
+        ...c2.decidedBy ? { decidedBy: c2.decidedBy } : {}
+      };
+    });
+    out2.push({
+      id: p.id,
+      name: p.name,
+      url: p.url,
+      ...p.auth !== void 0 ? { auth: p.auth } : {},
+      basis: p.basis,
+      criteria,
+      findings: own,
+      conformancePct: pct(criteria)
+    });
+  }
+  return out2;
+}
+var MARK = { C: "C", NC: "NC", NA: "\u2014", manual: "?" };
+var L3 = {
+  fr: {
+    title: "Grille par page",
+    note: "Statut de chaque crit\xE8re, page par page. `C` conforme \xB7 `NC` non conforme \xB7 `\u2014` non applicable \xB7 `?` \xE0 \xE9valuer.",
+    criterion: "Crit\xE8re",
+    theme: "Th\xE9matique",
+    none: "Aucune page dans le p\xE9rim\xE8tre : aucun instantan\xE9 (.ultra11y/pages) ni \xE9chantillon scann\xE9.",
+    basisNote: "Une page marqu\xE9e \xAB source \xBB n'a pas d'instantan\xE9 : ses constats proviennent du code, donc l'absence de constat n'y vaut PAS conformit\xE9 \u2014 les crit\xE8res restent \xAB \xE0 \xE9valuer \xBB.",
+    unattributed: (n) => `${n} constat(s) non rattach\xE9(s) \xE0 une page (code partag\xE9, fichier hors routes) \u2014 compt\xE9s dans l'audit global, jamais r\xE9partis d'office.`,
+    rate: "Taux",
+    snapshot: "instantan\xE9",
+    source: "source"
+  },
+  en: {
+    title: "Per-page grid",
+    note: "Each criterion's status, page by page. `C` conforming \xB7 `NC` non-conforming \xB7 `\u2014` not applicable \xB7 `?` to assess.",
+    criterion: "Criterion",
+    theme: "Theme",
+    none: "No page in scope: no snapshot (.ultra11y/pages) and no scanned sample.",
+    basisNote: 'A page marked "source" has no snapshot: its findings come from the code, so the absence of a finding there does NOT mean conforming \u2014 those criteria stay "to assess".',
+    unattributed: (n) => `${n} unattributed finding(s) (shared code, file outside any route) \u2014 counted in the overall audit, never spread across pages.`,
+    rate: "Rate",
+    snapshot: "snapshot",
+    source: "source"
+  }
+};
+function pageView(result, page) {
+  return {
+    ...result,
+    criteria: page.criteria,
+    findings: page.findings,
+    ...result.packFindings ? { packFindings: result.packFindings.filter((f) => f.page === page.id) } : {}
+  };
+}
+function gridOf(result, derived, standard, lang) {
+  const status = /* @__PURE__ */ new Map();
+  const put = (rowId, pageId, s) => {
+    const m = status.get(rowId) ?? /* @__PURE__ */ new Map();
+    m.set(pageId, s);
+    status.set(rowId, m);
+  };
+  if (isCore(standard)) {
+    const rows2 = [...result.criteria].sort((a, b) => compareSC(a.id, b.id)).map((c2) => ({ id: c2.id, label: `${c2.id} ${scTitle(c2.id, lang) ?? ""}`.trim(), group: c2.guideline }));
+    for (const p of derived) for (const c2 of p.criteria) put(c2.id, p.id, c2.status);
+    return { rows: rows2, status };
+  }
+  const pack = loadPack(standard);
+  const rows = pack.criteria.map((pc) => ({ id: pc.id, label: pc.id, group: `${pc.theme}. ${themeName(pack, pc.theme, lang) ?? ""}`.trim() }));
+  for (const p of derived) for (const pc of derivePackResults(pageView(result, p), standard)) put(pc.id, p.id, pc.status);
+  return { rows, status };
+}
+function renderPageGrid(result, pages, standard = CORE2, lang = "en") {
+  const s = L3[lang];
+  const out2 = [];
+  out2.push(`## \u{1F4CA} ${s.title}`, "");
+  const derived = derivePages(result, pages);
+  if (!derived.length) {
+    out2.push(s.none, "");
+    return out2.join("\n");
+  }
+  out2.push(`> ${s.note}`, "");
+  if (derived.some((p) => p.basis === "attributed")) out2.push(`> \u26A0\uFE0F ${s.basisNote}`, "");
+  const head = [isCore(standard) ? s.criterion : s.criterion, ...derived.map((p) => `${p.name}${p.auth ? " \u{1F512}" : ""}`)];
+  out2.push(`| ${head.join(" | ")} |`, `| ${head.map(() => "---").join(" | ")} |`);
+  out2.push(`| **${s.rate}** | ${derived.map((p) => `**${p.conformancePct}%**`).join(" | ")} |`);
+  out2.push(`| _${s.snapshot}?_ | ${derived.map((p) => p.basis === "snapshot" ? `_${s.snapshot}_` : `_${s.source}_`).join(" | ")} |`);
+  const { rows, status } = gridOf(result, derived, standard, lang);
+  let group = "";
+  for (const row of rows) {
+    if (row.group !== group) {
+      group = row.group;
+      out2.push(`| **${group}** | ${derived.map(() => "").join(" | ")} |`);
+    }
+    const cells = derived.map((p) => MARK[status.get(row.id)?.get(p.id) ?? "manual"]);
+    out2.push(`| ${row.label} | ${cells.join(" | ")} |`);
+  }
+  out2.push("");
+  const orphans = unattributedFindings(result);
+  if (orphans.length) out2.push(`> ${s.unattributed(orphans.length)}`, "");
+  return out2.join("\n");
+}
+
 // src/report.ts
 var ICON3 = { bloquant: "\u{1F534}", majeur: "\u{1F7E0}", mineur: "\u{1F7E1}" };
 var SEV_ORDER3 = ["bloquant", "majeur", "mineur"];
-var L3 = {
+var L4 = {
   fr: {
     title: (std) => `Rapport d'audit d'accessibilit\xE9 \u2014 ${std}`,
     wcagStd: "WCAG 2.2 niveau AA",
@@ -45236,6 +46370,8 @@ var L3 = {
     naTitle: "4. Crit\xE8res non applicables (NA)",
     manualTitle: "5. Crit\xE8res \xE0 adjuger (jugement / rendu) \u2014 non d\xE9cid\xE9s par le moteur statique",
     manualWarn: "Adjugez-les avec `verify --manual` (l'agent d\xE9cide depuis la source, de fa\xE7on gat\xE9e) ; les crit\xE8res de rendu passent par `scan`. Aucun ne doit \xEAtre marqu\xE9 \xAB conforme \xBB sans justification enregistr\xE9e et gat\xE9e.",
+    testsToRule: "tests \xE0 trancher",
+    manualHowTo: "G\xE9n\xE9rez la worklist : `verify --manual --in <audit.json> --standard <pack> --out <dir>`. Chaque item y porte l'\xE9nonc\xE9 complet de ses tests, sa note technique, ses cas particuliers, sa guidance et les termes que le r\xE9f\xE9rentiel d\xE9finit.",
     outOfScope: "Hors p\xE9rim\xE8tre moteur \u2014 mapp\xE9 sur des SC hors WCAG 2.2 AA ; v\xE9rification manuelle.",
     scopedOut: "Les non-conformit\xE9s WCAG relev\xE9es concernent des \xE9l\xE9ments hors du p\xE9rim\xE8tre de ce crit\xE8re \u2014 \xE0 \xE9valuer s\xE9par\xE9ment.",
     nothing: "Aucun.",
@@ -45285,6 +46421,8 @@ var L3 = {
     naTitle: "4. Not-applicable criteria (NA)",
     manualTitle: "5. Criteria to adjudicate (judgment / rendering) \u2014 not decided by the static engine",
     manualWarn: "Adjudicate these with `verify --manual` (the agent decides from source, gated); rendering criteria go to `scan`. None may be marked \u201Cconforming\u201D without a recorded, gated justification.",
+    testsToRule: "tests to rule on",
+    manualHowTo: "Generate the worklist: `verify --manual --in <audit.json> --standard <pack> --out <dir>`. Each item carries the full wording of its tests, its technical note, its particular cases, its guidance and the terms the standard defines.",
     outOfScope: "Out of engine scope \u2014 mapped to SCs outside WCAG 2.2 AA; manual verification.",
     scopedOut: "The WCAG failures found concern elements outside this criterion's scope \u2014 assess separately.",
     nothing: "None.",
@@ -45325,10 +46463,10 @@ function untestedNeedsRendering(r) {
 function partialAuditBanner(lang, untested = NEEDS_RENDERING.map((c2) => c2.sc)) {
   const set = new Set(untested);
   const labels = NEEDS_RENDERING.filter((c2) => set.has(c2.sc)).map((c2) => c2.label[lang]);
-  return L3[lang].partialAudit(labels.join(", "));
+  return L4[lang].partialAudit(labels.join(", "));
 }
 function render(r, lang, opts) {
-  const s = L3[lang];
+  const s = L4[lang];
   const out2 = [];
   out2.push(`# ${s.title(opts.std)}`, "");
   out2.push(`- **${s.date}** : ${r.date}`);
@@ -45378,6 +46516,8 @@ function render(r, lang, opts) {
     out2.push(`## \u{1F4A1} ${s.recTitle}`, "", `> ${s.recNote}`, "");
     for (const u of advisoryUnits) out2.push(...renderAuditorUnit(u, opts.standard, lang, { heading: "###" }));
   }
+  const pageScope = pagesOf(r);
+  if (pageScope.length) out2.push(renderPageGrid(r, pageScope, opts.standard, lang));
   if (r.scope.sample?.pages.length) {
     out2.push(`## \u{1F4C4} ${s.perPageTitle}`, "", `> ${s.perPageNote}`, "");
     if (r.scope.sample.transverse?.length) out2.push(`> ${s.transverseNote(r.scope.sample.transverse.join(", "))}`, "");
@@ -45405,11 +46545,20 @@ function render(r, lang, opts) {
   out2.push(na.length ? na.map((x) => `- ${x.label}${x.justification ? ` \u2014 _${x.justification}_` : ""}`).join("\n") : s.nothing, "");
   out2.push(`## ${s.manualTitle}`, "", `> ${s.manualWarn}`, "");
   const manual = rows.filter((x) => x.status === "manual");
-  out2.push(manual.length ? manual.map((x) => `- ${x.label}${x.justification ? ` \u2014 _${x.justification}_` : ""}`).join("\n") : s.nothing, "");
+  if (!manual.length) out2.push(s.nothing, "");
+  else {
+    const pack5 = isCore(opts.standard) ? void 0 : loadPack(opts.standard);
+    for (const x of manual) {
+      const tests = pack5 ? Object.keys(getCriterion(pack5, x.id)?.tests ?? {}) : [];
+      const testRef = tests.length ? ` \u2014 ${s.testsToRule}: ${tests.map((k) => `\`${x.id}.${k}\``).join(" \xB7 ")}` : "";
+      out2.push(`- ${x.label}${x.justification ? ` \u2014 _${x.justification}_` : ""}${testRef}`);
+    }
+    out2.push("", `> ${s.manualHowTo}`, "");
+  }
   return out2.join("\n");
 }
 function renderReport(r, lang = "en") {
-  const s = L3[lang];
+  const s = L4[lang];
   const byGuideline = /* @__PURE__ */ new Map();
   for (const c2 of r.criteria) {
     const title2 = scTitle(c2.id, lang);
@@ -45422,7 +46571,7 @@ function renderReport(r, lang = "en") {
 function renderPackReport(r, pack, lang = "en") {
   const derived = derivePackResults(r, pack.key);
   const std = `${pack.name} ${pack.baseVersion}`;
-  const s = L3[lang];
+  const s = L4[lang];
   const naReason = lang === "fr" ? "Aucun crit\xE8re de succ\xE8s WCAG mapp\xE9 n'est applicable dans le p\xE9rim\xE8tre." : "No mapped WCAG success criterion is applicable in scope.";
   const byTheme = /* @__PURE__ */ new Map();
   for (const pr of derived) {
@@ -45441,7 +46590,7 @@ function renderPackReport(r, pack, lang = "en") {
   const groups = pack.themes.map((t2) => ({ key: `${t2.number}.`, title: themeName(pack, t2.number, lang) ?? "", rows: byTheme.get(t2.number) ?? [] }));
   return render(r, lang, {
     std,
-    groupHead: L3[lang].byTheme,
+    groupHead: L4[lang].byTheme,
     groups,
     derivedOf: std,
     standard: pack.key,
@@ -45452,9 +46601,9 @@ function renderPackReport(r, pack, lang = "en") {
 function writeReport(r, opts) {
   const core = isCore(opts.standard);
   const md = core ? renderReport(r, opts.lang) : renderPackReport(r, loadPack(opts.standard), opts.lang);
-  mkdirSync5(opts.out, { recursive: true });
-  const path = join25(opts.out, `${core ? "wcag" : opts.standard}-${r.date}.md`);
-  writeFileSync6(path, md);
+  mkdirSync6(opts.out, { recursive: true });
+  const path = join26(opts.out, `${core ? "wcag" : opts.standard}-${r.date}.md`);
+  writeFileSync7(path, md);
   return path;
 }
 
@@ -45596,6 +46745,46 @@ function pushSingleIssue(units, lang, standard = "wcag", format = "audit") {
   }
   return result;
 }
+function COMMENT_MARKER(standard) {
+  return `<!-- ultra11y:report standard="${standard}" -->`;
+}
+function stickyBody(markdown, standard) {
+  return `${COMMENT_MARKER(standard)}
+${markdown}`;
+}
+function prNumberFromEnv(env = process.env) {
+  const explicit = Number.parseInt(env.ULTRA11Y_PR ?? "", 10);
+  if (Number.isFinite(explicit) && explicit > 0) return explicit;
+  const m = /^refs\/pull\/(\d+)\//.exec(env.GITHUB_REF ?? "");
+  const n = m ? Number.parseInt(m[1], 10) : Number.NaN;
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+function pickExistingComment(comments, marker) {
+  return comments.find((c2) => typeof c2.body === "string" && c2.body.includes(marker));
+}
+function pushPrComment(markdown, standard = "wcag") {
+  const pr = prNumberFromEnv();
+  if (pr === void 0) return { ok: true, action: "skipped", reason: "not a pull-request run" };
+  const marker = COMMENT_MARKER(standard);
+  const body2 = stickyBody(markdown, standard);
+  try {
+    const repo = gh(["repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"]).trim();
+    let existing;
+    try {
+      const raw = gh(["api", `repos/${repo}/issues/${pr}/comments`, "--paginate"]);
+      existing = pickExistingComment(JSON.parse(raw), marker);
+    } catch {
+    }
+    if (existing) {
+      gh(["api", "--method", "PATCH", `repos/${repo}/issues/comments/${existing.id}`, "-f", `body=${body2}`]);
+      return { ok: true, action: "updated" };
+    }
+    gh(["api", "--method", "POST", `repos/${repo}/issues/${pr}/comments`, "-f", `body=${body2}`]);
+    return { ok: true, action: "created" };
+  } catch (e) {
+    return { ok: false, action: "skipped", reason: ghErrorReason(e) };
+  }
+}
 
 // src/render.ts
 var KNOWN_LIBS = {
@@ -45626,7 +46815,7 @@ function detectFrameworks(deps, has2) {
   for (const [pkg, label] of Object.entries(KNOWN_LIBS)) if (dep(pkg)) componentLibraries.push(label);
   return { frameworks, componentLibraries };
 }
-var L4 = {
+var L5 = {
   fr: {
     title: "Obtenir du HTML rendu \xE0 auditer (render)",
     why: "Auditer les sources JSX d'une biblioth\xE8que de composants donne des faux n\xE9gatifs : il faut auditer le HTML r\xE9ellement produit.",
@@ -45657,7 +46846,7 @@ var L4 = {
   }
 };
 function renderPlan(d, lang = "fr") {
-  const s = L4[lang];
+  const s = L5[lang];
   const out2 = [`# ${s.title}`, "", `> ${s.why}`, ""];
   if (d.componentLibraries.length) out2.push(`> \u{1F9E9} ${s.libNote(d.componentLibraries.join(", "))}`, "");
   out2.push(`## ${s.detected}`, "");
@@ -45918,8 +47107,40 @@ function runWcag(opts) {
   console.log(opts.json ? JSON.stringify(allSC(), null, 2) : wcagList(opts.lang));
   return 0;
 }
+var foldTerm = (s) => s.normalize("NFD").replace(new RegExp("\\p{Diacritic}", "gu"), "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+function runGlossary(opts) {
+  const pack = loadPack(opts.standard);
+  const glossary = packGlossary(opts.standard) ?? {};
+  const anchors = Object.keys(glossary);
+  if (!anchors.length) {
+    console.error(`ultra11y criteria: ${pack.name} ships no glossary.`);
+    return 2;
+  }
+  const term = typeof opts.glossary === "string" ? opts.glossary.trim() : "";
+  if (!term) {
+    if (opts.json) console.log(JSON.stringify(glossary, null, 2));
+    else for (const a of anchors.sort()) console.log(`${a}	${glossary[a]?.title ?? ""}`);
+    return 0;
+  }
+  const want = foldTerm(term);
+  const hit = anchors.find((a) => a === term) ?? anchors.find((a) => foldTerm(a) === want) ?? anchors.find((a) => foldTerm(glossary[a]?.title ?? "") === want) ?? anchors.find((a) => foldTerm(a).startsWith(want));
+  if (!hit) {
+    const near = anchors.filter((a) => foldTerm(a).includes(want) || foldTerm(glossary[a]?.title ?? "").includes(want)).slice(0, 8);
+    console.error(`ultra11y criteria: no ${pack.name} glossary term matching "${term}".${near.length ? ` Did you mean: ${near.join(", ")}?` : ""}`);
+    return 2;
+  }
+  const entry = glossary[hit];
+  if (opts.json) console.log(JSON.stringify({ anchor: hit, ...entry }, null, 2));
+  else {
+    console.log(`${pack.name} \u2014 ${entry.title}  (#${hit})`);
+    console.log("");
+    console.log(entry.body);
+  }
+  return 0;
+}
 function runPack(opts) {
   const pack = loadPack(opts.standard);
+  if (opts.glossary !== void 0 && opts.glossary !== false) return runGlossary(opts);
   if (opts.id) {
     const c2 = getCriterion(pack, opts.id);
     if (!c2) {
@@ -45943,6 +47164,10 @@ function runPack(opts) {
   return 0;
 }
 function runCriteria(opts) {
+  if (opts.glossary !== void 0 && opts.glossary !== false && isCore(opts.standard)) {
+    console.error("ultra11y criteria: --glossary needs a country standard (e.g. --standard rgaa); WCAG ships no glossary here.");
+    return 2;
+  }
   return isCore(opts.standard) ? runWcag(opts) : runPack(opts);
 }
 function renderCriteriaReference() {
@@ -45977,12 +47202,12 @@ function renderCriteriaReference() {
 }
 
 // src/check.ts
-import { existsSync as existsSync12, readFileSync as readFileSync12 } from "fs";
-import { dirname as dirname8, join as join27 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync14 } from "fs";
+import { dirname as dirname9, join as join28 } from "path";
 
 // src/verify.ts
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
-import { join as join26 } from "path";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync8 } from "fs";
+import { join as join27 } from "path";
 var VERIFY_MAX = 40;
 var plain = (s) => s.replace(/\[([^\]]+)\]\(#[^)]*\)/g, "$1");
 function auditorCriterionLine(standard) {
@@ -46156,16 +47381,16 @@ function applyVerdicts(items, expected) {
   return { ok: failures.length === 0, total, refuted, unsupported, unadjudicated, invalid, missing, failures };
 }
 function writeWorklist(items, outDir, semantic, standard = "wcag", lang = "en") {
-  mkdirSync6(outDir, { recursive: true });
-  const todoPath = join26(outDir, "VERIFY.todo.json");
-  const mdPath = join26(outDir, "VERIFY.md");
-  writeFileSync7(todoPath, JSON.stringify(items, null, 2) + "\n");
-  writeFileSync7(mdPath, formatWorklist(items, semantic, standard, lang));
+  mkdirSync7(outDir, { recursive: true });
+  const todoPath = join27(outDir, "VERIFY.todo.json");
+  const mdPath = join27(outDir, "VERIFY.md");
+  writeFileSync8(todoPath, JSON.stringify(items, null, 2) + "\n");
+  writeFileSync8(mdPath, formatWorklist(items, semantic, standard, lang));
   return { todoPath, mdPath, count: items.length };
 }
 
 // src/grounding.ts
-import { existsSync as existsSync11, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync13 } from "fs";
 import { resolve as resolve4 } from "path";
 var WINDOW = 10;
 var norm2 = (s) => s.replace(/\s+/g, " ").trim();
@@ -46184,10 +47409,10 @@ function selectorProbes(selector) {
 function groundFinding(g, opts = {}) {
   if (isUnresolvable(g.file)) return { ok: true, moved: false };
   const path = resolve4(opts.cwd ?? process.cwd(), g.file);
-  if (!existsSync11(path)) return { ok: false, moved: false, issue: `cited file not found: ${g.file}` };
+  if (!existsSync12(path)) return { ok: false, moved: false, issue: `cited file not found: ${g.file}` };
   let text;
   try {
-    text = readFileSync11(path, "utf8");
+    text = readFileSync13(path, "utf8");
   } catch {
     return { ok: false, moved: false, issue: `cited file unreadable: ${g.file}` };
   }
@@ -46300,14 +47525,14 @@ function checkReport(md, standard = "wcag", lang = "en", opts = {}) {
   if (!rateM) {
     issues.push(s.rateMissing);
   } else {
-    const pct = parseFloat(rateM[1].replace(",", "."));
-    if (pct < 0 || pct > 100) issues.push(s.rateRange(rateM[1]));
+    const pct2 = parseFloat(rateM[1].replace(",", "."));
+    if (pct2 < 0 || pct2 > 100) issues.push(s.rateRange(rateM[1]));
     else if (core) {
       const totals = synthesisTotals(md);
       if (totals) {
         const { c: c2, nc } = totals;
         const expected = c2 + nc === 0 ? 100 : Math.round(c2 / (c2 + nc) * 100);
-        if (Math.abs(pct - expected) > 1) issues.push(s.rateInconsistent(rateM[1], expected, c2, nc));
+        if (Math.abs(pct2 - expected) > 1) issues.push(s.rateInconsistent(rateM[1], expected, c2, nc));
       }
     }
   }
@@ -46334,11 +47559,11 @@ function checkSemantic(md, opts) {
   const standard = opts.standard ?? "wcag";
   const s = M[lang];
   const empty = { total: 0, grounded: 0, moved: 0, failed: 0 };
-  const artifact = opts.verdictsPath ?? join27(dirname8(opts.reportPath), "VERIFY.todo.json");
-  if (!existsSync12(artifact)) return { ok: false, issues: [s.semanticMissing(artifact)], ...empty };
+  const artifact = opts.verdictsPath ?? join28(dirname9(opts.reportPath), "VERIFY.todo.json");
+  if (!existsSync13(artifact)) return { ok: false, issues: [s.semanticMissing(artifact)], ...empty };
   let items;
   try {
-    const parsed = JSON.parse(readFileSync12(artifact, "utf8"));
+    const parsed = JSON.parse(readFileSync14(artifact, "utf8"));
     if (!Array.isArray(parsed)) throw new Error("not an array");
     items = parsed;
   } catch {
@@ -46370,8 +47595,8 @@ function sectionBody(md, n) {
 }
 
 // src/adjudicate.ts
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync8 } from "fs";
-import { join as join28 } from "path";
+import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync9 } from "fs";
+import { join as join29 } from "path";
 
 // src/data/adjudication.json
 var adjudication_default = {
@@ -47294,49 +48519,91 @@ function docsForAudit(audit2, cwd) {
   const docs = [];
   for (const f of files) {
     try {
-      docs.push(parseSource(readText(cwd ? join28(cwd, f) : f), f));
+      docs.push(parseSource(readText(cwd ? join29(cwd, f) : f), f));
     } catch {
     }
   }
   return docs;
 }
+function blankItem(criteriaId, automatability, title2, harvested) {
+  const evidence = harvested.slice(0, ADJUDICATE_MAX_EVIDENCE);
+  return {
+    criteriaId,
+    automatability,
+    ...title2 ? { title: title2 } : {},
+    evidence,
+    ...harvested.length > ADJUDICATE_MAX_EVIDENCE ? { evidenceTruncated: { shown: evidence.length, total: harvested.length } } : {},
+    verdict: null,
+    justification: "",
+    reason: null,
+    findings: [],
+    recommendations: [],
+    decidedBy: "agent"
+  };
+}
+function packEvidence(scs, docs) {
+  const out2 = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const sc of scs) {
+    for (const e of HARVESTERS[sc]?.(docs) ?? []) {
+      const key = `${e.file}:${e.line}:${e.selector}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out2.push(e);
+    }
+  }
+  return out2;
+}
 function buildAdjudicationWorklist(audit2, opts = {}) {
   const docs = docsForAudit(audit2, opts.cwd);
-  return audit2.residualRisks.map((r) => {
-    const harvested = HARVESTERS[r.criteriaId]?.(docs) ?? [];
-    const evidence = harvested.slice(0, ADJUDICATE_MAX_EVIDENCE);
-    return {
-      criteriaId: r.criteriaId,
-      automatability: r.automatability,
-      title: scTitle(r.criteriaId) ?? void 0,
-      evidence,
-      ...harvested.length > ADJUDICATE_MAX_EVIDENCE ? { evidenceTruncated: { shown: evidence.length, total: harvested.length } } : {},
-      verdict: null,
-      justification: "",
-      reason: null,
-      findings: [],
-      recommendations: [],
-      decidedBy: "agent"
-    };
-  });
+  const standard = opts.standard;
+  if (standard !== void 0 && !isCore(standard)) {
+    const pack = loadPack(standard);
+    return derivePackResults(audit2, standard).filter((pc) => pc.status === "manual").map((pc) => {
+      const crit = getCriterion(pack, pc.id);
+      const scs = crit?.wcag ?? pc.scs;
+      const autos = scs.map((sc) => getSC(sc)?.automatability).filter((a) => !!a);
+      const automatability = autos.includes("needs-rendering") ? "needs-rendering" : "judgment";
+      return blankItem(pc.id, automatability, crit ? titlePlain(pack, crit, "fr") : void 0, packEvidence(scs, docs));
+    });
+  }
+  return audit2.residualRisks.map(
+    (r) => blankItem(r.criteriaId, r.automatability, scTitle(r.criteriaId) ?? void 0, HARVESTERS[r.criteriaId]?.(docs) ?? [])
+  );
 }
 var NC_SEVERITY_DEFAULT = "majeur";
 var MANUAL_REASONS = /* @__PURE__ */ new Set(["needs-rendered-dom", "undecidable"]);
-function normativeRefResolves(ref, standard) {
+function normativeRefResolves(ref, standard, itemCriterionId) {
   const r = (ref ?? "").trim();
   if (!r) return false;
   if (isCore(standard)) return hasSC(r);
   const pack = loadPack(standard);
-  if (hasId(pack, r)) return true;
-  const dot = r.lastIndexOf(".");
-  if (dot <= 0) return false;
-  const crit = getCriterion(pack, r.slice(0, dot));
-  return !!crit?.tests && Object.hasOwn(crit.tests, r.slice(dot + 1));
+  let critId = hasId(pack, r) ? r : void 0;
+  let testKey;
+  if (critId === void 0) {
+    const dot = r.lastIndexOf(".");
+    if (dot <= 0) return false;
+    const head = r.slice(0, dot);
+    if (!hasId(pack, head)) return false;
+    critId = head;
+    testKey = r.slice(dot + 1);
+  }
+  const crit = getCriterion(pack, critId);
+  if (!crit) return false;
+  if (testKey !== void 0 && !(crit.tests && Object.hasOwn(crit.tests, testKey))) return false;
+  return itemCriterionId === void 0 || critId === itemCriterionId;
 }
 function applyAdjudication(audit2, adj, opts = {}) {
   const issues = [];
   const byId2 = new Map(adj.items.map((it) => [it.criteriaId, it]));
-  for (const r of audit2.residualRisks) if (!byId2.has(r.criteriaId)) issues.push(`criterion ${r.criteriaId}: missing from the adjudication (coverage gap)`);
+  const packMode = !isCore(adj.standard);
+  if (packMode) {
+    for (const pc of derivePackResults(audit2, adj.standard)) {
+      if (pc.status === "manual" && !byId2.has(pc.id)) issues.push(`criterion ${pc.id}: missing from the adjudication (coverage gap)`);
+    }
+  } else {
+    for (const r of audit2.residualRisks) if (!byId2.has(r.criteriaId)) issues.push(`criterion ${r.criteriaId}: missing from the adjudication (coverage gap)`);
+  }
   const groundInputs = [];
   for (const it of adj.items) {
     const v = it.verdict;
@@ -47349,8 +48616,10 @@ function applyAdjudication(audit2, adj, opts = {}) {
       for (const f of it.findings ?? []) {
         if (!f.normativeRef || !f.normativeRef.trim()) {
           issues.push(`criterion ${it.criteriaId}: an NC finding requires a normativeRef citing the failed test of the active standard`);
-        } else if (!normativeRefResolves(f.normativeRef, adj.standard)) {
-          issues.push(`criterion ${it.criteriaId}: normativeRef "${f.normativeRef}" does not resolve to a test of ${adj.standard} (fabricated?)`);
+        } else if (!normativeRefResolves(f.normativeRef, adj.standard, isCore(adj.standard) ? void 0 : it.criteriaId)) {
+          issues.push(
+            isCore(adj.standard) ? `criterion ${it.criteriaId}: normativeRef "${f.normativeRef}" does not resolve to a test of ${adj.standard} (fabricated?)` : `criterion ${it.criteriaId}: normativeRef "${f.normativeRef}" is not a test of ${adj.standard} ${it.criteriaId} \u2014 cite one of its own tests (e.g. "${it.criteriaId}.1"); a WCAG id looks alike but denotes an unrelated test`
+          );
         }
         groundInputs.push({ file: f.file, line: f.line, selector: f.selector, snippet: f.snippet });
       }
@@ -47372,6 +48641,38 @@ function applyAdjudication(audit2, adj, opts = {}) {
   const newFindings = [];
   let applied = 0;
   let stillManual = 0;
+  if (packMode) {
+    const decided = [];
+    for (const it of adj.items) {
+      if (it.verdict === "manual") {
+        stillManual++;
+        decided.push({
+          id: it.criteriaId,
+          status: "manual",
+          reason: it.reason === "needs-rendered-dom" ? "needs-rendered-dom" : "undecidable",
+          justification: it.reason === "needs-rendered-dom" ? residualScanReason() : residualUndecidableReason(),
+          findings: [],
+          decidedBy: "agent"
+        });
+        continue;
+      }
+      applied++;
+      const fs2 = it.verdict === "NC" ? it.findings.map((f) => agentFinding(it.criteriaId, f)) : [];
+      const recs = (it.recommendations ?? []).map((rec) => agentFinding(it.criteriaId, rec, true));
+      newFindings.push(...fs2, ...recs);
+      decided.push({
+        id: it.criteriaId,
+        status: it.verdict,
+        ...it.verdict === "C" || it.verdict === "NA" ? { justification: it.justification.trim() } : {},
+        findings: [...fs2, ...recs],
+        decidedBy: "agent"
+      });
+    }
+    next.packAdjudication = { standard: adj.standard, criteria: decided };
+    next.findings = [...next.findings, ...newFindings];
+    next.adjudicated = { date: adj.auditDate, applied, stillManual };
+    return { ok: true, audit: next, issues, applied, stillManual, grounding };
+  }
   for (const it of adj.items) {
     const c2 = critById.get(it.criteriaId);
     if (!c2) continue;
@@ -47454,7 +48755,12 @@ var T2 = {
     questions: "\xC0 v\xE9rifier manuellement",
     decide: "R\xE8gle de d\xE9cision",
     na: "Non applicable si",
-    refs: "R\xE9f\xE9rences normatives mobilisables (techniques/\xE9checs W3C de ce crit\xE8re)"
+    refs: "R\xE9f\xE9rences normatives mobilisables (techniques/\xE9checs W3C de ce crit\xE8re)",
+    packIntro: (name2) => `R\xE9f\xE9rentiel actif : **${name2}**. Les items ci-dessous sont des crit\xE8res ${name2}, pas des crit\xE8res de succ\xE8s WCAG. Un \`normativeRef\` DOIT citer un test du crit\xE8re de l'item (par ex. \`11.2.1\`) \u2014 un id WCAG y ressemble mais d\xE9signe un tout autre test et sera rejet\xE9.`,
+    packTests: (name2, id) => `Tests ${name2} ${id} \xE0 trancher`,
+    technicalNote: "Note technique",
+    particularCases: "Cas particuliers",
+    glossary: "Termes d\xE9finis par le r\xE9f\xE9rentiel"
   },
   en: {
     title: "# Criteria adjudication (ultra11y)",
@@ -47472,16 +48778,60 @@ var T2 = {
     questions: "To verify manually",
     decide: "Decision rule",
     na: "Not applicable when",
-    refs: "Normative references you may cite (this criterion's W3C techniques/failures)"
+    refs: "Normative references you may cite (this criterion's W3C techniques/failures)",
+    packIntro: (name2) => `Active standard: **${name2}**. The items below are ${name2} criteria, not WCAG success criteria. A \`normativeRef\` MUST cite a test OF THE ITEM'S CRITERION (e.g. \`11.2.1\`) \u2014 a WCAG id looks alike but denotes an unrelated test and will be rejected.`,
+    packTests: (name2, id) => `${name2} ${id} tests to rule on`,
+    technicalNote: "Technical note",
+    particularCases: "Particular cases",
+    glossary: "Terms the standard defines"
   }
 };
 var ADJUDICATION = adjudication_default;
 var MAX_REFS = 12;
-function formatAdjudication(items, lang = "en") {
+var GLOSSARY_REF = /\[[^\]]+\]\(#([^)]+)\)/g;
+var MAX_GLOSSARY_TERMS = 8;
+var MAX_GLOSSARY_CHARS = 600;
+function glossaryAnchorsOf(crit) {
+  if (!crit) return [];
+  const texts = [...Object.values(crit.tests ?? {}).flat(), ...crit.technicalNote ?? [], ...crit.particularCases ?? []];
+  const seen = /* @__PURE__ */ new Set();
+  for (const t2 of texts) {
+    GLOSSARY_REF.lastIndex = 0;
+    for (let m = GLOSSARY_REF.exec(t2); m; m = GLOSSARY_REF.exec(t2)) if (m[1]) seen.add(m[1]);
+  }
+  return [...seen];
+}
+function glossaryBlock(pack, crit, lang) {
+  const anchors = glossaryAnchorsOf(crit).slice(0, MAX_GLOSSARY_TERMS);
+  if (!anchors.length) return [];
   const s = T2[lang];
+  const out2 = [`> **${s.glossary}**`, ""];
+  let any = false;
+  for (const a of anchors) {
+    const entry = resolveGlossary(pack.key, a);
+    if (!entry) continue;
+    any = true;
+    const body2 = entry.body.replace(/\s+/g, " ").trim();
+    out2.push(`- **${entry.title}** \u2014 ${body2.length > MAX_GLOSSARY_CHARS ? `${body2.slice(0, MAX_GLOSSARY_CHARS)}\u2026` : body2}`);
+  }
+  out2.push("");
+  return any ? out2 : [];
+}
+function packGuidanceBlock(standard, criterionId, lang) {
+  const entries = guidanceForCriterion(standard, criterionId);
+  if (!entries.length) return [];
+  return guidanceExampleBlock(entries, lang);
+}
+function plainTest(s) {
+  return s.replace(/\[([^\]]+)\]\(#[^)]*\)/g, "$1");
+}
+function formatAdjudication(items, lang = "en", standard = CORE2) {
+  const s = T2[lang];
+  const pack = isCore(standard) ? void 0 : loadPack(standard);
   const out2 = [s.title, "", s.intro, "", ...s.verdicts, "", s.rule, "", s.then, ""];
+  if (pack) out2.push(`> ${s.packIntro(pack.name)}`, "");
   for (const it of items) {
-    out2.push(`## ${it.criteriaId}${it.title ? ` \u2014 ${it.title}` : ""}  _(${it.automatability})_`);
+    out2.push(`## ${pack ? `${pack.name} ` : ""}${it.criteriaId}${it.title ? ` \u2014 ${it.title}` : ""}  _(${it.automatability})_`);
     out2.push("", `> ${s.evidence} (${it.evidence.length}${it.evidenceTruncated ? ` / ${it.evidenceTruncated.total}` : ""}):`, "");
     if (!it.evidence.length) out2.push(s.none, "");
     else {
@@ -47498,17 +48848,37 @@ function formatAdjudication(items, lang = "en") {
         out2.push("");
       }
     }
-    const refs = techniquesFor(it.criteriaId);
-    if (refs.length) {
-      out2.push(`> ${s.refs}: ${refs.slice(0, MAX_REFS).join(", ")}${refs.length > MAX_REFS ? ` \u2026 (\`criteria ${it.criteriaId}\`)` : ""}`, "");
+    if (pack) {
+      const crit = getCriterion(pack, it.criteriaId);
+      const tests = crit?.tests ?? {};
+      const keys = Object.keys(tests);
+      if (keys.length) {
+        out2.push(`> **${s.packTests(pack.name, it.criteriaId)}**`, "");
+        for (const k of keys) {
+          const lines = tests[k] ?? [];
+          out2.push(`- \`${it.criteriaId}.${k}\` ${plainTest(lines[0] ?? "")}`);
+          for (const line of lines.slice(1)) out2.push(`  - ${plainTest(line)}`);
+        }
+        out2.push("");
+      }
+      if (crit?.technicalNote?.length) out2.push(`> **${s.technicalNote}** \u2014 ${crit.technicalNote.map(plainTest).join(" ")}`, "");
+      if (crit?.particularCases?.length) out2.push(`> **${s.particularCases}** \u2014 ${crit.particularCases.map(plainTest).join(" ")}`, "");
+      out2.push(...glossaryBlock(pack, crit, lang));
+      out2.push(...packGuidanceBlock(standard, it.criteriaId, lang));
+      if (keys.length) out2.push(`> ${s.refs}: ${keys.map((k) => `\`${it.criteriaId}.${k}\``).join(", ")}`, "");
+    } else {
+      const refs = techniquesFor(it.criteriaId);
+      if (refs.length) {
+        out2.push(`> ${s.refs}: ${refs.slice(0, MAX_REFS).join(", ")}${refs.length > MAX_REFS ? ` \u2026 (\`criteria ${it.criteriaId}\`)` : ""}`, "");
+      }
     }
   }
   return out2.join("\n");
 }
 function writeAdjudication(items, outDir, opts) {
-  mkdirSync7(outDir, { recursive: true });
-  const todoPath = join28(outDir, "ADJUDICATE.todo.json");
-  const mdPath = join28(outDir, "ADJUDICATE.md");
+  mkdirSync8(outDir, { recursive: true });
+  const todoPath = join29(outDir, "ADJUDICATE.todo.json");
+  const mdPath = join29(outDir, "ADJUDICATE.md");
   const file = {
     tool: "ultra11y",
     kind: "adjudication",
@@ -47517,16 +48887,16 @@ function writeAdjudication(items, outDir, opts) {
     auditDate: opts.auditDate,
     items
   };
-  writeFileSync8(todoPath, JSON.stringify(file, null, 2) + "\n");
-  writeFileSync8(mdPath, formatAdjudication(items, opts.lang ?? "en"));
+  writeFileSync9(todoPath, JSON.stringify(file, null, 2) + "\n");
+  writeFileSync9(mdPath, formatAdjudication(items, opts.lang ?? "en", opts.standard));
   return { todoPath, mdPath, count: items.length };
 }
 
 // src/scan.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync9, existsSync as existsSync14, statSync as statSync7, readdirSync as readdirSync4, rmSync as rmSync3, readFileSync as readFileSync13 } from "fs";
+import { mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync10, existsSync as existsSync15, statSync as statSync7, readdirSync as readdirSync5, rmSync as rmSync3, readFileSync as readFileSync15 } from "fs";
 import { tmpdir } from "os";
-import { join as join29, resolve as resolve5 } from "path";
+import { join as join30, resolve as resolve5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/axe-map.ts
@@ -47768,7 +49138,7 @@ async function crawlUrls(start2, opts) {
 }
 
 // src/sample.ts
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 function looksLikeTarget(u) {
   return /^https?:\/\//i.test(u) || /^(\.\.?[/\\]|[/\\])/.test(u) || /\.x?html?$/i.test(u);
 }
@@ -47804,7 +49174,7 @@ function validateSample(raw) {
     if (p.auth !== void 0 && typeof p.auth !== "boolean") err2(`sample.pages[${i2}].auth`, "auth must be a boolean");
     if (p.storageState !== void 0 && (typeof p.storageState !== "string" || p.storageState.trim() === "")) {
       err2(`sample.pages[${i2}].storageState`, "storageState must be a non-empty file path string");
-    } else if (typeof p.storageState === "string" && p.storageState.trim() !== "" && !existsSync13(p.storageState)) {
+    } else if (typeof p.storageState === "string" && p.storageState.trim() !== "" && !existsSync14(p.storageState)) {
       warn(
         `sample.pages[${i2}].storageState`,
         `storageState path not found: "${p.storageState}" (resolved from the current directory) \u2014 the scan will not be able to load this session`
@@ -47929,11 +49299,11 @@ function imageExists(tag) {
 }
 var CTX_PREFIX = "ultra11y-dyn-";
 function buildImage(tag = IMAGE_TAG) {
-  const ctx = mkdtempSync2(join29(tmpdir(), CTX_PREFIX));
+  const ctx = mkdtempSync2(join30(tmpdir(), CTX_PREFIX));
   try {
-    writeFileSync9(join29(ctx, "runner.mjs"), RUNNER);
-    writeFileSync9(join29(ctx, "package.json"), PKG);
-    writeFileSync9(join29(ctx, "Dockerfile"), DOCKERFILE);
+    writeFileSync10(join30(ctx, "runner.mjs"), RUNNER);
+    writeFileSync10(join30(ctx, "package.json"), PKG);
+    writeFileSync10(join30(ctx, "Dockerfile"), DOCKERFILE);
     execFileSync3("docker", ["build", "-t", tag, ctx], { stdio: "inherit", timeout: 9e5 });
   } finally {
     rmSync3(ctx, { recursive: true, force: true });
@@ -47942,9 +49312,9 @@ function buildImage(tag = IMAGE_TAG) {
 function cleanTempContexts() {
   let removed = 0;
   const dir = tmpdir();
-  for (const name2 of readdirSync4(dir)) {
+  for (const name2 of readdirSync5(dir)) {
     if (!name2.startsWith(CTX_PREFIX)) continue;
-    rmSync3(join29(dir, name2), { recursive: true, force: true });
+    rmSync3(join30(dir, name2), { recursive: true, force: true });
     removed++;
   }
   return removed;
@@ -48054,8 +49424,8 @@ function toDynamicResult(out2, target, lang = "en", engine = "axe-core@playwrigh
 }
 var DOCKER_TESTED_SCS = ["1.4.10"];
 function runScan(opts) {
-  const isUrl = /^https?:\/\//i.test(opts.target);
-  if (!isUrl && !existsSync14(opts.target)) {
+  const isUrl3 = /^https?:\/\//i.test(opts.target);
+  if (!isUrl3 && !existsSync15(opts.target)) {
     throw new Error(`File not found: ${opts.target}. Pass an http(s):// URL or an existing HTML file.`);
   }
   if (!dockerAvailable()) {
@@ -48063,7 +49433,7 @@ function runScan(opts) {
   }
   const tag = opts.tag ?? IMAGE_TAG;
   if (!imageExists(tag)) buildImage(tag);
-  const isFile = !isUrl && existsSync14(opts.target) && statSync7(opts.target).isFile();
+  const isFile = !isUrl3 && existsSync15(opts.target) && statSync7(opts.target).isFile();
   const out2 = runRunner(opts.target, isFile, tag);
   return { ...toDynamicResult(out2, opts.target), testedScs: [...DOCKER_TESTED_SCS] };
 }
@@ -48141,10 +49511,10 @@ async function runCrawlScan(opts) {
 var sevRank = { bloquant: 3, majeur: 2, mineur: 1 };
 function resolveHostAnchor(file, snippet2) {
   const s = snippet2?.trim();
-  if (!s || !existsSync14(file)) return null;
+  if (!s || !existsSync15(file)) return null;
   let source;
   try {
-    source = readFileSync13(file, "utf8");
+    source = readFileSync15(file, "utf8");
   } catch {
     return null;
   }
@@ -48240,7 +49610,7 @@ function mergeDynamic(audit2, dynamic, lang = "en") {
 }
 
 // src/scan-local.ts
-import { existsSync as existsSync15, statSync as statSync8 } from "fs";
+import { existsSync as existsSync16, statSync as statSync8 } from "fs";
 import { createRequire } from "module";
 import { resolve as resolve6 } from "path";
 var LOCAL_ENGINE = "axe-core@playwright (local)";
@@ -48795,11 +50165,11 @@ async function runOnPage(browser, AxeBuilder, target, isFile, opts) {
   }
 }
 async function runScanLocal(opts) {
-  const isUrl = /^https?:\/\//i.test(opts.target);
-  if (!isUrl && !existsSync15(opts.target)) {
+  const isUrl3 = /^https?:\/\//i.test(opts.target);
+  if (!isUrl3 && !existsSync16(opts.target)) {
     throw new Error(`File not found: ${opts.target}. Pass an http(s):// URL or an existing HTML file.`);
   }
-  const isFile = !isUrl && statSync8(opts.target).isFile();
+  const isFile = !isUrl3 && statSync8(opts.target).isFile();
   const lang = opts.lang ?? "en";
   const interact = opts.interact !== false;
   const { chromium, AxeBuilder } = resolveLocalDeps(opts.cwd);
@@ -48877,7 +50247,7 @@ async function runCrawlScanLocal(opts) {
 }
 
 // src/fix.ts
-import { writeFileSync as writeFileSync10 } from "fs";
+import { writeFileSync as writeFileSync11 } from "fs";
 
 // src/fix/edits.ts
 function openTag(source, start2) {
@@ -49091,7 +50461,7 @@ function fixOne(file, source, opts, canWrite = true) {
     regression = after.length > findings.length || after.some((f) => !beforeKinds.has(f.ruleId));
     if (opts.write && !regression && file !== "<stdin>") {
       if (canWrite) {
-        writeFileSync10(file, output);
+        writeFileSync11(file, output);
         written = true;
       } else {
         skippedPartialStage = true;
@@ -49214,9 +50584,9 @@ function baselineSummary(diff, lang = "fr") {
 }
 
 // src/init.ts
-import { writeFileSync as writeFileSync11, mkdirSync as mkdirSync8, chmodSync } from "fs";
+import { writeFileSync as writeFileSync12, mkdirSync as mkdirSync9, chmodSync } from "fs";
 import { execFileSync as execFileSync4 } from "child_process";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 var EN_SEV = { bloquant: "blocking", majeur: "major", mineur: "minor" };
 function repoRoot() {
   try {
@@ -49269,35 +50639,61 @@ function ciWorkflow(enginePath, failOn) {
   return `name: a11y
 # Generated by \`ultra11y init --ci\`. Fails only on NEW non-conformities >= ${EN_SEV[failOn]}
 # introduced by the PR (vs audits/baseline.json) \u2014 not the existing backlog.
+#
+# Findings are reported IN the pull request: SARIF \u2192 code scanning puts each one on the line
+# of code that caused it, and \`::error::\` annotations cover repositories without Advanced
+# Security. Set \`comment: 'true'\` to also get a sticky summary comment (needs
+# \`pull-requests: write\`), and \`standard: 'rgaa'\` to report against a country standard.
+#
+# The action is PINNED to the engine version that generated this file, so a CI run stays
+# reproducible. \`maxgfr/ultra11y@v${VERSION.split(".")[0]}\` also resolves (a moving major
+# tag) if you would rather track the major line and take fixes automatically.
 on:
   pull_request:
+
+permissions:
+  contents: read
+  security-events: write # SARIF upload; drop it and the annotations still report
+  # pull-requests: write # uncomment together with \`comment: 'true'\` below
+
 jobs:
   ultra11y:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
         with:
-          fetch-depth: 0
-      - uses: actions/setup-node@v4
+          fetch-depth: 0 # the diff gate needs the base ref
+      - uses: maxgfr/ultra11y@v${VERSION}
         with:
-          node-version: 20
-      - name: ultra11y accessibility regression gate
-        run: node "${enginePath}" audit --since "origin/\${{ github.base_ref }}" --baseline audits/baseline.json --fail-on ${EN_SEV[failOn]}
+          since: auto # the PR's base branch
+          baseline: audits/baseline.json
+          fail-on: ${EN_SEV[failOn]}
+          # standard: rgaa
+          # comment: 'true'
+          #
+          # Page-by-page, with a real browser (computed contrast, focus, zoom, reflow):
+          # start: npm run start
+          # wait-on: http://localhost:3000
+          # urls: http://localhost:3000 http://localhost:3000/contact
+          # \u2026or \`sample: 'true'\` to scan the sample declared in .ultra11yrc.json.
+#
+# Vendored alternative \u2014 no marketplace action, just the bundle in this repo:
+#   - run: node "${enginePath}" audit --since "origin/\${{ github.base_ref }}" --baseline audits/baseline.json --fail-on ${EN_SEV[failOn]}
 `;
 }
 function writeHook(root, enginePath, failOn, mode = "staged") {
-  const dir = join30(root, ".git", "hooks");
-  mkdirSync8(dir, { recursive: true });
-  const path = join30(dir, "pre-commit");
-  writeFileSync11(path, mode === "baseline" ? hookScript(enginePath, failOn) : stagedHookScript(enginePath, failOn));
+  const dir = join31(root, ".git", "hooks");
+  mkdirSync9(dir, { recursive: true });
+  const path = join31(dir, "pre-commit");
+  writeFileSync12(path, mode === "baseline" ? hookScript(enginePath, failOn) : stagedHookScript(enginePath, failOn));
   chmodSync(path, 493);
   return path;
 }
 function writeCi(root, enginePath, failOn) {
-  const dir = join30(root, ".github", "workflows");
-  mkdirSync8(dir, { recursive: true });
-  const path = join30(dir, "a11y.yml");
-  writeFileSync11(path, ciWorkflow(enginePath, failOn));
+  const dir = join31(root, ".github", "workflows");
+  mkdirSync9(dir, { recursive: true });
+  const path = join31(dir, "a11y.yml");
+  writeFileSync12(path, ciWorkflow(enginePath, failOn));
   return path;
 }
 
@@ -49380,12 +50776,826 @@ function captureCoverageSummary(cov, lang) {
   return lines.join("\n");
 }
 
+// src/sarif.ts
+var INFO_URI = "https://github.com/maxgfr/ultra11y";
+var SCHEMA = "https://json.schemastore.org/sarif-2.1.0.json";
+var FINGERPRINT_KEY = "ultra11yFindingId/v1";
+var LEVEL = { bloquant: "error", majeur: "warning", mineur: "note" };
+function levelFor(f) {
+  return f.advisory ? "note" : LEVEL[f.severity];
+}
+var toUri = repoRelative;
+var isUrl = isUrlPath;
+function physicalLocation(f, baseDir) {
+  if (isUrl(f.file)) return [];
+  return [
+    {
+      physicalLocation: {
+        artifactLocation: { uri: toUri(f.file, baseDir) },
+        region: {
+          // SARIF regions are 1-based. A merged dynamic finding can carry line 0 when the
+          // host-anchor resolver declined to guess (src/scan.ts resolveHostAnchor) — clamp
+          // rather than emit an invalid region.
+          startLine: Math.max(1, f.line),
+          startColumn: Math.max(1, f.col),
+          ...f.snippet ? { snippet: { text: f.snippet } } : {}
+        }
+      }
+    }
+  ];
+}
+function relatedLocations(f, baseDir) {
+  const r = f.related;
+  if (!r || isUrl(r.file)) return void 0;
+  return [
+    { physicalLocation: { artifactLocation: { uri: toUri(r.file, baseDir) }, region: { startLine: Math.max(1, r.line), startColumn: Math.max(1, r.col) } } }
+  ];
+}
+function criterionLabel(f, standard) {
+  if (isCore(standard)) return `WCAG ${f.criteriaId}`;
+  const pack = loadPack(standard);
+  const ids = packCriteriaForFinding(pack, f);
+  return ids.length ? `${pack.name} ${ids.join(", ")}` : `WCAG ${f.criteriaId}`;
+}
+function ruleFor(f, standard, lang) {
+  const sc = f.criteriaId;
+  const title2 = scTitle(sc, lang);
+  const tags = ["accessibility", `wcag:${sc}`];
+  if (!isCore(standard)) {
+    const pack = loadPack(standard);
+    for (const id of packCriteriaForFinding(pack, f)) tags.push(`${pack.key}:${id}`);
+  }
+  if (f.advisory) tags.push("recommendation");
+  const level = levelFor(f);
+  return {
+    id: f.ruleId,
+    shortDescription: { text: title2 ? `${f.ruleId} \u2014 WCAG ${sc} ${title2}` : `${f.ruleId} \u2014 WCAG ${sc}` },
+    fullDescription: { text: resolveRemediation(f, lang) },
+    ...understanding(sc) ? { helpUri: understanding(sc) } : {},
+    defaultConfiguration: { level },
+    properties: { tags, "problem.severity": level }
+  };
+}
+function toSarif(result, opts = {}) {
+  const standard = opts.standard ?? CORE2;
+  const lang = opts.lang ?? "en";
+  const baseDir = opts.baseDir ?? process.cwd();
+  const rules = [];
+  const indexOf = /* @__PURE__ */ new Map();
+  const results = [];
+  for (const f of findingsForStandard(result, standard)) {
+    let idx = indexOf.get(f.ruleId);
+    if (idx === void 0) {
+      idx = rules.length;
+      indexOf.set(f.ruleId, idx);
+      rules.push(ruleFor(f, standard, lang));
+    }
+    const related = relatedLocations(f, baseDir);
+    const page = f.sample?.page;
+    const properties = { criterion: criterionLabel(f, standard) };
+    if (isUrl(f.file)) properties.url = f.file;
+    if (page) properties.page = page;
+    if (f.advisory) properties.advisory = true;
+    if (f.preliminary) properties.preliminary = true;
+    results.push({
+      ruleId: f.ruleId,
+      ruleIndex: idx,
+      level: levelFor(f),
+      message: { text: `[${criterionLabel(f, standard)}] ${resolveMessage(f, lang)} \u2014 ${resolveRemediation(f, lang)}` },
+      locations: physicalLocation(f, baseDir),
+      ...related ? { relatedLocations: related } : {},
+      partialFingerprints: { [FINGERPRINT_KEY]: findingId(f) },
+      properties
+    });
+  }
+  return {
+    $schema: SCHEMA,
+    version: "2.1.0",
+    runs: [
+      {
+        tool: { driver: { name: "ultra11y", version: VERSION, informationUri: INFO_URI, rules } },
+        // Distinguishes concurrent uploads in one PR (source audit vs page scan) so
+        // GitHub keeps them as separate analyses instead of overwriting one another.
+        automationDetails: { id: `ultra11y/${standard}/` },
+        results
+      }
+    ]
+  };
+}
+
+// src/annotate.ts
+var LEVEL2 = { bloquant: "error", majeur: "warning", mineur: "notice" };
+var ICON6 = { bloquant: "\u{1F534}", majeur: "\u{1F7E0}", mineur: "\u{1F7E1}" };
+var SEV_ORDER5 = ["bloquant", "majeur", "mineur"];
+function esc(s) {
+  return s.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
+}
+function escProp(s) {
+  return esc(s).replace(/:/g, "%3A").replace(/,/g, "%2C");
+}
+var isUrl2 = isUrlPath;
+function criterionLabel2(f, standard) {
+  if (isCore(standard)) return `WCAG ${f.criteriaId}`;
+  const pack = loadPack(standard);
+  const ids = packCriteriaForFinding(pack, f);
+  return ids.length ? `${pack.name} ${ids.join(", ")}` : `WCAG ${f.criteriaId}`;
+}
+function annotations(result, opts = {}) {
+  const standard = opts.standard ?? CORE2;
+  const lang = opts.lang ?? "en";
+  const baseDir = opts.baseDir ?? process.cwd();
+  const all = findingsForStandard(result, standard);
+  const scoped = opts.failOn ? findingsAtOrAbove(all, opts.failOn) : all;
+  const out2 = [];
+  for (const f of scoped) {
+    if (isUrl2(f.file)) continue;
+    const level = f.advisory ? "notice" : LEVEL2[f.severity];
+    const file = repoRelative(f.file, baseDir);
+    const title2 = `${criterionLabel2(f, standard)} \xB7 ${f.ruleId}`;
+    const body2 = `${resolveMessage(f, lang)}
+${resolveRemediation(f, lang)}`;
+    out2.push(`::${level} file=${escProp(file)},line=${Math.max(1, f.line)},col=${Math.max(1, f.col)},title=${escProp(title2)}::${esc(body2)}`);
+  }
+  return out2;
+}
+var S = {
+  fr: {
+    title: "Audit d'accessibilit\xE9 ultra11y",
+    files: "fichiers",
+    rate: "r\xE9ussite automatique",
+    none: "\u2705 Aucune non-conformit\xE9 d\xE9tect\xE9e par le moteur statique.",
+    findings: "Non-conformit\xE9s",
+    severity: "S\xE9v\xE9rit\xE9",
+    criterion: "Crit\xE8re",
+    where: "Emplacement",
+    what: "Constat",
+    more: (n) => `\u2026 et ${n} autre(s).`,
+    perPage: "Constats par page",
+    page: "Page",
+    count: "Constats",
+    unanchored: (n) => `${n} constat(s) rattach\xE9(s) \xE0 une URL, sans ligne de code \xE0 annoter \u2014 voir le rapport.`
+  },
+  en: {
+    title: "ultra11y accessibility audit",
+    files: "files",
+    rate: "automatic pass rate",
+    none: "\u2705 No non-conformity detected by the static engine.",
+    findings: "Non-conformities",
+    severity: "Severity",
+    criterion: "Criterion",
+    where: "Location",
+    what: "Finding",
+    more: (n) => `\u2026 and ${n} more.`,
+    perPage: "Findings per page",
+    page: "Page",
+    count: "Findings",
+    unanchored: (n) => `${n} finding(s) keyed to a URL, with no code line to annotate \u2014 see the report.`
+  }
+};
+var MAX_ROWS = 50;
+function stepSummary(result, opts = {}) {
+  const standard = opts.standard ?? CORE2;
+  const lang = opts.lang ?? "en";
+  const s = S[lang];
+  const stdLabel = isCore(standard) ? "WCAG 2.2 AA" : loadPack(standard).name;
+  const out2 = [];
+  out2.push(`## ${s.title} \u2014 ${stdLabel}`, "");
+  out2.push(`\`${result.date}\` \xB7 ${result.scope.files} ${s.files} \xB7 **${result.conformancePct}%** ${s.rate}`, "");
+  const baseDir = opts.baseDir ?? process.cwd();
+  const all = findingsForStandard(result, standard);
+  if (!all.length) {
+    out2.push(s.none, "");
+    return out2.join("\n");
+  }
+  const sorted = [...all].sort((a, b) => SEV_ORDER5.indexOf(a.severity) - SEV_ORDER5.indexOf(b.severity));
+  out2.push(`### ${s.findings} (${sorted.length})`, "");
+  out2.push(`| ${s.severity} | ${s.criterion} | ${s.where} | ${s.what} |`, "| --- | --- | --- | --- |");
+  for (const f of sorted.slice(0, MAX_ROWS)) {
+    const where = isUrl2(f.file) ? f.file : `${repoRelative(f.file, baseDir)}:${Math.max(1, f.line)}`;
+    const msg = resolveMessage(f, lang).replace(/\|/g, "\\|");
+    out2.push(`| ${ICON6[f.severity]} ${f.severity} | ${criterionLabel2(f, standard)} | \`${where}\` | ${msg} |`);
+  }
+  if (sorted.length > MAX_ROWS) out2.push("", s.more(sorted.length - MAX_ROWS));
+  out2.push("");
+  const unanchored = all.filter((f) => isUrl2(f.file)).length;
+  if (unanchored) out2.push(`> ${s.unanchored(unanchored)}`, "");
+  const pages = result.scope.sample?.pages ?? [];
+  if (pages.length) {
+    out2.push(`### ${s.perPage}`, "");
+    out2.push(`| ${s.page} | ${s.count} |`, "| --- | --- |");
+    for (const pg of pages) {
+      const n = all.filter((f) => f.file === pg.url || f.sample?.page !== void 0 && f.sample.page === pg.name).length;
+      out2.push(`| ${pg.name} \u2014 \`${pg.url}\` | ${n} |`);
+    }
+    out2.push("");
+  }
+  return out2.join("\n");
+}
+
+// src/dev.ts
+import { createServer } from "http";
+import { join as join32 } from "path";
+var DEV_DEFAULT_PORT = 4111;
+function criterionLabel3(f, standard) {
+  if (isCore(standard)) return `WCAG ${f.criteriaId}`;
+  const pack = loadPack(standard);
+  const ids = packCriteriaForFinding(pack, f);
+  return ids.length ? `${pack.name} ${ids.join(", ")}` : `WCAG ${f.criteriaId}`;
+}
+function overlayJs() {
+  return `(() => {
+  const ENDPOINT = window.__ULTRA11Y_ENDPOINT__ || "http://127.0.0.1:${DEV_DEFAULT_PORT}";
+  const HOST_ID = "__ultra11y_overlay";
+  if (document.getElementById(HOST_ID)) return;
+
+  const host = document.createElement("div");
+  host.id = HOST_ID;
+  const shadow = host.attachShadow({ mode: "open" });
+  const style = document.createElement("style");
+  style.textContent = \`
+    :host { all: initial; }
+    .bar { position: fixed; right: 16px; bottom: 16px; z-index: 2147483647;
+      font: 13px/1.4 ui-sans-serif, system-ui, sans-serif; }
+    button.fab { border: 0; border-radius: 999px; padding: 10px 14px; cursor: pointer;
+      background: #1c1c1e; color: #fff; box-shadow: 0 2px 12px rgba(0,0,0,.35); }
+    button.fab[data-state="ok"] { background: #0a7d33; }
+    button.fab[data-state="bad"] { background: #b3261e; }
+    .panel { position: fixed; right: 16px; bottom: 64px; width: min(460px, calc(100vw - 32px));
+      max-height: min(60vh, 560px); overflow: auto; background: #fff; color: #111;
+      border-radius: 10px; box-shadow: 0 8px 32px rgba(0,0,0,.28); padding: 12px 14px; }
+    @media (prefers-color-scheme: dark) { .panel { background: #1c1c1e; color: #f2f2f7; } }
+    h2 { font-size: 13px; margin: 0 0 8px; }
+    ul { list-style: none; margin: 0; padding: 0; }
+    li { padding: 7px 0; border-top: 1px solid rgba(127,127,127,.25); }
+    .sev { font-weight: 700; margin-right: 6px; }
+    .b { color: #b3261e; } .m { color: #b06000; } .n { color: #666; }
+    a { color: inherit; }
+    code { font: 11px/1.4 ui-monospace, monospace; opacity: .8; }
+    .empty { opacity: .75; }
+  \`;
+  const root = document.createElement("div");
+  root.className = "bar";
+  const fab = document.createElement("button");
+  fab.className = "fab";
+  fab.type = "button";
+  fab.textContent = "a11y \u2026";
+  const panel = document.createElement("div");
+  panel.className = "panel";
+  panel.hidden = true;
+  root.append(fab, panel);
+  shadow.append(style, root);
+  document.body.appendChild(host);
+
+  fab.addEventListener("click", () => { panel.hidden = !panel.hidden; });
+
+  const SEV = { bloquant: ["b", "BLOQUANT"], majeur: ["m", "MAJEUR"], mineur: ["n", "mineur"] };
+
+  function render(findings, error) {
+    if (error) {
+      fab.textContent = "a11y ?";
+      fab.dataset.state = "";
+      panel.innerHTML = "<h2>ultra11y</h2><p class='empty'>" + String(error) + "</p>";
+      return;
+    }
+    const nc = findings.filter((f) => !f.advisory);
+    fab.textContent = nc.length ? "a11y " + nc.length : "a11y \u2713";
+    fab.dataset.state = nc.length ? "bad" : "ok";
+    if (!findings.length) {
+      panel.innerHTML = "<h2>ultra11y</h2><p class='empty'>No non-conformity detected on this page by the static engine. The judgment criteria remain yours.</p>";
+      return;
+    }
+    const h = document.createElement("h2");
+    h.textContent = "ultra11y \u2014 " + nc.length + " non-conformity(ies) on this page";
+    const ul = document.createElement("ul");
+    for (const f of findings.slice(0, 60)) {
+      const li = document.createElement("li");
+      const s = SEV[f.severity] || ["n", f.severity];
+      const sev = document.createElement("span");
+      sev.className = "sev " + s[0];
+      sev.textContent = f.advisory ? "reco" : s[1];
+      li.append(sev, document.createTextNode(f.message));
+      const where = (f.origin && f.origin.sourceFile) || f.file;
+      const line = (f.origin && f.origin.sourceLine) || f.line || 1;
+      if (where && !/^https?:/.test(where)) {
+        const a = document.createElement("a");
+        // Next exposes this endpoint in dev; it opens the file in the configured editor.
+        a.href = "/__nextjs_launch-editor?file=" + encodeURIComponent(where + ":" + line + ":1");
+        a.textContent = where + ":" + line;
+        a.addEventListener("click", (e) => { e.preventDefault(); fetch(a.href).catch(() => {}); });
+        const code = document.createElement("code");
+        code.append(document.createElement("br"), a);
+        li.append(code);
+      }
+      ul.append(li);
+    }
+    panel.replaceChildren(h, ul);
+  }
+
+  let busy = false;
+  async function check() {
+    if (busy) return;
+    busy = true;
+    fab.textContent = "a11y \u2026";
+    // Detach the overlay so it is neither serialized nor counted: its presence would shift
+    // every document-order index by one and break the styles/DOM join.
+    const parent = host.parentNode;
+    if (parent) parent.removeChild(host);
+    let collected;
+    try {
+      collected = (0, eval)(${JSON.stringify(COLLECT_SNAPSHOT)});
+    } finally {
+      if (parent) parent.appendChild(host);
+      busy = false;
+    }
+    try {
+      const res = await fetch(ENDPOINT + "/snapshot", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          meta: { v: 1, id: slug(location.pathname), name: document.title || location.pathname, url: location.href, runner: "dev" },
+          dom: collected.dom, styles: collected.styles, boxes: collected.boxes, css: collected.css,
+        }),
+      });
+      const json = await res.json();
+      render(json.findings || [], json.error);
+    } catch (e) {
+      render([], "ultra11y dev server unreachable at " + ENDPOINT + " \u2014 run \`ultra11y dev\`.");
+    }
+  }
+
+  function slug(path) {
+    const s = path.normalize("NFD").replace(/[\\u0300-\\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+    return s || (path === "/" ? "accueil" : "page");
+  }
+
+  // Re-check on client-side navigation: patch the history methods a router uses, plus back/forward.
+  let timer;
+  const schedule = () => { clearTimeout(timer); timer = setTimeout(check, 400); };
+  for (const m of ["pushState", "replaceState"]) {
+    const orig = history[m];
+    history[m] = function () { const r = orig.apply(this, arguments); schedule(); return r; };
+  }
+  addEventListener("popstate", schedule);
+  schedule();
+})();`;
+}
+function nextOverlayComponent(port) {
+  return `"use client";
+// ultra11y dev overlay for Next.js. Generated by \`ultra11y dev --next\`.
+//
+//   // app/layout.tsx
+//   import { Ultra11yOverlay } from "../.ultra11y/next/overlay";
+//   \u2026
+//   <body>{children}<Ultra11yOverlay /></body>
+//
+// Renders NOTHING in production: the whole component short-circuits on NODE_ENV, so shipping
+// it is inert. Start the side-car with \`ultra11y dev\` for it to have anything to talk to.
+import { useEffect } from "react";
+
+export function Ultra11yOverlay({ endpoint = "http://127.0.0.1:${port}" }) {
+  useEffect(() => {
+    if (process.env.NODE_ENV !== "development") return;
+    if (document.getElementById("__ultra11y_overlay_script")) return;
+    window.__ULTRA11Y_ENDPOINT__ = endpoint;
+    const s = document.createElement("script");
+    s.id = "__ultra11y_overlay_script";
+    s.src = endpoint + "/overlay.js";
+    document.body.appendChild(s);
+  }, [endpoint]);
+  return null;
+}
+
+export default Ultra11yOverlay;
+`;
+}
+var MARK2 = { C: "C", NC: "NC", NA: "\u2014", manual: "?" };
+var CLASS = { C: "c", NC: "nc", NA: "na", manual: "m" };
+function esc2(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function dashboardHtml(result, pages, standard, lang) {
+  const fr = lang === "fr";
+  const stdLabel = isCore(standard) ? "WCAG 2.2 AA" : loadPack(standard).name;
+  const head = `<!doctype html><html lang="${fr ? "fr" : "en"}"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>ultra11y \u2014 ${esc2(stdLabel)}</title>
+<style>
+ :root { color-scheme: light dark; --bg:#fff; --fg:#111; --line:#e3e3e6; --mut:#666; }
+ @media (prefers-color-scheme: dark) { :root { --bg:#141416; --fg:#f2f2f7; --line:#2c2c2e; --mut:#a1a1a6; } }
+ body { margin:0; padding:24px; background:var(--bg); color:var(--fg); font:14px/1.5 ui-sans-serif,system-ui,sans-serif; }
+ h1 { font-size:18px; margin:0 0 4px; } p.sub { color:var(--mut); margin:0 0 20px; }
+ table { border-collapse:collapse; width:100%; } th,td { padding:5px 8px; border-bottom:1px solid var(--line); text-align:left; }
+ th { position:sticky; top:0; background:var(--bg); }
+ td.c,td.nc,td.na,td.m { text-align:center; font-weight:600; width:80px; }
+ td.c{color:#0a7d33} td.nc{color:#b3261e} td.na{color:var(--mut)} td.m{color:#b06000}
+ tr.theme td { font-weight:700; background:color-mix(in srgb, var(--fg) 6%, transparent); }
+ .rate { font-size:22px; font-weight:700; }
+ .empty { color:var(--mut); max-width:60ch; }
+ code { font:12px ui-monospace,monospace; color:var(--mut); }
+</style></head><body>`;
+  if (!result || !pages.length) {
+    return `${head}<h1>ultra11y</h1>
+<p class="empty">${fr ? "Aucune page captur\xE9e pour l'instant. Ouvrez votre application avec l'overlay actif : chaque page visit\xE9e appara\xEEtra ici." : "No page captured yet. Open your app with the overlay active: every page you visit shows up here."}</p></body></html>`;
+  }
+  const rows = [];
+  const status = /* @__PURE__ */ new Map();
+  if (isCore(standard)) {
+    for (const c2 of result.criteria) rows.push({ id: c2.id, label: c2.id, group: c2.guideline });
+    for (const p of pages) for (const c2 of p.criteria) (status.get(c2.id) ?? status.set(c2.id, /* @__PURE__ */ new Map()).get(c2.id)).set(p.id, c2.status);
+  } else {
+    const pack = loadPack(standard);
+    for (const pc of pack.criteria) rows.push({ id: pc.id, label: pc.id, group: `${pc.theme}. ${themeName(pack, pc.theme, lang) ?? ""}` });
+    for (const p of pages) {
+      const view = { ...result, criteria: p.criteria, findings: p.findings };
+      for (const pc of derivePackResults(view, standard)) (status.get(pc.id) ?? status.set(pc.id, /* @__PURE__ */ new Map()).get(pc.id)).set(p.id, pc.status);
+    }
+  }
+  const out2 = [head];
+  out2.push(`<h1>ultra11y \u2014 ${esc2(stdLabel)}</h1>`);
+  out2.push(`<p class="sub">${pages.length} ${fr ? "page(s) captur\xE9e(s)" : "page(s) captured"} \xB7 <code>${esc2(result.date)}</code></p>`);
+  out2.push("<table><thead><tr><th></th>");
+  for (const p of pages) out2.push(`<th>${esc2(p.name)}${p.auth ? " \u{1F512}" : ""}<br><code>${esc2(p.url)}</code></th>`);
+  out2.push("</tr></thead><tbody>");
+  out2.push(`<tr><td>${fr ? "Taux" : "Rate"}</td>${pages.map((p) => `<td class="rate">${p.conformancePct}%</td>`).join("")}</tr>`);
+  let group = "";
+  for (const row of rows) {
+    if (row.group !== group) {
+      group = row.group;
+      out2.push(`<tr class="theme"><td colspan="${pages.length + 1}">${esc2(group)}</td></tr>`);
+    }
+    const cells = pages.map((p) => {
+      const s = status.get(row.id)?.get(p.id) ?? "manual";
+      return `<td class="${CLASS[s]}">${MARK2[s]}</td>`;
+    });
+    out2.push(`<tr><td>${esc2(row.label)}</td>${cells.join("")}</tr>`);
+  }
+  out2.push("</tbody></table></body></html>");
+  return out2.join("\n");
+}
+function cors(res) {
+  res.setHeader("access-control-allow-origin", "*");
+  res.setHeader("access-control-allow-headers", "content-type");
+  res.setHeader("access-control-allow-methods", "POST, GET, OPTIONS");
+}
+async function readBody(req, limit = 64 * 1024 * 1024) {
+  const chunks = [];
+  let size = 0;
+  for await (const c2 of req) {
+    const buf = c2;
+    size += buf.length;
+    if (size > limit) throw new Error("payload too large");
+    chunks.push(buf);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function auditCollected(root, payload) {
+  const v = validateSnapshotMeta(payload.meta);
+  if (!v.ok || !v.meta) return { ok: false, error: v.issues.map((i2) => `${i2.path}: ${i2.message}`).join("; ") };
+  if (typeof payload.dom !== "string" || !payload.dom.trim()) return { ok: false, error: "dom is required" };
+  const dir = writeSnapshot(root, {
+    meta: v.meta,
+    dom: payload.dom,
+    ...payload.styles ? { styles: payload.styles } : {},
+    ...payload.boxes ? { boxes: payload.boxes } : {},
+    ...payload.axtree ? { axtree: payload.axtree } : {},
+    ...payload.css ? { css: payload.css } : {}
+  });
+  return { ok: true, result: runAudit({ inputs: [join32(dir, "dom.html")] }) };
+}
+function projectPages(root) {
+  const snaps = readSnapshots(root);
+  if (!snaps.length) return { result: null, pages: [] };
+  const scope = pageScopesFrom(snaps);
+  const result = runAudit({ inputs: [join32(root, ".ultra11y/pages")] });
+  result.scope.pages = scope;
+  attributePages(result, scope);
+  return { result, pages: derivePages(result, scope) };
+}
+function startDevServer(opts) {
+  const log = opts.onLog ?? (() => {
+  });
+  const server = createServer((req, res) => {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    cors(res);
+    if (req.method === "OPTIONS") {
+      res.writeHead(204).end();
+      return;
+    }
+    if (url.pathname === "/overlay.js") {
+      res.writeHead(200, { "content-type": "application/javascript; charset=utf-8", "cache-control": "no-store" }).end(overlayJs());
+      return;
+    }
+    if (url.pathname === "/snapshot" && req.method === "POST") {
+      void (async () => {
+        try {
+          const body2 = await readBody(req);
+          const payload = JSON.parse(body2);
+          const r = auditCollected(opts.root, payload);
+          if (!r.ok) {
+            res.writeHead(400, { "content-type": "application/json" }).end(JSON.stringify({ error: r.error }));
+            return;
+          }
+          const nc = r.result.findings.filter((f) => !f.advisory);
+          const name2 = payload.meta?.name ?? "page";
+          log(opts.lang === "fr" ? `ultra11y dev : ${name2} \u2014 ${nc.length} non-conformit\xE9(s)` : `ultra11y dev: ${name2} \u2014 ${nc.length} non-conformity(ies)`);
+          for (const f of nc.slice(0, 20)) {
+            const where = f.origin?.sourceFile ?? f.file;
+            log(
+              `  ${f.severity} ${criterionLabel3(f, opts.standard)} \xB7 ${where}:${Math.max(1, f.origin?.sourceLine ?? f.line)} \u2014 ${resolveMessage(f, opts.lang)}`
+            );
+          }
+          res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ findings: r.result.findings }));
+        } catch (e) {
+          res.writeHead(400, { "content-type": "application/json" }).end(JSON.stringify({ error: e instanceof Error ? e.message : String(e) }));
+        }
+      })();
+      return;
+    }
+    if (url.pathname === "/" || url.pathname === "/index.html") {
+      const { result, pages } = projectPages(opts.root);
+      res.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" }).end(dashboardHtml(result, pages, opts.standard, opts.lang));
+      return;
+    }
+    res.writeHead(404, { "content-type": "text/plain" }).end("not found");
+  });
+  return new Promise((resolve10, reject) => {
+    server.once("error", reject);
+    server.listen(opts.port, "127.0.0.1", () => {
+      resolve10({
+        port: server.address().port,
+        close: () => new Promise((r) => server.close(() => r()))
+      });
+    });
+  });
+}
+
+// src/e2e.ts
+function detectE2eRunner(deps, has2) {
+  const dep = (n) => Object.hasOwn(deps, n);
+  const out2 = [];
+  if (dep("@playwright/test") || dep("playwright") || ["ts", "js", "mjs", "cjs"].some((e) => has2(`playwright.config.${e}`))) out2.push("playwright");
+  if (dep("cypress") || ["ts", "js", "mjs", "cjs"].some((e) => has2(`cypress.config.${e}`))) out2.push("cypress");
+  return out2;
+}
+function runnerCore(enginePath) {
+  return `import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+
+// Engine resolution, in order: the ULTRA11Y env override (same convention as the git hook),
+// then the path baked in when \`render --e2e\` generated this file.
+const ENGINE = process.env.ULTRA11Y || ${JSON.stringify(enginePath)};
+
+/** Persist a collected page as a snapshot and audit it. Returns the AuditResult. */
+export function auditSnapshot(payload) {
+  const res = spawnSync(process.execPath, [ENGINE, "snapshot", "write", "--json"], {
+    input: JSON.stringify(payload),
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024,
+  });
+  if (res.error) throw new Error("ultra11y: could not run the engine at " + ENGINE + " \u2014 " + res.error.message);
+  if (!res.stdout) throw new Error("ultra11y: the engine produced no output (exit " + res.status + ")\\n" + (res.stderr || ""));
+  try {
+    return JSON.parse(res.stdout);
+  } catch {
+    throw new Error("ultra11y: could not parse the engine output\\n" + res.stdout.slice(0, 500));
+  }
+}
+
+const RANK = { bloquant: 0, majeur: 1, mineur: 2 };
+const THRESHOLD = { blocking: 0, bloquant: 0, major: 1, majeur: 1, minor: 2, mineur: 2 };
+
+/** Findings at or above the threshold, ignoring non-normative recommendations. */
+export function failingFindings(result, failOn) {
+  const max = THRESHOLD[failOn];
+  if (max === undefined) throw new Error('ultra11y: failOn must be blocking|major|minor (got "' + failOn + '")');
+  return (result.findings || []).filter((f) => !f.advisory && RANK[f.severity] <= max);
+}
+
+export function formatFailure(pageName, failing) {
+  const lines = ["ultra11y: " + failing.length + " accessibility non-conformity(ies) on \\"" + pageName + "\\":"];
+  for (const f of failing.slice(0, 20)) {
+    lines.push("  [" + f.severity + "] " + f.ruleId + " (WCAG " + f.criteriaId + ") \u2014 " + (f.origin && f.origin.sourceFile ? f.origin.sourceFile : f.file) + " \u2014 " + f.message);
+  }
+  if (failing.length > 20) lines.push("  \u2026 and " + (failing.length - 20) + " more.");
+  lines.push("Full detail: .ultra11y/pages/ \u2014 re-audit offline with \`ultra11y audit\`.");
+  return lines.join("\\n");
+}
+`;
+}
+function playwrightFixture(enginePath) {
+  return `// ultra11y \u2014 Playwright integration. Generated by \`ultra11y render --e2e\`.
+//
+//   import { test, checkA11y } from "../.ultra11y/e2e/playwright.mjs";
+//
+//   test("home page is accessible", async ({ page, ultra11y }) => {
+//     await page.goto("/");
+//     await ultra11y({ as: "accueil" });          // via the fixture
+//   });
+//
+//   // \u2026or without the fixture:
+//   await checkA11y(page, { as: "accueil", failOn: "blocking" });
+//
+// Each checked page is persisted to .ultra11y/pages/<id>/ (DOM + computed styles + boxes),
+// so the SAME page can be re-audited later, offline, with no browser \u2014 that is what lets CI
+// and the RGAA report speak page by page. Commit the snapshots to gate on them.
+//
+// Options: { as?: string (page id), name?: string, failOn?: "blocking"|"major"|"minor"|false,
+//            auth?: boolean, sources?: string[], notes?: string }
+// \`failOn: false\` records the snapshot without ever failing the test.
+${runnerCore(enginePath)}
+const COLLECT = ${JSON.stringify(COLLECT_SNAPSHOT)};
+
+export async function checkA11y(page, opts = {}) {
+  const collected = await page.evaluate(COLLECT);
+  // A VIEWPORT screenshot, deliberately \u2014 the boxes come from getBoundingClientRect, which is
+  // viewport-relative, so a full-page capture would put the two coordinate systems out of
+  // step. It feeds the pixel tier: contrast where the CSSOM cannot answer (text over an
+  // image or a gradient). \`screenshot: false\` skips it.
+  let shot;
+  if (opts.screenshot !== false) {
+    try {
+      shot = (await page.screenshot({ fullPage: false })).toString("base64");
+    } catch {
+      // A screenshot failure must never fail the accessibility check itself.
+    }
+  }
+  const url = collected.url || page.url();
+  const id = opts.as || slugify(url);
+  const payload = {
+    meta: {
+      v: 1,
+      id: id,
+      name: opts.name || collected.title || id,
+      url: url,
+      runner: "playwright",
+      viewport: collected.viewport,
+      capturedAt: new Date().toISOString(),
+      ...(opts.auth !== undefined ? { auth: opts.auth } : {}),
+      ...(opts.sources ? { sources: opts.sources } : {}),
+      ...(opts.notes ? { notes: opts.notes } : {}),
+    },
+    dom: collected.dom,
+    styles: collected.styles,
+    boxes: collected.boxes,
+    css: collected.css,
+    ...(shot ? { screenshot: shot } : {}),
+  };
+  const result = auditSnapshot(payload);
+  const failOn = opts.failOn === undefined ? "blocking" : opts.failOn;
+  if (failOn !== false) {
+    const failing = failingFindings(result, failOn);
+    if (failing.length) throw new Error(formatFailure(payload.meta.name, failing));
+  }
+  return result;
+}
+
+// Same slug rule as the engine (src/snapshot.ts slugifyPageId): accent-folded URL path.
+function slugify(url) {
+  let path = url;
+  try {
+    path = new URL(url).pathname;
+  } catch {}
+  const slug = path.normalize("NFD").replace(/[\\u0300-\\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || (path === "/" || path === "" ? "accueil" : "page");
+}
+
+// Optional fixture form. Import \`test\` from here instead of @playwright/test.
+// Playwright is resolved through createRequire (this file is ESM, so \`require\` does not
+// exist) and lazily, so the module still loads in a project that has not installed it.
+export const test = (() => {
+  try {
+    const base = createRequire(import.meta.url)("@playwright/test").test;
+    return base.extend({
+      ultra11y: async ({ page }, use) => {
+        await use((opts) => checkA11y(page, opts));
+      },
+    });
+  } catch {
+    return undefined;
+  }
+})();
+`;
+}
+function cypressPlugin(enginePath) {
+  return `// ultra11y \u2014 Cypress plugin (Node side). Generated by \`ultra11y render --e2e\`.
+//
+//   // cypress.config.js
+//   import ultra11y from "./.ultra11y/e2e/cypress-plugin.mjs";
+//   export default defineConfig({ e2e: { setupNodeEvents(on, config) { ultra11y(on); return config; } } });
+//
+// Cypress test code runs in the BROWSER and cannot write to disk, so the collected page
+// round-trips through this task. The browser half is cypress-commands.mjs.
+${runnerCore(enginePath)}
+export default function register(on) {
+  on("task", {
+    ultra11ySnapshot(payload) {
+      const result = auditSnapshot(payload);
+      const failOn = payload.failOn === undefined ? "blocking" : payload.failOn;
+      const failing = failOn === false ? [] : failingFindings(result, failOn);
+      // Return rather than throw: the browser half raises the assertion, so the failure is
+      // attributed to the test rather than to the plugin.
+      return { findings: result.findings || [], failing: failing, message: failing.length ? formatFailure(payload.meta.name, failing) : "" };
+    },
+  });
+}
+`;
+}
+function cypressCommands() {
+  return `// ultra11y \u2014 Cypress command (browser side). Generated by \`ultra11y render --e2e\`.
+//
+//   // cypress/support/e2e.js  (the supportFile)
+//   import "../../.ultra11y/e2e/cypress-commands.mjs";
+//
+//   cy.visit("/");
+//   cy.ultra11y({ as: "accueil" });
+//
+// Options: { as?, name?, failOn?: "blocking"|"major"|"minor"|false, auth?, sources?, notes? }
+const COLLECT = ${JSON.stringify(COLLECT_SNAPSHOT)};
+
+Cypress.Commands.add("ultra11y", (opts = {}) => {
+  cy.window({ log: false }).then((win) => {
+    // eslint-disable-next-line no-eval
+    const collected = win.eval(COLLECT);
+    const url = collected.url || win.location.href;
+    const id = opts.as || slugify(url);
+    const payload = {
+      meta: {
+        v: 1,
+        id: id,
+        name: opts.name || collected.title || id,
+        url: url,
+        runner: "cypress",
+        viewport: collected.viewport,
+        capturedAt: new Date().toISOString(),
+        ...(opts.auth !== undefined ? { auth: opts.auth } : {}),
+        ...(opts.sources ? { sources: opts.sources } : {}),
+        ...(opts.notes ? { notes: opts.notes } : {}),
+      },
+      dom: collected.dom,
+      styles: collected.styles,
+      boxes: collected.boxes,
+      css: collected.css,
+      failOn: opts.failOn,
+    };
+    return cy.task("ultra11ySnapshot", payload, { log: false }).then((res) => {
+      if (res && res.failing && res.failing.length) throw new Error(res.message);
+      return res;
+    });
+  });
+});
+
+function slugify(url) {
+  let path = url;
+  try {
+    path = new URL(url).pathname;
+  } catch (e) {}
+  const slug = path.normalize("NFD").replace(/[\\u0300-\\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || (path === "/" || path === "" ? "accueil" : "page");
+}
+`;
+}
+function e2eSetupPlan(runners, paths, lang = "en") {
+  const fr = lang === "fr";
+  const out2 = [];
+  if (!runners.length) {
+    out2.push(
+      fr ? "Aucun runner E2E d\xE9tect\xE9 (ni Playwright, ni Cypress). Installez-en un, ou forcez l'\xE9criture avec --runner playwright|cypress." : "No E2E runner detected (neither Playwright nor Cypress). Install one, or force the files with --runner playwright|cypress."
+    );
+    return out2.join("\n");
+  }
+  if (paths.playwright) {
+    out2.push(fr ? `Fixture Playwright \xE9crite : ${paths.playwright}` : `Playwright fixture written: ${paths.playwright}`);
+    out2.push("");
+    out2.push(fr ? "Dans un test :" : "In a test:");
+    out2.push(`  import { test, checkA11y } from "${paths.playwright}";`);
+    out2.push(`  await page.goto("/");`);
+    out2.push(`  await checkA11y(page, { as: "accueil" });`);
+    out2.push("");
+  }
+  if (paths.cypressPlugin) {
+    out2.push(fr ? `Plugin Cypress \xE9crit : ${paths.cypressPlugin}` : `Cypress plugin written: ${paths.cypressPlugin}`);
+    if (paths.cypressCommands) out2.push(fr ? `Commande Cypress \xE9crite : ${paths.cypressCommands}` : `Cypress command written: ${paths.cypressCommands}`);
+    out2.push("");
+    out2.push(fr ? "Dans cypress.config.js (setupNodeEvents) :" : "In cypress.config.js (setupNodeEvents):");
+    out2.push(`  import ultra11y from "./${paths.cypressPlugin}";`);
+    out2.push(`  setupNodeEvents(on, config) { ultra11y(on); return config; }`);
+    out2.push(fr ? "Puis dans le supportFile :" : "Then in the supportFile:");
+    out2.push(`  import "${paths.cypressCommands ? `../../${paths.cypressCommands}` : ""}";`);
+    out2.push(fr ? "Dans un test : cy.visit('/'); cy.ultra11y({ as: 'accueil' });" : "In a test: cy.visit('/'); cy.ultra11y({ as: 'accueil' });");
+    out2.push("");
+  }
+  out2.push(
+    fr ? "Chaque page v\xE9rifi\xE9e est enregistr\xE9e dans .ultra11y/pages/<id>/ \u2014 committez-la pour auditer la vraie page hors ligne (CI, rapport page par page)." : "Every checked page is recorded in .ultra11y/pages/<id>/ \u2014 commit it to audit the real page offline (CI, per-page report)."
+  );
+  return out2.join("\n");
+}
+
 // src/config.ts
-import { existsSync as existsSync17, statSync as statSync9 } from "fs";
-import { join as join31, isAbsolute as isAbsolute2 } from "path";
+import { existsSync as existsSync18, statSync as statSync9 } from "fs";
+import { join as join33, isAbsolute as isAbsolute2 } from "path";
 
 // src/pack.ts
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 function exampleParses(ex) {
   for (const code2 of [ex.bad, ex.good]) {
     if (!code2) continue;
@@ -49456,7 +51666,7 @@ function checkGuidance(ds, pack) {
 function runPackCheck(packPath, guidancePath) {
   const errors = [];
   const warnings = [];
-  if (!existsSync16(packPath)) return { ok: false, errors: [`pack file not found: ${packPath}`], warnings };
+  if (!existsSync17(packPath)) return { ok: false, errors: [`pack file not found: ${packPath}`], warnings };
   let raw;
   try {
     raw = JSON.parse(readText(packPath));
@@ -49480,7 +51690,7 @@ function runPackCheck(packPath, guidancePath) {
     }
   }
   if (v.ok && v.pack && guidancePath) {
-    if (!existsSync16(guidancePath)) {
+    if (!existsSync17(guidancePath)) {
       errors.push(`guidance file not found: ${guidancePath}`);
     } else {
       let gRaw;
@@ -49534,8 +51744,8 @@ function packScaffold() {
 // src/config.ts
 var CONFIG_FILE = ".ultra11yrc.json";
 function loadConfig(cwd) {
-  const p = join31(cwd, CONFIG_FILE);
-  if (!existsSync17(p)) return null;
+  const p = join33(cwd, CONFIG_FILE);
+  if (!existsSync18(p)) return null;
   let parsed;
   try {
     parsed = JSON.parse(readText(p));
@@ -49548,16 +51758,16 @@ function loadConfig(cwd) {
   return parsed;
 }
 function packPaths(path) {
-  if (!existsSync17(path)) return null;
+  if (!existsSync18(path)) return null;
   if (statSync9(path).isDirectory()) {
-    const pack = join31(path, "pack.json");
-    if (!existsSync17(pack)) return null;
-    const glossary = join31(path, "glossary.json");
-    const guidance = join31(path, "guidance.json");
+    const pack = join33(path, "pack.json");
+    if (!existsSync18(pack)) return null;
+    const glossary = join33(path, "glossary.json");
+    const guidance = join33(path, "guidance.json");
     return {
       pack,
-      glossary: existsSync17(glossary) ? glossary : void 0,
-      guidance: existsSync17(guidance) ? guidance : void 0
+      glossary: existsSync18(glossary) ? glossary : void 0,
+      guidance: existsSync18(guidance) ? guidance : void 0
     };
   }
   return { pack: path };
@@ -49573,7 +51783,7 @@ function loadRuntimeStandards(cwd, packFlags, onWarn, override = false) {
   }
   result.defaultStandard = config?.standard;
   for (const raw of [...config?.packs ?? [], ...packFlags]) {
-    const paths = packPaths(isAbsolute2(raw) ? raw : join31(cwd, raw));
+    const paths = packPaths(isAbsolute2(raw) ? raw : join33(cwd, raw));
     if (!paths) {
       result.errors.push(`--pack ${raw}: not found (expected a pack JSON file or a directory with pack.json)`);
       continue;
@@ -49603,7 +51813,7 @@ ${formatIssues(v.issues).join("\n")}`);
     result.loadedPacks.push(v.pack.key);
     if (paths.guidance) loadGuidanceFile(paths.guidance, result, onWarn);
   }
-  for (const g of config?.guidance ?? []) loadGuidanceFile(isAbsolute2(g) ? g : join31(cwd, g), result, onWarn);
+  for (const g of config?.guidance ?? []) loadGuidanceFile(isAbsolute2(g) ? g : join33(cwd, g), result, onWarn);
   for (const sm of config?.secondaryMappings ?? []) {
     if (!sm || typeof sm.standard !== "string" || typeof sm.ruleId !== "string" || typeof sm.criterion !== "string") {
       result.errors.push("secondaryMappings: each entry must be { standard, ruleId, criterion, note? }");
@@ -49618,7 +51828,7 @@ ${formatIssues(v.issues).join("\n")}`);
   return result;
 }
 function loadGuidanceFile(path, result, onWarn) {
-  if (!existsSync17(path)) {
+  if (!existsSync18(path)) {
     onWarn(`ultra11y: guidance ${path} not found \u2014 skipping.`);
     return;
   }
@@ -49656,11 +51866,11 @@ ${g.errors.map((e) => `  \u2717 ${e}`).join("\n")}`);
 }
 
 // src/orchestrate.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync14, rmSync as rmSync4, writeFileSync as writeFileSync12 } from "fs";
-import { join as join33, resolve as resolve7 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync16, rmSync as rmSync4, writeFileSync as writeFileSync13 } from "fs";
+import { join as join35, resolve as resolve7 } from "path";
 
 // src/orchestrate-templates.ts
-import { join as join32 } from "path";
+import { join as join34 } from "path";
 var ONE_WRITER_FOOTER = `
 ## Return, don't write
 
@@ -49685,14 +51895,21 @@ var ADJUDICATE_SCHEMA = {
             description: "REQUIRED (>=1, groundable) for NC",
             items: {
               type: "object",
-              required: ["file", "line", "message"],
+              // `normativeRef` is REQUIRED by the fold (src/adjudicate.ts): an NC with none is
+              // rejected. Omitting it here made every fan-out adjudication produce NC verdicts
+              // that `verify --apply` then refused.
+              required: ["file", "line", "message", "normativeRef"],
               properties: {
                 file: { type: "string" },
                 line: { type: "integer" },
                 selector: { type: "string" },
                 message: { type: "string" },
                 snippet: { type: "string" },
-                severity: { enum: ["bloquant", "majeur", "mineur"] }
+                severity: { enum: ["bloquant", "majeur", "mineur"] },
+                normativeRef: {
+                  type: "string",
+                  description: "The precise failed test of the ACTIVE standard. WCAG core: a success-criterion id (e.g. '1.1.1'). Country standard: a test OF THIS ITEM'S OWN CRITERION (e.g. '11.2.1' on item 11.2) \u2014 a WCAG id looks alike but denotes an unrelated test and is rejected."
+                }
               }
             }
           }
@@ -49725,7 +51942,7 @@ var PHASE_SPECS = {
     title: "Adjudicate",
     schema: ADJUDICATE_SCHEMA,
     description: (n) => `Adjudicate the ${n} residual judgment criterion(ia) of an ultra11y audit (fan-out, fail-closed fold)`,
-    applyHint: (engine, worklist, run2) => `node ${engine} verify --apply ${worklist} --in ${join32(run2, "audit-latest.json")} --out ${run2}`
+    applyHint: (engine, worklist, run2) => `node ${engine} verify --apply ${worklist} --in ${join34(run2, "audit-latest.json")} --out ${run2}`
   },
   "verify-report": {
     role: "refuter",
@@ -49747,7 +51964,7 @@ function toBatches(ids, batchSize) {
 }
 function phaseWorkflowScript(ph, runAbs, engineAbs, batchSize) {
   const spec = phaseSpec(ph.name);
-  const scriptPath = join32(runAbs, "orchestration", `${ph.name}.workflow.mjs`);
+  const scriptPath = join34(runAbs, "orchestration", `${ph.name}.workflow.mjs`);
   const meta2 = { name: `ultra11y-${ph.name}`, description: spec.description(ph.items), phases: [{ title: spec.title }] };
   return [
     `export const meta = ${JSON.stringify(meta2)}`,
@@ -49789,27 +52006,27 @@ function agentContracts(runAbs, engineAbs) {
   return {
     adjudicator: `# Contract: adjudicator
 
-You adjudicate residual judgment criteria of an ultra11y WCAG audit \u2014 the success criteria the deterministic engine could not decide (alt-text relevance, link purpose in context, reading order\u2026).
+You adjudicate the residual judgment criteria of an ultra11y audit \u2014 the ones the deterministic engine could not decide (alt-text relevance, link purpose in context, reading order\u2026). The ACTIVE STANDARD is recorded in the worklist's \`standard\` field: under a country standard (e.g. \`rgaa\`) the items are that standard's OWN criteria, each carrying its numbered tests \u2014 not WCAG success criteria.
 
-Worklist: \`${join32(runAbs, "ADJUDICATE.todo.json")}\` (an object with \`kind: "adjudication"\` and \`items[]\`). Handle ONLY the criteria whose \`criteriaId\` is named in your prompt (\`ITEMS=<id,\u2026>\`).
+Worklist: \`${join34(runAbs, "ADJUDICATE.todo.json")}\` (an object with \`kind: "adjudication"\` and \`items[]\`). Handle ONLY the criteria whose \`criteriaId\` is named in your prompt (\`ITEMS=<id,\u2026>\`).
 
 For EACH of your criteria:
 
 1. Read its worklist entry. \`evidence[]\` holds source-anchored excerpts (\`file\`, \`line\`, \`selector\`, \`snippet\`) harvested from the audited code \u2014 open the cited files at the cited lines whenever the snippet alone cannot decide.
 2. Rule it (the apply gate is FAIL-CLOSED \u2014 a verdict missing its required field does not fold):
    - \`C\` (conforming) \u2014 REQUIRES \`justification\` explaining why the evidence satisfies the criterion.
-   - \`NC\` (non-conforming) \u2014 REQUIRES \`findings\`: at least one groundable \`{ file, line, selector?, message, snippet?, severity? }\` pointing at REAL source. The fold re-grounds every finding; an invented file:line is rejected.
+   - \`NC\` (non-conforming) \u2014 REQUIRES \`findings\`: at least one groundable \`{ file, line, selector?, message, snippet?, severity?, normativeRef }\` pointing at REAL source. The fold re-grounds every finding; an invented file:line is rejected. \`normativeRef\` MUST cite the precise failed test \u2014 under a country standard, one of the item's OWN tests, which the worklist lists for you under \xAB tests to rule on \xBB.
    - \`NA\` (not applicable) \u2014 REQUIRES \`justification\`.
    - \`manual\` (still undecidable) \u2014 REQUIRES \`reason\`: \`needs-rendered-dom\` (only a rendered DOM can decide, e.g. computed contrast) or \`undecidable\` (the evidence cannot settle it either way).
 3. Never guess. A criterion you cannot decide from real evidence stays \`manual\` with a reason \u2014 that is a valid, honest verdict; the scan tier or a human picks it up.
 
-Return (structured output): \`{ "verdicts": [{ "criteriaId", "verdict", "justification", "reason", "findings" }] }\` \u2014 your ITEMS only, every field grounded in what you actually read.
+Return (structured output): \`{ "verdicts": [{ "criteriaId", "verdict", "justification", "reason", "findings" }] }\` \u2014 your ITEMS only, every field grounded in what you actually read, every NC finding carrying its \`normativeRef\`.
 ${footer}`,
     refuter: `# Contract: refuter
 
 You are an adversarial skeptic verifying the non-conformities of an ultra11y report. Your job is to try to REFUTE each claim: assume it is wrong until the source proves it.
 
-Worklist: \`${join32(runAbs, "VERIFY.todo.json")}\` (a JSON array; each entry has \`n\`, \`criteriaId\`, \`file\`, \`line\`, \`selector\`, \`claim\`). Handle ONLY the entries whose \`n\` is named in your prompt (\`ITEMS=<n,\u2026>\`).
+Worklist: \`${join34(runAbs, "VERIFY.todo.json")}\` (a JSON array; each entry has \`n\`, \`criteriaId\`, \`file\`, \`line\`, \`selector\`, \`claim\`). Handle ONLY the entries whose \`n\` is named in your prompt (\`ITEMS=<n,\u2026>\`).
 
 For EACH of your entries:
 
@@ -49845,14 +52062,14 @@ ${status}
 
 ## The loop (play every role yourself, one item at a time)
 
-1. **Audit** (if not done): \`${engine} audit "<globs>" --graph --out ${runAbs}\` \u2192 \`${join32(runAbs, "audit-latest.json")}\`.
-2. **Adjudicate the residual criteria** \u2014 \`${engine} verify --manual --in ${join32(runAbs, "audit-latest.json")} --out ${runAbs}\` writes \`${join32(runAbs, "ADJUDICATE.todo.json")}\`. For EVERY item, apply \`${join32(runAbs, "orchestration", "agents", "adjudicator.md")}\` yourself (read the evidence, rule C/NC/NA/manual, fill the required justification/findings/reason IN the todo file). Then fold, fail-closed: \`${engine} verify --apply ${join32(runAbs, "ADJUDICATE.todo.json")} --in ${join32(runAbs, "audit-latest.json")} --out ${runAbs}\`.
-3. **Report**: \`${engine} report --in ${join32(runAbs, "audit-latest.json")} --out ${runAbs}\`.
-4. **Verify the report's claims** \u2014 \`${engine} verify --report <the report .md> --out ${runAbs}\` writes \`${join32(runAbs, "VERIFY.todo.json")}\`. For EVERY entry, apply \`${join32(runAbs, "orchestration", "agents", "refuter.md")}\` yourself (open file:line, verdict supported/partial/refuted/unsupported + note IN the todo file). Then: \`${engine} verify --apply ${join32(runAbs, "VERIFY.todo.json")} --report <the report .md>\`.
+1. **Audit** (if not done): \`${engine} audit "<globs>" --graph --out ${runAbs}\` \u2192 \`${join34(runAbs, "audit-latest.json")}\`.
+2. **Adjudicate the residual criteria** \u2014 \`${engine} verify --manual --in ${join34(runAbs, "audit-latest.json")} --out ${runAbs}\` writes \`${join34(runAbs, "ADJUDICATE.todo.json")}\`. For EVERY item, apply \`${join34(runAbs, "orchestration", "agents", "adjudicator.md")}\` yourself (read the evidence, rule C/NC/NA/manual, fill the required justification/findings/reason IN the todo file). Then fold, fail-closed: \`${engine} verify --apply ${join34(runAbs, "ADJUDICATE.todo.json")} --in ${join34(runAbs, "audit-latest.json")} --out ${runAbs}\`.
+3. **Report**: \`${engine} report --in ${join34(runAbs, "audit-latest.json")} --out ${runAbs}\`.
+4. **Verify the report's claims** \u2014 \`${engine} verify --report <the report .md> --out ${runAbs}\` writes \`${join34(runAbs, "VERIFY.todo.json")}\`. For EVERY entry, apply \`${join34(runAbs, "orchestration", "agents", "refuter.md")}\` yourself (open file:line, verdict supported/partial/refuted/unsupported + note IN the todo file). Then: \`${engine} verify --apply ${join34(runAbs, "VERIFY.todo.json")} --report <the report .md>\`.
 5. **Gate**: \`${engine} check --report <the report .md> --semantic\` must exit 0 before presenting anything.
 6. **Fix & re-audit**: \`${engine} fix <globs> --write --iterate\`, hand-apply the judgment fixes, then loop from step 1 until the gate stays green.
 
-With subagents available, prefer the emitted workflows instead: \`orchestrate --run ${runAbs} --phase <p>\` then \`Workflow({ scriptPath: "${join32(runAbs, "orchestration", "<p>.workflow.mjs")}" })\` \u2014 you stay the sole writer either way.
+With subagents available, prefer the emitted workflows instead: \`orchestrate --run ${runAbs} --phase <p>\` then \`Workflow({ scriptPath: "${join34(runAbs, "orchestration", "<p>.workflow.mjs")}" })\` \u2014 you stay the sole writer either way.
 `;
 }
 
@@ -49862,12 +52079,12 @@ var SMALL_WORKLIST = 3;
 var BATCH_SIZE = 8;
 function listPhases(runDir, engineAbs) {
   const run2 = resolve7(runDir);
-  const adjPath = join33(run2, "ADJUDICATE.todo.json");
+  const adjPath = join35(run2, "ADJUDICATE.todo.json");
   let adjIds = [];
   let adjReady = false;
-  if (existsSync18(adjPath)) {
+  if (existsSync19(adjPath)) {
     try {
-      const f = JSON.parse(readFileSync14(adjPath, "utf8"));
+      const f = JSON.parse(readFileSync16(adjPath, "utf8"));
       if (f && f.kind === "adjudication" && Array.isArray(f.items)) {
         adjReady = true;
         adjIds = f.items.map((i2) => i2.criteriaId);
@@ -49875,12 +52092,12 @@ function listPhases(runDir, engineAbs) {
     } catch {
     }
   }
-  const verPath = join33(run2, "VERIFY.todo.json");
+  const verPath = join35(run2, "VERIFY.todo.json");
   let verIds = [];
   let verReady = false;
-  if (existsSync18(verPath)) {
+  if (existsSync19(verPath)) {
     try {
-      const items = JSON.parse(readFileSync14(verPath, "utf8"));
+      const items = JSON.parse(readFileSync16(verPath, "utf8"));
       if (Array.isArray(items)) {
         verReady = true;
         verIds = items.map((i2) => String(i2.n));
@@ -49895,7 +52112,7 @@ function listPhases(runDir, engineAbs) {
       worklist: adjPath,
       items: adjIds.length,
       ids: adjIds,
-      prerequisite: `node ${engineAbs} verify --manual --in ${join33(run2, "audit-latest.json")} --out ${run2}`
+      prerequisite: `node ${engineAbs} verify --manual --in ${join35(run2, "audit-latest.json")} --out ${run2}`
     },
     {
       name: "verify-report",
@@ -49909,7 +52126,7 @@ function listPhases(runDir, engineAbs) {
 }
 function orchestrateRun(runDir, engineAbs, opts = {}) {
   const run2 = resolve7(runDir);
-  if (!existsSync18(run2)) {
+  if (!existsSync19(run2)) {
     return { exitCode: 2, written: [], notices: [], errors: [`run dir not found: ${run2}`], phases: [] };
   }
   const phases = listPhases(run2, engineAbs);
@@ -49936,22 +52153,22 @@ function orchestrateRun(runDir, engineAbs, opts = {}) {
     }
     selected = [ph];
   }
-  const orchDir = join33(run2, "orchestration");
-  const agentsDir = join33(orchDir, "agents");
-  mkdirSync9(join33(orchDir, "out"), { recursive: true });
-  mkdirSync9(agentsDir, { recursive: true });
+  const orchDir = join35(run2, "orchestration");
+  const agentsDir = join35(orchDir, "agents");
+  mkdirSync10(join35(orchDir, "out"), { recursive: true });
+  mkdirSync10(agentsDir, { recursive: true });
   const written = [];
   const notices = [];
   for (const [name2, content] of Object.entries(agentContracts(run2, engineAbs))) {
-    const p = join33(agentsDir, `${name2}.md`);
-    writeFileSync12(p, content);
+    const p = join35(agentsDir, `${name2}.md`);
+    writeFileSync13(p, content);
     written.push(p);
   }
   const emitted = new Set(opts.eco ? [] : selected.filter((p) => p.items > 0).map((p) => p.name));
   for (const ph of phases) {
     if (emitted.has(ph.name)) continue;
-    const stale = join33(orchDir, `${ph.name}.workflow.mjs`);
-    if (existsSync18(stale)) {
+    const stale = join35(orchDir, `${ph.name}.workflow.mjs`);
+    if (existsSync19(stale)) {
       rmSync4(stale, { force: true });
       notices.push(`phase "${ph.name}": stale workflow removed \u2014 its worklist ${ph.ready ? "is now empty" : "no longer exists"}.`);
     }
@@ -49965,13 +52182,13 @@ function orchestrateRun(runDir, engineAbs, opts = {}) {
       if (ph.items <= SMALL_WORKLIST) {
         notices.push(`phase "${ph.name}": only ${ph.items} item(s) \u2014 the sequential --eco path is equivalent and cheaper.`);
       }
-      const p = join33(orchDir, `${ph.name}.workflow.mjs`);
-      writeFileSync12(p, phaseWorkflowScript(ph, run2, engineAbs, BATCH_SIZE));
+      const p = join35(orchDir, `${ph.name}.workflow.mjs`);
+      writeFileSync13(p, phaseWorkflowScript(ph, run2, engineAbs, BATCH_SIZE));
       written.push(p);
     }
   }
-  const rb = join33(orchDir, "RUNBOOK.md");
-  writeFileSync12(rb, runbookMd(phases, run2, engineAbs));
+  const rb = join35(orchDir, "RUNBOOK.md");
+  writeFileSync13(rb, runbookMd(phases, run2, engineAbs));
   written.push(rb);
   return { exitCode: 0, written, notices, errors: [], phases };
 }
@@ -49980,8 +52197,8 @@ function orchestrateRun(runDir, engineAbs, opts = {}) {
 import { createInterface as createInterface2 } from "readline";
 
 // src/mcp/handlers.ts
-import { existsSync as existsSync19, readFileSync as readFileSync15, realpathSync as realpathSync2, statSync as statSync10 } from "fs";
-import { isAbsolute as isAbsolute3, join as join34, resolve as resolve8, sep as sep4 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync17, realpathSync as realpathSync2, statSync as statSync10 } from "fs";
+import { isAbsolute as isAbsolute3, join as join36, resolve as resolve8, sep as sep4 } from "path";
 
 // src/project-lock.ts
 var chains = /* @__PURE__ */ new Map();
@@ -50029,7 +52246,7 @@ function requiredCwd(args2, defaults) {
   const cwd = str2(args2.cwd) ?? defaults.defaultCwd;
   if (!cwd) throw new ToolError("`cwd` is required: an absolute path to the project root.");
   const abs = resolve8(cwd);
-  if (!existsSync19(abs)) throw new ToolError(`project root not found: ${abs}`);
+  if (!existsSync20(abs)) throw new ToolError(`project root not found: ${abs}`);
   if (!statSync10(abs).isDirectory()) throw new ToolError(`\`cwd\` is not a directory: ${abs}`);
   return abs;
 }
@@ -50174,13 +52391,13 @@ function handlePackCheck(args2, cwd) {
   return { cwd, ...res };
 }
 function handleSampleCheck(cwd) {
-  const file = join34(cwd, ".ultra11yrc.json");
-  if (!existsSync19(file)) {
+  const file = join36(cwd, ".ultra11yrc.json");
+  if (!existsSync20(file)) {
     throw new ToolError(`no .ultra11yrc.json at ${cwd} \u2014 a page sample must be declared before it can be linted.`);
   }
   let raw;
   try {
-    raw = JSON.parse(readFileSync15(file, "utf8"));
+    raw = JSON.parse(readFileSync17(file, "utf8"));
   } catch (e) {
     throw new ToolError(`.ultra11yrc.json is not valid JSON: ${e.message}`);
   }
@@ -50218,7 +52435,7 @@ function handleInit(args2, cwd) {
   const enginePath = resolve8("scripts/ultra11y.mjs");
   const written = [];
   if (bool(args2.hook)) written.push(writeHook(cwd, enginePath, failOn));
-  if (bool(args2.ci)) written.push(join34(cwd, ".github/workflows/a11y.yml"));
+  if (bool(args2.ci)) written.push(join36(cwd, ".github/workflows/a11y.yml"));
   if (!written.length) {
     throw new ToolError("nothing to install \u2014 pass hook:true and/or ci:true.");
   }
@@ -50238,8 +52455,8 @@ function reportText(args2, tool) {
   if (inline) return inline;
   if (!file) throw new ToolError(`\`report_text\` is required \u2014 the report markdown for ultra11y_${tool} to work on.`);
   if (!isAbsolute3(file)) throw new ToolError("`report_file` must be an absolute path.");
-  if (!existsSync19(file)) throw new ToolError(`report file not found: ${file}`);
-  return readFileSync15(file, "utf8");
+  if (!existsSync20(file)) throw new ToolError(`report file not found: ${file}`);
+  return readFileSync17(file, "utf8");
 }
 function handleCriteria(args2) {
   const lang = langOf(args2);
@@ -50254,7 +52471,7 @@ function handleCriteria(args2) {
 function handleRead(args2, cwd) {
   const raw = str2(args2.path);
   if (!raw) throw new ToolError("`path` is required \u2014 relative to the project root, or an absolute path inside it.");
-  const target = isAbsolute3(raw) ? raw : join34(cwd, raw);
+  const target = isAbsolute3(raw) ? raw : join36(cwd, raw);
   let real;
   try {
     real = realpathSync2(target);
@@ -50268,7 +52485,7 @@ function handleRead(args2, cwd) {
   const st = statSync10(real);
   if (!st.isFile()) throw new ToolError(`not a file: ${raw}`);
   if (st.size > MAX_READ_BYTES) throw new ToolError(`file is too large to read (${st.size} bytes): ${raw}`);
-  const lines = readFileSync15(real, "utf8").split("\n");
+  const lines = readFileSync17(real, "utf8").split("\n");
   const total = lines.length;
   const start2 = Math.max(1, Math.floor(num2(args2.start_line) ?? 1));
   if (start2 > total) throw new ToolError(`start_line ${start2} is past the end of the file (${total} lines).`);
@@ -50763,25 +52980,25 @@ function str3(v) {
 var DECLARED = new Set([...TOOLS2, ...WRITE_TOOLS].map((t2) => t2.name));
 
 // src/mcp/resources.ts
-import { existsSync as existsSync20, readdirSync as readdirSync5, readFileSync as readFileSync16, realpathSync as realpathSync3, statSync as statSync11 } from "fs";
-import { basename as basename3, dirname as dirname9, join as join35, resolve as resolve9, sep as sep5 } from "path";
+import { existsSync as existsSync21, readdirSync as readdirSync6, readFileSync as readFileSync18, realpathSync as realpathSync3, statSync as statSync11 } from "fs";
+import { basename as basename3, dirname as dirname10, join as join37, resolve as resolve9, sep as sep5 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var SKILL_NAME = "ultra11y";
 var URI_SCHEME = "skill://";
 function resolveSkillRoot(moduleDir) {
-  const here = moduleDir ?? dirname9(fileURLToPath4(import.meta.url));
+  const here = moduleDir ?? dirname10(fileURLToPath4(import.meta.url));
   const candidates2 = [resolve9(here, ".."), resolve9(here, "..", "skills", SKILL_NAME), resolve9(here, "..", "..", "skills", SKILL_NAME)];
-  return candidates2.find((dir) => existsSync20(join35(dir, "SKILL.md")));
+  return candidates2.find((dir) => existsSync21(join37(dir, "SKILL.md")));
 }
 function listResources(moduleDir) {
   const root = resolveSkillRoot(moduleDir);
   if (!root) return [];
   const out2 = [describe(root, "SKILL.md", `${SKILL_NAME}: the skill`)];
-  const refDir = join35(root, "references");
-  if (!existsSync20(refDir)) return out2;
-  for (const file of readdirSync5(refDir).sort()) {
+  const refDir = join37(root, "references");
+  if (!existsSync21(refDir)) return out2;
+  for (const file of readdirSync6(refDir).sort()) {
     if (!file.endsWith(".md")) continue;
-    out2.push(describe(root, join35("references", file), `${SKILL_NAME} reference: ${basename3(file, ".md")}`));
+    out2.push(describe(root, join37("references", file), `${SKILL_NAME} reference: ${basename3(file, ".md")}`));
   }
   return out2;
 }
@@ -50805,7 +53022,7 @@ function readResource(uri, moduleDir) {
     throw new ResourceError(`resource path escapes the skill root: ${uri}`);
   }
   if (!statSync11(targetReal).isFile()) throw new ResourceError(`not a file: ${uri}`);
-  return { uri, mimeType: "text/markdown", text: readFileSync16(targetReal, "utf8") };
+  return { uri, mimeType: "text/markdown", text: readFileSync18(targetReal, "utf8") };
 }
 var ResourceError = class extends Error {
 };
@@ -50816,14 +53033,14 @@ function describe(root, rel, fallbackTitle) {
     title: fallbackTitle,
     mimeType: "text/markdown"
   };
-  const summary = firstProse(join35(root, rel));
+  const summary = firstProse(join37(root, rel));
   if (summary) decl.description = summary;
   return decl;
 }
 function firstProse(file) {
   let text;
   try {
-    text = readFileSync16(file, "utf8");
+    text = readFileSync18(file, "utf8");
   } catch {
     return void 0;
   }
@@ -50842,7 +53059,7 @@ var ERR_INVALID_REQUEST = -32600;
 var ERR_METHOD_NOT_FOUND = -32601;
 var ERR_INVALID_PARAMS = -32602;
 var ERR_INTERNAL = -32603;
-function createServer(opts = {}) {
+function createServer2(opts = {}) {
   const serverInfo = { name: opts.serverName ?? "ultra11y", version: VERSION };
   const maxBytes = opts.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES2;
   let protocol = LATEST_PROTOCOL2;
@@ -50993,7 +53210,7 @@ async function runStdioServer(opts = {}) {
       process.stdout.write = original;
     };
   }
-  const server = createServer(opts);
+  const server = createServer2(opts);
   const send = (msg) => {
     emit2(JSON.stringify(msg) + "\n");
   };
@@ -51142,7 +53359,7 @@ async function route(req, res, opts) {
   const protocol = declared ?? ASSUMED_HTTP_PROTOCOL;
   let raw;
   try {
-    raw = await readBody(req);
+    raw = await readBody2(req);
   } catch (e) {
     if (e.message === "too large") {
       sendJson(res, 413, { error: `request body exceeds ${MAX_BODY_BYTES} bytes` }, origin);
@@ -51158,7 +53375,7 @@ async function route(req, res, opts) {
     sendJson(res, 200, { jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } }, origin);
     return;
   }
-  const mcp = createServer(opts);
+  const mcp = createServer2(opts);
   mcp.setProtocolVersion(protocol);
   const out2 = [];
   const collect2 = (m) => void out2.push(m);
@@ -51189,7 +53406,7 @@ function sendJson(res, status, body2, origin, extra = {}) {
   res.end(text);
 }
 var DRAIN_LIMIT = MAX_BODY_BYTES * 8;
-function readBody(req) {
+function readBody2(req) {
   return new Promise((resolve10, reject) => {
     const chunks = [];
     let size = 0;
@@ -51232,11 +53449,13 @@ non-conformities. RGAA (France) and other country standards are pluggable packs
 Usage:
   ultra11y audit    <globs\u2026 | -> [--out <dir>] [--include <glob>] [--exclude <glob>] [--ext <list>] [--jsx] [--graph] [--json] [--lang auto|en|fr] [--no-default-excludes]
   ultra11y audit    [--changed | --since <ref> | --staged] [--max-files <n>] [--dedup exact|normalized|off] [--baseline <file>] [--fail-on blocking|major|minor]
-  ultra11y audit    [--captures <dir>] [--no-captures] [--require-captures]   (rendered-DOM captures: audit real HTML, gate blind-spot components)
-  ultra11y report   --in <audit.json> [--out <dir>] [--standard <pack>] [--lang auto|en|fr]
+  ultra11y audit    [--captures <dir>] [--no-captures] [--require-captures]   (rendered-DOM captures + .ultra11y/pages snapshots: audit real HTML)
+  ultra11y audit    [--format sarif|github]        (CI: SARIF for code scanning, or inline annotations + job summary)
+  ultra11y report   --in <audit.json> [--out <dir>] [--standard <pack>] [--format sarif|github] [--lang auto|en|fr]
   ultra11y prd      --in <audit.json> [--out <dir>] [--split criterion] [--format audit|doc|remediation] [--no-technical] [--standard <pack>] [--gh-issues | --gh-single] [--lang auto|en|fr]
-  ultra11y render   [<dir>] [--scaffold | --setup | --coverage | --storybook] [--captures <dir>] [--out <file>] [--json] [--lang auto|en|fr]
+  ultra11y render   [<dir>] [--scaffold | --setup | --e2e | --coverage | --storybook] [--runner playwright|cypress|auto] [--captures <dir>] [--out <file>] [--json] [--lang auto|en|fr]
   ultra11y criteria [<sc>] [--list] [--standard <pack> [--theme <N>]] [--generate] [--json] [--lang auto|en|fr]
+  ultra11y criteria --standard <pack> --glossary [<term>]   (the terms the standard DEFINES \u2014 its tests depend on them)
   ultra11y check    --report <md> [--standard <pack>] [--in <audit.json>] [--semantic [--verdicts <file>]] [--quiet] [--json]
   ultra11y verify   --report <md> [--standard <pack>] [--semantic] [--apply <verdicts.json>] [--max-verify <n>] [--out <dir>] [--json]
   ultra11y verify   --report <md> --in <audit.json> --manual [--out <dir>] [--json]   (adjudicate the manual criteria)
@@ -51250,6 +53469,12 @@ Usage:
   ultra11y scan     --sitemap <url> | --crawl <url> [--depth <n>] [--max <n>] [--runtime \u2026] [--cwd <dir>] [--merge <audit.json>] [--json]
   ultra11y scan     --clean        (remove the dynamic-tier Docker image + temp contexts)
   ultra11y sample   check [--standard <pack>] [--json]   (lint the .ultra11yrc.json page sample vs the standard's required page kinds)
+  ultra11y snapshot write [--root <dir>] [--fail-on blocking|major|minor] [--json]   (payload on stdin \u2192 .ultra11y/pages/<id>/ + audit it)
+  ultra11y snapshot list  [--root <dir>] [--json]
+  ultra11y pages    --in <audit.json> [--standard <pack>] [--json] [--lang auto|en|fr]   (the per-page criterion grid)
+  ultra11y mcp      [--transport stdio|http] [--cwd <dir>] [--allow-write] [--port <n>] [--bind <addr>] [--allow-remote] [--allow-origin <o>] [--max-response-bytes <n>]
+  ultra11y dev      [--port <n>] [--root <dir>] [--standard <pack>] [--lang auto|en|fr]   (dev side-car: live overlay + per-page dashboard)
+  ultra11y dev      --next [--port <n>]        (write the Next overlay component, then wire one line into your layout)
 
 Commands:
   audit      Run the static engine over the inputs (files/globs, or '-' for stdin)
@@ -51258,12 +53483,19 @@ Commands:
              (default auto: repo <html lang> \u2192 the active standard's default locale
              \u2192 English). The engine decides the machine-detectable criteria; the AI
              agent adjudicates the judgment ones (verify --manual, gated) and the
-             scan tier decides the needs-rendering ones.
+             scan tier decides the needs-rendering ones. --format sarif|github emits
+             the CI rendering instead of the summary (in --baseline gate mode it
+             covers exactly the NEW findings, i.e. what the PR introduced).
   report     Render an AuditResult into a dated WCAG 2.2 AA compliance report
              (audits/wcag-YYYY-MM-DD.md): metadata, per-guideline synthesis table,
              non-conformities by priority, conforming + not-applicable lists.
              --standard <pack> writes a derived report for a country standard
              (e.g. --standard rgaa \u2192 audits/rgaa-YYYY-MM-DD.md).
+             --format renders the same result for CI instead of Markdown: 'sarif'
+             (SARIF 2.1.0 for GitHub code scanning, so findings land as inline PR
+             annotations) or 'github' (::error:: workflow commands on stdout plus a
+             job summary appended to $GITHUB_STEP_SUMMARY). Both honour --standard,
+             so this is how you get an RGAA-keyed SARIF \u2014 audit itself is WCAG-keyed.
   prd        Turn an AuditResult into an AUDITOR conformance backlog
              (audits/prd-YYYY-MM-DD.md), one entry per criterion rendered with the
              active standard's vocabulary (RGAA "Th\xE9matique/Crit\xE8re/Test", WCAG core
@@ -51278,7 +53510,12 @@ Commands:
              react-dom/server SSR snapshot harness to fill in. --setup installs the
              zero-touch test-render capture harvester (one setupFiles line \u2192 every
              component your tests render is snapshotted to .ultra11y/captures and
-             audited). --coverage reports which components have a rendered capture vs
+             audited). --setup captures COMPONENTS from unit tests; --e2e wires the
+             audit into an existing Playwright/Cypress run instead, so a targeted PAGE
+             is checked during the tests you already have \u2014 each checked page is
+             persisted to .ultra11y/pages/<id>/ (DOM + computed styles + boxes) and can
+             be re-audited later, offline, with no browser.
+             --coverage reports which components have a rendered capture vs
              which are still opaque-source-only blind spots. --storybook attributes
              per-story HTML (via a storybook-static index) back to source components.
              Then audit the produced HTML, and use scan for the needs-rendering criteria.
@@ -51286,6 +53523,12 @@ Commands:
              (criteria 1.4.3) or the full list grouped by guideline (--list).
              --standard <pack>: a pack criterion, a pack theme (--theme N), or its
              theme list. Carries the WCAG\u2194pack cross-refs + automatability class.
+             --glossary [<term>] looks up a term the standard DEFINES (RGAA ships
+             119). These definitions are normative \u2014 what "if necessary" or
+             "relevant" mean in a test is decided there \u2014 and the adjudication
+             worklist now inlines the ones each criterion's own tests cite. With no
+             term, lists them all. Resolves by anchor or title, accent-insensitive;
+             an unknown term errors with suggestions rather than a near-miss.
   check      Integrity gate on a produced report: every cited criterion resolves,
              every NA is justified, sections + pass-rate maths are well-formed.
              --standard tells it which id grammar/registry to validate against.
@@ -51348,6 +53591,38 @@ Commands:
              page kinds (RGAA: accueil, contact, mentions l\xE9gales, d\xE9claration
              d'accessibilit\xE9, plan du site, aide, authentification, pages
              repr\xE9sentatives + \xE9l\xE9ments transverses) \u2014 advisory, never a gate.
+  snapshot   Persist a rendered PAGE (.ultra11y/pages/<id>/: documentElement DOM +
+             computed-style digest + boxes + a11y tree) and audit it. 'snapshot write'
+             reads the collected payload on stdin, so a browser-side producer (the
+             render --e2e fixtures, the dev overlay) needs to know nothing about the
+             on-disk format \u2014 one process per checked page. 'snapshot list' shows what
+             has been captured. Because a snapshot is a FULL document (a component
+             capture is a fragment), the page-scoped rules run on it: that is where
+             html lang (RGAA 8.3) and page title (8.5/8.6) become decidable.
+  dev        Development side-car: see the defects on the page you are BUILDING,
+             while you build it. It serves a per-page dashboard on
+             http://127.0.0.1:4111 and an overlay the app loads; every page you
+             visit is snapshotted, audited and listed in a floating panel, each
+             finding linking to its file:line (Next's launch-editor endpoint).
+             --next writes the overlay component to wire into your layout \u2014 it
+             renders NOTHING outside development. LOOPBACK ONLY: the server
+             writes files, so it never binds beyond 127.0.0.1.
+  mcp        Serve the engine over the Model Context Protocol, so an MCP client
+             (Claude Code, an IDE) drives audit/report/criteria as tools instead of
+             shelling out. --transport stdio (default) speaks over stdin/stdout;
+             --transport http listens on 127.0.0.1 (--port, --bind), and stays
+             loopback-only unless you pass --allow-remote. Read-only by default:
+             --allow-write opts into the commands that touch files.
+  pages      The per-page criterion grid \u2014 RGAA is a per-page norm, the engine's
+             verdict is scope-wide, and this bridges the two. One row per criterion
+             (the pack's own under --standard), one column per page. Rebuilt from a
+             committed audit.json alone: no snapshots on disk, no browser.
+             Two honesty rules: a finding is attributed to a page only when something
+             SAYS so (the snapshot it was raised on, the scanned URL, the sample page
+             name, or the page's recorded source files) \u2014 anything else is reported as
+             UNATTRIBUTED, never spread across pages; and "no finding here" means
+             conforming only for a page whose real rendered DOM was audited. A page
+             known only by source attribution keeps its undecided criteria "to assess".
 
 Options:
   --out <dir>        output dir (report/prd/scan default: audits); for audit, persist
@@ -51390,7 +53665,19 @@ Options:
   --coverage         render: report rendered-capture coverage (covered vs blind-spot components); with --json emits the coverage object
   --storybook        render: attribute per-story HTML (via storybook-static index.json) into .ultra11y/captures (point the HTML dir with --captures)
   --captures <dir>   audit/render: rendered-capture dir to ingest (default: .ultra11y/captures)
-  --no-captures      audit: do NOT auto-detect/ingest the .ultra11y/captures dir
+  --no-captures      audit: do NOT auto-detect/ingest .ultra11y/captures nor .ultra11y/pages
+  --e2e              render: write the Playwright/Cypress fixtures into .ultra11y/e2e/
+  --runner <name>    render --e2e: force playwright|cypress instead of auto-detecting
+  --root <dir>       snapshot: project root holding .ultra11y/pages (default: .)
+  --port <n>         dev: port for the side-car (default: 4111); mcp: HTTP transport port
+  --transport <k>    mcp: stdio (default) or http
+  --bind <addr>      mcp --transport http: address to bind (default 127.0.0.1)
+  --allow-remote     mcp --transport http: accept non-loopback connections (off by default)
+  --allow-origin <o> mcp --transport http: an Origin allowed to call the server
+  --max-response-bytes <n>  mcp: cap a tool response's size
+  --allow-write      mcp: allow the tools that write files (read-only otherwise)
+  --glossary [<t>]   criteria: look up a term the country standard defines (or list all)
+  --next             dev: write the Next.js overlay component instead of serving
   --require-captures audit: gate \u2014 fail if any opaque/control component lacks a rendered capture (implies --graph)
   --write            fix: apply fixes to disk (default is a dry-run diff)
   --iterate          fix: with --write, re-audit + re-apply mechanical fixes until stable (bounded)
@@ -51462,7 +53749,25 @@ Options:
   -v, --version      print version
 
 Data: WCAG 2.2 \xA9 W3C (W3C Document License). RGAA 4.1.2 pack \xA9 DINUM, Licence Ouverte / Etalab 2.0 (see NOTICE).`;
-var COMMANDS = ["audit", "report", "prd", "render", "criteria", "check", "verify", "scan", "sample", "fix", "init", "pack", "orchestrate", "mcp"];
+var COMMANDS = [
+  "audit",
+  "report",
+  "prd",
+  "render",
+  "criteria",
+  "check",
+  "verify",
+  "scan",
+  "sample",
+  "snapshot",
+  "pages",
+  "dev",
+  "mcp",
+  "fix",
+  "init",
+  "pack",
+  "orchestrate"
+];
 function isCommand(s) {
   return !!s && COMMANDS.includes(s);
 }
@@ -51500,10 +53805,14 @@ var VALUE_FLAGS2 = /* @__PURE__ */ new Set([
   "captures",
   "run",
   "phase",
+  "root",
+  "runner",
+  // Shared by `dev` (side-car port) and `mcp` (HTTP transport port) — one entry, both users.
+  "port",
+  "glossary",
   // `mcp` only. The flag sets are global, so these are accepted (and warned
   // about, never silently ignored) on every command — like --phase already is.
   "transport",
-  "port",
   "bind",
   "allow-origin",
   "max-response-bytes"
@@ -51526,6 +53835,8 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "scaffold",
   "storybook",
   "setup",
+  "e2e",
+  "next",
   "coverage",
   "write",
   "dry-run",
@@ -51632,6 +53943,36 @@ function peekMergeAudit(mergeIn) {
     return void 0;
   }
 }
+function parseCiFormat(v) {
+  if (v === void 0) return void 0;
+  if (v === "sarif") return "sarif";
+  if (v === "github") return "github";
+  return null;
+}
+function emitCiFormat(result, format, standard, lang, failOn) {
+  if (format === "sarif") {
+    console.log(JSON.stringify(toSarif(result, { standard, lang }), null, 2));
+    return;
+  }
+  for (const line of annotations(result, { standard, lang, failOn })) console.log(line);
+  const summaryPath = process.env.GITHUB_STEP_SUMMARY;
+  const md = stepSummary(result, { standard, lang });
+  if (summaryPath) {
+    try {
+      appendFileSync(summaryPath, `${md}
+`);
+    } catch {
+    }
+  } else {
+    console.error(md);
+  }
+  if (process.env.ULTRA11Y_PR_COMMENT === "1") {
+    const c2 = pushPrComment(md, standard);
+    console.error(
+      c2.ok ? lang === "fr" ? `ultra11y : commentaire de PR ${c2.action === "updated" ? "mis \xE0 jour" : c2.action === "created" ? "cr\xE9\xE9" : "ignor\xE9"}${c2.reason ? ` (${c2.reason})` : ""}.` : `ultra11y: PR comment ${c2.action}${c2.reason ? ` (${c2.reason})` : ""}.` : lang === "fr" ? `ultra11y : commentaire de PR impossible${c2.reason ? ` \u2014 ${c2.reason}` : ""}.` : `ultra11y: PR comment failed${c2.reason ? ` \u2014 ${c2.reason}` : ""}.`
+    );
+  }
+}
 async function cmdAudit(p) {
   const inputs = p.positionals.length ? p.positionals : ["."];
   if (inputs.length === 0) {
@@ -51646,13 +53987,19 @@ async function cmdAudit(p) {
   const capturesFlag = typeof p.flags.captures === "string" && p.flags.captures ? p.flags.captures : void 0;
   const capturesDir = capturesFlag ?? ".ultra11y/captures";
   const scopedToDiff = p.flags.changed === true || p.flags.staged === true || since !== void 0;
-  const capturesWanted = p.flags["no-captures"] !== true && !inputs.includes("-") && (capturesFlag !== void 0 || existsSync21(capturesDir));
+  const capturesWanted = p.flags["no-captures"] !== true && !inputs.includes("-") && (capturesFlag !== void 0 || existsSync22(capturesDir));
   const useCaptures = capturesWanted && !scopedToDiff && !inputs.includes(capturesDir);
-  const auditInputs = useCaptures ? [...inputs, capturesDir] : inputs;
+  const pagesWanted = p.flags["no-captures"] !== true && !inputs.includes("-") && existsSync22(PAGES_DIR);
+  const usePages = pagesWanted && !scopedToDiff && !inputs.includes(PAGES_DIR);
+  const auditInputs = [...inputs, ...useCaptures ? [capturesDir] : [], ...usePages ? [PAGES_DIR] : []];
   if (useCaptures)
     console.error(
       lang === "fr" ? `ultra11y audit : captures rendues ing\xE9r\xE9es depuis ${capturesDir}.` : `ultra11y audit: ingesting rendered captures from ${capturesDir}.`
     );
+  if (usePages)
+    console.error(
+      lang === "fr" ? `ultra11y audit : instantan\xE9s de page ing\xE9r\xE9s depuis ${PAGES_DIR}.` : `ultra11y audit: ingesting page snapshots from ${PAGES_DIR}.`
+    );
   const result = runAudit({
     inputs: auditInputs,
     stdin,
@@ -51673,13 +54020,20 @@ async function cmdAudit(p) {
     onWarn: (m) => console.error(m)
   });
   lang = resolveLang(p.flags, { audit: result });
+  if (usePages) {
+    const scope = pageScopesFrom(readSnapshots("."));
+    if (scope.length) {
+      result.scope.pages = scope;
+      attributePages(result, scope);
+    }
+  }
   if (typeof p.flags.out === "string") {
     const out2 = p.flags.out;
     const asFile = out2.toLowerCase().endsWith(".json");
-    const target = asFile ? out2 : join36(out2, "audit-latest.json");
+    const target = asFile ? out2 : join38(out2, "audit-latest.json");
     try {
-      mkdirSync10(asFile ? dirname10(out2) : out2, { recursive: true });
-      writeFileSync13(target, JSON.stringify(result, null, 2) + "\n");
+      mkdirSync11(asFile ? dirname11(out2) : out2, { recursive: true });
+      writeFileSync14(target, JSON.stringify(result, null, 2) + "\n");
       console.error(lang === "fr" ? `\u2192 audit \xE9crit dans ${target}` : `\u2192 audit written to ${target}`);
     } catch {
     }
@@ -51690,10 +54044,15 @@ async function cmdAudit(p) {
     console.error(`ultra11y audit: --fail-on must be blocking|major|minor (got "${String(failOnRaw)}").`);
     return 2;
   }
+  const ciFormat = parseCiFormat(p.flags.format);
+  if (ciFormat === null) {
+    console.error(`ultra11y audit: --format must be sarif|github (got "${String(p.flags.format)}").`);
+    return 2;
+  }
   const baselineFlag = p.flags.baseline;
   if (typeof baselineFlag === "string" && baselineFlag) {
     let baseline = null;
-    if (existsSync21(baselineFlag)) {
+    if (existsSync22(baselineFlag)) {
       try {
         const parsed = JSON.parse(readText(baselineFlag));
         if (isCurrentAudit(parsed)) baseline = parsed;
@@ -51707,7 +54066,8 @@ async function cmdAudit(p) {
     }
     const diff = diffAgainstBaseline(result, baseline, failOnParsed ?? "bloquant");
     const blindSpots2 = requireCaptures ? result.scope.captureCoverage?.blindSpots ?? [] : [];
-    if (p.flags.json)
+    if (ciFormat) emitCiFormat({ ...result, findings: diff.newFindings }, ciFormat, CORE2, lang, failOnParsed ?? "bloquant");
+    else if (p.flags.json)
       console.log(JSON.stringify(requireCaptures && result.scope.captureCoverage ? { ...diff, captureCoverage: result.scope.captureCoverage } : diff, null, 2));
     else {
       console.log(baselineSummary(diff, lang));
@@ -51719,7 +54079,8 @@ async function cmdAudit(p) {
   const failOn = failOnSet ? failOnParsed ?? "bloquant" : void 0;
   const failing = failOn ? findingsAtOrAbove(result.findings, failOn) : [];
   const blindSpots = requireCaptures ? result.scope.captureCoverage?.blindSpots ?? [] : [];
-  if (p.flags.json) console.log(JSON.stringify(result, null, 2));
+  if (ciFormat) emitCiFormat(result, ciFormat, CORE2, lang, failOn);
+  else if (p.flags.json) console.log(JSON.stringify(result, null, 2));
   else {
     console.log(auditSummary(result, lang));
     if (requireCaptures && result.scope.captureCoverage) console.error(captureCoverageSummary(result.scope.captureCoverage, lang));
@@ -51733,6 +54094,175 @@ async function cmdAudit(p) {
   if (!failOnSet && !requireCaptures) return 0;
   return failing.length || blindSpots.length ? 1 : 0;
 }
+async function cmdDev(p) {
+  const root = typeof p.flags.root === "string" && p.flags.root ? p.flags.root : ".";
+  const standard = stdOf(p, "dev");
+  if (standard === null) return 2;
+  const lang = resolveLang(p.flags, { standard });
+  const portRaw = p.flags.port;
+  const port = typeof portRaw === "string" ? Number.parseInt(portRaw, 10) : DEV_DEFAULT_PORT;
+  if (!Number.isFinite(port) || port < 0 || port > 65535) {
+    console.error(`ultra11y dev: --port must be a number between 0 and 65535 (got "${String(portRaw)}").`);
+    return 2;
+  }
+  if (p.flags.next === true) {
+    const dir = join38(root, ".ultra11y", "next");
+    const rel = ".ultra11y/next/overlay.jsx";
+    try {
+      mkdirSync11(dir, { recursive: true });
+      writeFileSync14(join38(dir, "overlay.jsx"), nextOverlayComponent(port));
+    } catch (e) {
+      console.error(`ultra11y dev: could not write ${rel}: ${e instanceof Error ? e.message : String(e)}`);
+      return 1;
+    }
+    const fr2 = lang === "fr";
+    console.log(fr2 ? `Composant overlay \xE9crit : ${rel}` : `Overlay component written: ${rel}`);
+    console.log("");
+    console.log(fr2 ? "Ajoutez-le \xE0 votre layout racine (app/layout.tsx) :" : "Add it to your root layout (app/layout.tsx):");
+    console.log(`  import { Ultra11yOverlay } from "../${rel.replace(/\.jsx$/, "")}";`);
+    console.log(`  <body>{children}<Ultra11yOverlay /></body>`);
+    console.log("");
+    console.log(
+      fr2 ? `Puis lancez le side-car : ultra11y dev  (tableau de bord : http://127.0.0.1:${port})` : `Then start the side-car: ultra11y dev  (dashboard: http://127.0.0.1:${port})`
+    );
+    console.log(fr2 ? "Le composant ne rend RIEN hors d\xE9veloppement." : "The component renders NOTHING outside development.");
+    return 0;
+  }
+  const fr = lang === "fr";
+  let server;
+  try {
+    server = await startDevServer({ root, port, standard, lang, onLog: (m) => console.error(m) });
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(
+      /EADDRINUSE/.test(msg) ? `ultra11y dev: port ${port} is already in use \u2014 pass --port <n>.` : `ultra11y dev: could not start the server: ${msg}`
+    );
+    return 1;
+  }
+  console.error(fr ? `ultra11y dev : tableau de bord sur http://127.0.0.1:${server.port}` : `ultra11y dev: dashboard on http://127.0.0.1:${server.port}`);
+  console.error(fr ? "Boucle locale uniquement (l'outil \xE9crit des fichiers). Ctrl-C pour arr\xEAter." : "Loopback only (the tool writes files). Ctrl-C to stop.");
+  await new Promise((resolve10) => {
+    const stop2 = () => {
+      void server.close().then(resolve10);
+    };
+    process.once("SIGINT", stop2);
+    process.once("SIGTERM", stop2);
+  });
+  return 0;
+}
+async function cmdPages(p) {
+  const inFlag = p.flags.in;
+  if (typeof inFlag !== "string" || !inFlag) {
+    console.error("ultra11y pages: --in <audit.json> is required ('-' for stdin).");
+    return 2;
+  }
+  const standard = stdOf(p, "pages");
+  if (standard === null) return 2;
+  const raw = inFlag === "-" ? await readStdin() : readInputFile(inFlag, "pages", "--in");
+  if (raw === null) return 2;
+  let result;
+  try {
+    result = JSON.parse(raw);
+  } catch {
+    console.error("ultra11y pages: --in is not valid JSON (expected an AuditResult).");
+    return 2;
+  }
+  if (!isCurrentAudit(result)) {
+    console.error("ultra11y pages: input is not a current ultra11y AuditResult (WCAG-keyed, schema v2). Re-run `audit`.");
+    return 2;
+  }
+  const lang = resolveLang(p.flags, { audit: result, standard });
+  const scope = pagesOf(result);
+  if (!scope.length) {
+    console.error(
+      lang === "fr" ? "ultra11y pages : aucune page dans le p\xE9rim\xE8tre. Capturez des instantan\xE9s (render --e2e) ou scannez un \xE9chantillon (scan --sample)." : "ultra11y pages: no page in scope. Capture snapshots (render --e2e) or scan a sample (scan --sample)."
+    );
+    return 1;
+  }
+  attributePages(result, scope);
+  if (p.flags.json) console.log(JSON.stringify({ pages: derivePages(result, scope), unattributed: unattributedFindings(result).length }, null, 2));
+  else console.log(renderPageGrid(result, scope, standard, lang));
+  return 0;
+}
+async function cmdSnapshot(p) {
+  const sub = p.positionals[0];
+  const root = typeof p.flags.root === "string" && p.flags.root ? p.flags.root : ".";
+  const lang = resolveLang(p.flags, {});
+  if (sub === "list") {
+    const snaps = readSnapshots(root);
+    if (p.flags.json)
+      console.log(
+        JSON.stringify(
+          snaps.map((s) => s.meta),
+          null,
+          2
+        )
+      );
+    else if (!snaps.length) console.log(lang === "fr" ? `Aucun instantan\xE9 dans ${join38(root, PAGES_DIR)}.` : `No snapshot in ${join38(root, PAGES_DIR)}.`);
+    else for (const s of snaps) console.log(`${s.meta.id}	${s.meta.name}	${s.meta.url}${s.meta.auth ? "	[auth]" : ""}`);
+    return 0;
+  }
+  if (sub !== "write") {
+    console.error("ultra11y snapshot: expected `snapshot write` (payload on stdin) or `snapshot list`.");
+    return 2;
+  }
+  const raw = await readStdin();
+  if (!raw.trim()) {
+    console.error("ultra11y snapshot write: no payload on stdin (expected {meta, dom, styles?, boxes?, axtree?}).");
+    return 2;
+  }
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch {
+    console.error("ultra11y snapshot write: stdin is not valid JSON.");
+    return 2;
+  }
+  const v = validateSnapshotMeta(payload.meta);
+  if (!v.ok || !v.meta) {
+    for (const i2 of v.issues) console.error(`ultra11y snapshot write: ${i2.path} \u2014 ${i2.message}`);
+    return 2;
+  }
+  if (typeof payload.dom !== "string" || !payload.dom.trim()) {
+    console.error("ultra11y snapshot write: `dom` must be the serialized documentElement.outerHTML.");
+    return 2;
+  }
+  let dir;
+  try {
+    dir = writeSnapshot(root, {
+      meta: v.meta,
+      dom: payload.dom,
+      ...payload.styles ? { styles: payload.styles } : {},
+      ...payload.boxes ? { boxes: payload.boxes } : {},
+      ...payload.axtree ? { axtree: payload.axtree } : {},
+      ...payload.css ? { css: payload.css } : {}
+    });
+  } catch (e) {
+    console.error(`ultra11y snapshot write: could not write the snapshot: ${e instanceof Error ? e.message : String(e)}`);
+    return 1;
+  }
+  if (typeof payload.screenshot === "string" && payload.screenshot) {
+    try {
+      writeFileSync14(join38(dir, "screen.png"), Buffer.from(payload.screenshot, "base64"));
+    } catch {
+      console.error("ultra11y snapshot write: the screenshot could not be written \u2014 the pixel tier will be skipped for this page.");
+    }
+  }
+  const result = runAudit({ inputs: [join38(dir, "dom.html")], onWarn: (m) => console.error(m) });
+  const failOnRaw = p.flags["fail-on"];
+  const failOnParsed = parseFailOn(failOnRaw);
+  if (failOnRaw !== void 0 && failOnParsed === null) {
+    console.error(`ultra11y snapshot write: --fail-on must be blocking|major|minor (got "${String(failOnRaw)}").`);
+    return 2;
+  }
+  const failing = failOnRaw !== void 0 ? findingsAtOrAbove(result.findings, failOnParsed ?? "bloquant").filter((f) => !f.advisory) : [];
+  if (p.flags.json) console.log(JSON.stringify(result, null, 2));
+  else {
+    console.log(lang === "fr" ? `\u2192 instantan\xE9 \xE9crit dans ${dir}` : `\u2192 snapshot written to ${dir}`);
+    console.log(auditSummary(result, lang));
+  }
+  return failing.length ? 1 : 0;
+}
 function cmdInit(p) {
   const root = repoRoot() ?? process.cwd();
   let engineRel = process.argv[1] ?? "scripts/ultra11y.mjs";
@@ -51755,9 +54285,9 @@ function cmdInit(p) {
   if (want.baseline) {
     const inputs = p.positionals.length ? p.positionals : ["."];
     const result = runAudit({ inputs, onWarn: (m) => console.error(m) });
-    mkdirSync10(join36(root, "audits"), { recursive: true });
-    const bp = join36(root, "audits", "baseline.json");
-    writeFileSync13(bp, JSON.stringify(result, null, 2) + "\n");
+    mkdirSync11(join38(root, "audits"), { recursive: true });
+    const bp = join38(root, "audits", "baseline.json");
+    writeFileSync14(bp, JSON.stringify(result, null, 2) + "\n");
     wrote.push(bp);
   }
   if (want.hook) wrote.push(writeHook(root, engineRel, failOn, legacy ? "baseline" : "staged"));
@@ -51781,7 +54311,8 @@ function cmdCriteria(p) {
     list: p.flags.list === true,
     json: p.flags.json === true,
     lang: resolveLang(p.flags, { standard }),
-    standard
+    standard,
+    ...p.flags.glossary !== void 0 ? { glossary: p.flags.glossary } : {}
   });
 }
 async function cmdReport(p) {
@@ -51807,6 +54338,15 @@ async function cmdReport(p) {
   }
   const out2 = typeof p.flags.out === "string" ? p.flags.out : "audits";
   const lang = resolveLang(p.flags, { audit: result, standard });
+  const ciFormat = parseCiFormat(p.flags.format);
+  if (ciFormat === null) {
+    console.error(`ultra11y report: --format must be sarif|github (got "${String(p.flags.format)}").`);
+    return 2;
+  }
+  if (ciFormat) {
+    emitCiFormat(result, ciFormat, standard, lang);
+    return 0;
+  }
   const path = writeReport(result, { out: out2, lang, standard });
   const untested = isCore(standard) ? [] : untestedNeedsRendering(result);
   const partial = untested.length > 0;
@@ -51883,13 +54423,67 @@ async function cmdPrd(p) {
   if (json) console.log(JSON.stringify({ paths, units: prdUnits(result, standard, lang), ...gh2 ? { gh: gh2 } : {} }, null, 2));
   return gh2 && gh2.failed > 0 ? 1 : 0;
 }
+function depsAt(root) {
+  const pkgPath = join38(root, "package.json");
+  if (!existsSync22(pkgPath)) return {};
+  try {
+    const pkg = JSON.parse(readText(pkgPath));
+    return { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+  } catch {
+    return {};
+  }
+}
+function engineRefFor(root) {
+  let ref = process.argv[1] ?? "scripts/ultra11y.mjs";
+  try {
+    const abs = realpathSync4(ref);
+    ref = abs.startsWith(root + sep6) ? relative3(root, abs) : abs;
+  } catch {
+  }
+  return ref;
+}
 function cmdRender(p) {
   const root = p.positionals[0] ?? ".";
   const lang = resolveLang(p.flags, {});
+  if (p.flags.e2e === true) {
+    const forced = typeof p.flags.runner === "string" ? p.flags.runner : void 0;
+    if (forced !== void 0 && forced !== "playwright" && forced !== "cypress" && forced !== "auto") {
+      console.error(`ultra11y render: --runner must be playwright|cypress|auto (got "${forced}").`);
+      return 2;
+    }
+    const detected = detectE2eRunner(depsAt(root), (f) => existsSync22(join38(root, f)));
+    const runners = forced && forced !== "auto" ? [forced] : detected;
+    if (!runners.length) {
+      console.error(e2eSetupPlan([], {}, lang));
+      return 1;
+    }
+    const engineRef = engineRefFor(root);
+    const dir = join38(root, ".ultra11y", "e2e");
+    const paths = {};
+    try {
+      mkdirSync11(dir, { recursive: true });
+      if (runners.includes("playwright")) {
+        writeFileSync14(join38(dir, "playwright.mjs"), playwrightFixture(engineRef));
+        paths.playwright = ".ultra11y/e2e/playwright.mjs";
+      }
+      if (runners.includes("cypress")) {
+        writeFileSync14(join38(dir, "cypress-plugin.mjs"), cypressPlugin(engineRef));
+        writeFileSync14(join38(dir, "cypress-commands.mjs"), cypressCommands());
+        paths.cypressPlugin = ".ultra11y/e2e/cypress-plugin.mjs";
+        paths.cypressCommands = ".ultra11y/e2e/cypress-commands.mjs";
+      }
+    } catch (e) {
+      console.error(`ultra11y render: could not write the E2E fixtures: ${e instanceof Error ? e.message : String(e)}`);
+      return 1;
+    }
+    if (p.flags.json) console.log(JSON.stringify({ runners, paths }, null, 2));
+    else console.log(e2eSetupPlan(runners, paths, lang));
+    return 0;
+  }
   if (p.flags.scaffold === true) {
     const out2 = typeof p.flags.out === "string" && p.flags.out ? p.flags.out : "ultra11y-render.tsx";
     try {
-      writeFileSync13(out2, ssrHarness());
+      writeFileSync14(out2, ssrHarness());
     } catch (e) {
       console.error(`ultra11y render: could not write ${out2}: ${e instanceof Error ? e.message : String(e)}`);
       return 1;
@@ -51903,29 +54497,29 @@ Fill in COMPONENTS, run it (e.g. npx tsx ${out2}), then: node scripts/ultra11y.m
   }
   if (p.flags.setup === true) {
     const rel = ".ultra11y/capture-setup.mjs";
-    const out2 = join36(root, rel);
+    const out2 = join38(root, rel);
     try {
-      mkdirSync10(dirname10(out2), { recursive: true });
-      writeFileSync13(out2, captureSetup());
+      mkdirSync11(dirname11(out2), { recursive: true });
+      writeFileSync14(out2, captureSetup());
     } catch (e) {
       console.error(`ultra11y render: could not write ${out2}: ${e instanceof Error ? e.message : String(e)}`);
       return 1;
     }
     let setupDeps = {};
-    const setupPkg = join36(root, "package.json");
-    if (existsSync21(setupPkg)) {
+    const setupPkg = join38(root, "package.json");
+    if (existsSync22(setupPkg)) {
       try {
         const pkg = JSON.parse(readText(setupPkg));
         setupDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
       } catch {
       }
     }
-    const tr = detectTestRunner(setupDeps, (f) => existsSync21(join36(root, f)));
+    const tr = detectTestRunner(setupDeps, (f) => existsSync22(join38(root, f)));
     console.log(captureSetupPlan(tr, rel, lang));
     const gaLine = ".ultra11y/captures/*.html text eol=lf linguist-generated=true";
-    const gaPath = join36(root, ".gitattributes");
+    const gaPath = join38(root, ".gitattributes");
     try {
-      const existing = existsSync21(gaPath) ? readFileSync17(gaPath, "utf8") : "";
+      const existing = existsSync22(gaPath) ? readFileSync19(gaPath, "utf8") : "";
       if (!existing.includes(".ultra11y/captures/")) {
         appendFileSync(gaPath, (existing && !existing.endsWith("\n") ? "\n" : "") + gaLine + "\n");
         console.log(lang === "fr" ? `.gitattributes : ajout\xE9 \xAB ${gaLine} \xBB` : `.gitattributes: added "${gaLine}"`);
@@ -51933,8 +54527,8 @@ Fill in COMPONENTS, run it (e.g. npx tsx ${out2}), then: node scripts/ultra11y.m
     } catch {
     }
     try {
-      const giPath = join36(root, ".gitignore");
-      if (existsSync21(giPath) && /^\s*\/?\.ultra11y(\/\**)?\/?\s*$/m.test(readFileSync17(giPath, "utf8")))
+      const giPath = join38(root, ".gitignore");
+      if (existsSync22(giPath) && /^\s*\/?\.ultra11y(\/\**)?\/?\s*$/m.test(readFileSync19(giPath, "utf8")))
         console.error(
           lang === "fr" ? "\u26A0\uFE0F .ultra11y semble ignor\xE9 par .gitignore \u2014 les captures doivent \xEAtre committ\xE9es pour le gate (ajoutez \xAB !.ultra11y/captures/ \xBB)." : '\u26A0\uFE0F .ultra11y appears gitignored \u2014 captures must be committed for the gate (add "!.ultra11y/captures/").'
         );
@@ -51944,8 +54538,8 @@ Fill in COMPONENTS, run it (e.g. npx tsx ${out2}), then: node scripts/ultra11y.m
   }
   if (p.flags.storybook === true || typeof p.flags.storybook === "string") {
     const sbDir = p.positionals[0] ?? "storybook-static";
-    const indexPath = existsSync21(join36(sbDir, "index.json")) ? join36(sbDir, "index.json") : join36(sbDir, "stories.json");
-    if (!existsSync21(indexPath)) {
+    const indexPath = existsSync22(join38(sbDir, "index.json")) ? join38(sbDir, "index.json") : join38(sbDir, "stories.json");
+    if (!existsSync22(indexPath)) {
       console.error(
         lang === "fr" ? `ultra11y render : aucun index Storybook (index.json/stories.json) dans ${sbDir}.` : `ultra11y render: no Storybook index (index.json/stories.json) in ${sbDir}.`
       );
@@ -51955,7 +54549,7 @@ Fill in COMPONENTS, run it (e.g. npx tsx ${out2}), then: node scripts/ultra11y.m
     const provById = new Map(stories.map((s) => [s.id, storyProvenance(s)]));
     const capturesFlag = typeof p.flags.captures === "string" && p.flags.captures ? p.flags.captures : void 0;
     const htmlDir = capturesFlag ?? sbDir;
-    const htmlFiles = existsSync21(htmlDir) ? discover([htmlDir]).files.filter((f) => /\.html?$/i.test(f)) : [];
+    const htmlFiles = existsSync22(htmlDir) ? discover([htmlDir]).files.filter((f) => /\.html?$/i.test(f)) : [];
     const outDir = ".ultra11y/captures";
     let attributed = 0;
     let skipped = 0;
@@ -51977,8 +54571,8 @@ Fill in COMPONENTS, run it (e.g. npx tsx ${out2}), then: node scripts/ultra11y.m
         continue;
       }
       try {
-        mkdirSync10(outDir, { recursive: true });
-        writeFileSync13(join36(outDir, `${hitId}.html`), `${formatCaptureComment(prov)}
+        mkdirSync11(outDir, { recursive: true });
+        writeFileSync14(join38(outDir, `${hitId}.html`), `${formatCaptureComment(prov)}
 ${raw}${raw.endsWith("\n") ? "" : "\n"}`);
         attributed++;
       } catch {
@@ -52000,11 +54594,11 @@ ${raw}${raw.endsWith("\n") ? "" : "\n"}`);
   }
   if (p.flags.coverage === true) {
     const capturesFlag = typeof p.flags.captures === "string" && p.flags.captures ? p.flags.captures : void 0;
-    const capturesDir = capturesFlag ?? join36(root, ".ultra11y/captures");
+    const capturesDir = capturesFlag ?? join38(root, ".ultra11y/captures");
     const graphExt = [...GRAPH_ONLY_EXT, ...asList(p.flags.ext) ?? []];
     const sourceFiles = discover([root], { include: asList(p.flags.include), exclude: asList(p.flags.exclude), ext: graphExt }).files;
     const graph = buildGraphStreaming(sourceFiles);
-    const capFiles = existsSync21(capturesDir) ? discover([capturesDir]).files : [];
+    const capFiles = existsSync22(capturesDir) ? discover([capturesDir]).files : [];
     const entries = capFiles.map((f) => ({ file: toPosix(f), provenance: parseCaptureProvenance(readText(f)) }));
     const cov = computeCaptureCoverage(graph, entries);
     if (p.flags.json) console.log(JSON.stringify(cov, null, 2));
@@ -52012,15 +54606,15 @@ ${raw}${raw.endsWith("\n") ? "" : "\n"}`);
     return 0;
   }
   let deps = {};
-  const pkgPath = join36(root, "package.json");
-  if (existsSync21(pkgPath)) {
+  const pkgPath = join38(root, "package.json");
+  if (existsSync22(pkgPath)) {
     try {
       const pkg = JSON.parse(readText(pkgPath));
       deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
     } catch {
     }
   }
-  const detection = detectFrameworks(deps, (f) => existsSync21(join36(root, f)));
+  const detection = detectFrameworks(deps, (f) => existsSync22(join38(root, f)));
   if (p.flags.json) console.log(JSON.stringify(detection, null, 2));
   else console.log(renderPlan(detection, lang));
   return 0;
@@ -52219,9 +54813,9 @@ function applyAdjudicationFile(p, adj, lang) {
     return 1;
   }
   const out2 = typeof p.flags.out === "string" ? p.flags.out : ".";
-  mkdirSync10(out2, { recursive: true });
-  const auditPath = join36(out2, "audit-latest.json");
-  writeFileSync13(auditPath, JSON.stringify(r.audit, null, 2) + "\n");
+  mkdirSync11(out2, { recursive: true });
+  const auditPath = join38(out2, "audit-latest.json");
+  writeFileSync14(auditPath, JSON.stringify(r.audit, null, 2) + "\n");
   if (p.flags.json) console.log(JSON.stringify({ ok: true, auditPath, applied: r.applied, stillManual: r.stillManual, grounding: r.grounding }, null, 2));
   else
     console.log(
@@ -52291,7 +54885,7 @@ async function cmdScan(p) {
     return 0;
   }
   for (const target of p.positionals.filter((a) => a !== "-")) {
-    if (/^https?:\/\//i.test(target) || existsSync21(target)) continue;
+    if (/^https?:\/\//i.test(target) || existsSync22(target)) continue;
     console.error(
       lang === "fr" ? `ultra11y scan : fichier introuvable (file not found) : ${target}. Passez une URL http(s):// ou un fichier HTML existant.` : `ultra11y scan: File not found: ${target}. Pass an http(s):// URL or an existing HTML file.`
     );
@@ -52416,12 +55010,12 @@ async function cmdScan(p) {
       audit2 = parsed;
     }
     const merged = mergeDynamic(audit2, dynamic, lang);
-    mkdirSync10(out2, { recursive: true });
-    writeFileSync13(join36(out2, "audit-latest.json"), JSON.stringify(merged, null, 2) + "\n");
+    mkdirSync11(out2, { recursive: true });
+    writeFileSync14(join38(out2, "audit-latest.json"), JSON.stringify(merged, null, 2) + "\n");
     if (p.flags.json) console.log(JSON.stringify(merged, null, 2));
     else
       console.log(
-        lang === "fr" ? `Audit statique + dynamique fusionn\xE9 \u2192 ${join36(out2, "audit-latest.json")} (${merged.conformancePct}% r\xE9ussite, ${merged.findings.length} findings).` : `Static + dynamic audit merged \u2192 ${join36(out2, "audit-latest.json")} (${merged.conformancePct}% pass rate, ${merged.findings.length} findings).`
+        lang === "fr" ? `Audit statique + dynamique fusionn\xE9 \u2192 ${join38(out2, "audit-latest.json")} (${merged.conformancePct}% r\xE9ussite, ${merged.findings.length} findings).` : `Static + dynamic audit merged \u2192 ${join38(out2, "audit-latest.json")} (${merged.conformancePct}% pass rate, ${merged.findings.length} findings).`
       );
     return 0;
   }
@@ -52601,7 +55195,7 @@ function cmdOrchestrate(p) {
   }
   const engineAbs = realpathSync4(fileURLToPath5(import.meta.url));
   if (p.flags.list === true) {
-    if (!existsSync21(runFlag)) {
+    if (!existsSync22(runFlag)) {
       console.error(`ultra11y orchestrate: run dir not found: ${runFlag}.`);
       return 2;
     }
@@ -52628,7 +55222,7 @@ function cmdOrchestrate(p) {
     );
   } else {
     console.log(
-      lang === "fr" ? `Suivez ${join36(runFlag, "orchestration", "RUNBOOK.md")} s\xE9quentiellement (chemin \xE9co).` : `Follow ${join36(runFlag, "orchestration", "RUNBOOK.md")} sequentially (the eco path).`
+      lang === "fr" ? `Suivez ${join38(runFlag, "orchestration", "RUNBOOK.md")} s\xE9quentiellement (chemin \xE9co).` : `Follow ${join38(runFlag, "orchestration", "RUNBOOK.md")} sequentially (the eco path).`
     );
   }
   if (p.flags.phase === void 0 && workflows.length === 0 && p.flags.eco !== true) {
@@ -52696,6 +55290,12 @@ async function main(argv) {
       return cmdScan(p);
     case "sample":
       return cmdSample(p);
+    case "snapshot":
+      return cmdSnapshot(p);
+    case "pages":
+      return cmdPages(p);
+    case "dev":
+      return cmdDev(p);
     case "fix":
       return cmdFix(p);
     case "init":