@lotics/cli 0.205.2 → 0.206.0

package/dist/probe_page.js

@@ -22,16 +22,25 @@ var __loticsProbe = (() => {
   var probe_page_exports = {};
   __export(probe_page_exports, {
     PROBES: () => PROBES,
+    contentHeight: () => contentHeight,
+    doors: () => doors,
+    editorSelector: () => editorSelector,
+    focused: () => focused,
+    openDoor: () => openDoor,
     openRecord: () => openRecord,
     openScreen: () => openScreen,
+    overlaysOpen: () => overlaysOpen,
+    paintState: () => paintState,
     recordRows: () => recordRows,
+    rings: () => rings,
     run: () => run,
     screens: () => screens,
+    surfaceReport: () => surfaceReport,
     textLeafCount: () => textLeafCount
   });
 
   // src/probe_collectors.ts
-  function moneyColumns() {
+  function moneyColumns(root = document.body) {
     const money = /^[-+−]?\s?(?:(?:[$€]|USD|EUR|VND)\s?[\d.,]+\s?(?:[KMB]|tr|tỷ)?|[\d.,]+\s?(?:tr|tỷ)?\s?(?:₫|đ|VND|USD|EUR|[$€]))$/i;
     const skipTag = /^(SCRIPT|STYLE|TITLE|META|LINK|NOSCRIPT|TEMPLATE)$/;
     const bandGap = 48;
@@ -59,7 +68,7 @@ var __loticsProbe = (() => {
       }
       node.childNodes.forEach(walk);
     };
-    walk(document.body);
+    walk(root);
     const bands = [];
     for (const leaf of [...leaves].sort((a, b) => a.top - b.top)) {
       const band = bands[bands.length - 1];
@@ -96,7 +105,7 @@ var __loticsProbe = (() => {
     }
     return { total: leaves.length, columns };
   }
-  function reportedValues() {
+  function reportedValues(root = document.body) {
     const numeric = /^[-+−]?\d[\d.,]*\s?(?:%|[A-Za-z₫đ$€]{1,4})?$/;
     const counted = /(?:%|[A-Za-z₫đ$€]{1,4})$/;
     const delta = /^[↑↓→▲▼]\s*[-+−]?\d[\d.,]*\s?%$/;
@@ -107,7 +116,7 @@ var __loticsProbe = (() => {
     const nameReach = 360;
     const values = [];
     const labels = [];
-    let deltas = 0;
+    const deltaLeaves = [];
     const walk = (node) => {
       if (node.nodeType === Node.TEXT_NODE) {
         const text = (node.textContent || "").trim();
@@ -116,11 +125,11 @@ var __loticsProbe = (() => {
         if (typeof parent.checkVisibility === "function" && !parent.checkVisibility()) return;
         const rect = parent.getBoundingClientRect();
         if (rect.width === 0 && rect.height === 0) return;
+        const leaf = { text, left: Math.round(rect.left), right: Math.round(rect.right), top: Math.round(rect.top) };
         if (delta.test(text)) {
-          deltas += 1;
+          deltaLeaves.push(leaf);
           return;
         }
-        const leaf = { text, left: Math.round(rect.left), right: Math.round(rect.right), top: Math.round(rect.top) };
         if (!numeric.test(text) || dateLike.test(text)) {
           labels.push(leaf);
           return;
@@ -131,7 +140,7 @@ var __loticsProbe = (() => {
       }
       node.childNodes.forEach(walk);
     };
-    walk(document.body);
+    walk(root);
     const clusters = [];
     for (const leaf of [...values].sort((a, b) => a.left - b.left || a.top - b.top)) {
       const cluster = clusters.find((c) => leaf.left < c.right && leaf.right > c.left);
@@ -143,6 +152,11 @@ var __loticsProbe = (() => {
         clusters.push({ left: leaf.left, right: leaf.right, items: [leaf] });
       }
     }
+    const nameOf2 = (left, right, top, inkLeft) => {
+      const above = labels.filter((label) => label.top < top && top - label.top <= nameReach && label.left < right && label.right > left).sort((a, b) => b.top - a.top)[0];
+      const beside = labels.filter((label) => Math.abs(label.top - top) <= 8 && label.right <= inkLeft).sort((a, b) => b.right - a.right)[0];
+      return (above ?? beside)?.text.slice(0, 40) ?? "";
+    };
     const columns = [];
     let bare = 0;
     let quantities = 0;
@@ -151,56 +165,229 @@ var __loticsProbe = (() => {
       const ordinal = items.length >= 3 && items.every((item, index) => item.text === String(index + 1));
       if (ordinal) continue;
       const top = items[0];
-      const above = labels.filter((label) => label.top < top.top && top.top - label.top <= nameReach && label.left < cluster.right && label.right > cluster.left).sort((a, b) => b.top - a.top)[0];
-      const beside = labels.filter((label) => Math.abs(label.top - top.top) <= 8 && label.right <= top.left).sort((a, b) => b.right - a.right)[0];
       const scaled = items.filter((item) => counted.test(item.text)).length;
-      bare += items.length;
+      bare += items.length - scaled;
       quantities += scaled;
       columns.push({
-        slot: (above ?? beside)?.text.slice(0, 40) ?? "",
+        slot: nameOf2(cluster.left, cluster.right, top.top, top.left),
         size: items.length,
         quantities: scaled,
         samples: items.slice(0, 4).map((item) => item.text)
       });
     }
     columns.sort((a, b) => b.size - a.size);
-    const drawn = Array.from(document.querySelectorAll('[role="meter"], [role="progressbar"], canvas')).filter((el) => {
+    const drawn = Array.from(root.querySelectorAll('[role="meter"], [role="progressbar"], canvas')).filter((el) => {
       const r = el.getBoundingClientRect();
       return r.width > 0 && r.height > 0;
     });
     const reads = (el) => {
       const role = el.getAttribute("role");
       if (role !== "meter" && role !== "progressbar") return true;
-      const stated = (name) => {
+      const stated2 = (name) => {
         const raw = el.getAttribute(name);
         return raw === null || raw.trim() === "" ? Number.NaN : Number(raw);
       };
       const bound = (name, fallback) => {
-        const value = stated(name);
+        const value = stated2(name);
         return Number.isFinite(value) ? value : fallback;
       };
-      const now = stated("aria-valuenow");
+      const now = stated2("aria-valuenow");
       if (!Number.isFinite(now)) return false;
       const floor = bound("aria-valuemin", 0);
       const top = bound("aria-valuemax", 100);
       return top > floor && now < top;
     };
-    const pictures = Array.from(document.querySelectorAll('[role="img"], svg, img')).filter((el) => {
+    const pictures = Array.from(root.querySelectorAll('[role="img"], svg, img')).filter((el) => {
       if (el.getAttribute("aria-hidden") === "true") return false;
       const r = el.getBoundingClientRect();
       return r.width >= pictureMin && r.height >= pictureMin;
     });
-    const encoded = drawn.filter(reads).length + pictures.length + deltas;
+    const markMin = 4;
+    const notData = 'a, button, input, nav, [role="banner"], [role="button"], [role="checkbox"], [role="radio"], [role="switch"], [role="tab"]';
+    const marked = (el) => {
+      if (el.closest(notData) !== null) return false;
+      const r = el.getBoundingClientRect();
+      return r.width >= markMin && r.height >= markMin && (r.width < pictureMin || r.height < pictureMin);
+    };
+    const glyphs = Array.from(root.querySelectorAll('[role="img"]')).filter(
+      (el) => el.getAttribute("aria-hidden") !== "true" && (el.getAttribute("aria-label") || "").trim() !== "" && marked(el)
+    );
+    const already = [...drawn, ...pictures, ...glyphs];
+    const swatches = Array.from(root.querySelectorAll("*")).filter((el) => {
+      if ((el.textContent || "").trim() !== "") return false;
+      if (already.some((device) => device === el || device.contains(el))) return false;
+      if (!marked(el)) return false;
+      const ground = getComputedStyle(el).backgroundColor;
+      return ground !== "" && ground !== "transparent" && !/,\s*0(?:\.0+)?\)\s*$/.test(ground);
+    });
+    const tells = (marks, sign) => new Set(marks.map(sign)).size > 1 ? marks.length : 0;
+    const categorical = tells(swatches, (el) => getComputedStyle(el).backgroundColor) + tells(glyphs, (el) => el.getAttribute("aria-label") || "");
+    const tally = /* @__PURE__ */ new Map();
+    const note = (kind, box) => {
+      const slot = nameOf2(box.left, box.right, box.top, box.left);
+      const key = `${kind}\0${slot}`;
+      const seen = tally.get(key);
+      if (seen === void 0) tally.set(key, { kind, slot, count: 1 });
+      else seen.count += 1;
+    };
+    const noteElement = (kind, el) => {
+      const r = el.getBoundingClientRect();
+      note(kind, { left: Math.round(r.left), right: Math.round(r.right), top: Math.round(r.top) });
+    };
+    for (const el of drawn) noteElement(el.tagName === "CANVAS" ? "chart" : "meter", el);
+    for (const el of pictures) noteElement("picture", el);
+    for (const el of swatches) noteElement("swatch", el);
+    for (const el of glyphs) noteElement("glyph", el);
+    for (const leaf of deltaLeaves) note("delta", leaf);
+    const deviceKinds = [...tally.values()].sort(
+      (a, b) => b.count - a.count || (a.kind < b.kind ? -1 : a.kind > b.kind ? 1 : 0)
+    );
+    const slotMax = pictureMin * 4;
+    const isSlot = (el) => {
+      if ((el.textContent || "").trim() !== "") return false;
+      if (el.closest(notData) !== null) return false;
+      const r = el.getBoundingClientRect();
+      if (r.width < pictureMin || r.height < pictureMin) return false;
+      return r.width <= slotMax && r.height <= slotMax;
+    };
+    const holdsPicture = (el) => {
+      if (/^(IMG|CANVAS|VIDEO)$/.test(el.tagName)) return true;
+      for (const media of el.querySelectorAll("img, canvas, video")) {
+        const r = media.getBoundingClientRect();
+        if (r.width > 0 && r.height > 0) return true;
+      }
+      for (const vector of el.querySelectorAll("svg")) {
+        const r = vector.getBoundingClientRect();
+        if (r.width >= pictureMin && r.height >= pictureMin) return true;
+      }
+      return false;
+    };
+    const slotBoxes = Array.from(root.querySelectorAll("*")).filter(
+      (el) => isSlot(el) && !Array.from(el.children).some(isSlot)
+    );
+    const slotClusters = [];
+    for (const el of slotBoxes) {
+      const r = el.getBoundingClientRect();
+      const box = { left: Math.round(r.left), right: Math.round(r.right), top: Math.round(r.top) };
+      const cluster = slotClusters.find((c) => box.left < c.right && box.right > c.left);
+      if (cluster !== void 0) {
+        cluster.items.push(el);
+        cluster.left = Math.min(cluster.left, box.left);
+        cluster.right = Math.max(cluster.right, box.right);
+      } else {
+        slotClusters.push({ left: box.left, right: box.right, items: [el] });
+      }
+    }
+    const markSlots = slotClusters.filter((cluster) => cluster.items.length >= 3).map((cluster) => {
+      const tops = cluster.items.map((el) => Math.round(el.getBoundingClientRect().top));
+      return {
+        slot: nameOf2(cluster.left, cluster.right, Math.min(...tops), cluster.left),
+        size: cluster.items.length,
+        filled: cluster.items.filter(holdsPicture).length
+      };
+    }).sort((a, b) => b.size - a.size);
+    const encoded = drawn.filter(reads).length + pictures.length + deltaLeaves.length + categorical;
     return {
-      total: bare + encoded,
+      total: bare + quantities + encoded,
       bare,
       quantities,
       encoded,
-      devices: drawn.length + pictures.length + deltas,
-      columns
+      devices: drawn.length + pictures.length + deltaLeaves.length + swatches.length + glyphs.length,
+      deviceKinds,
+      columns,
+      markSlots
     };
   }
-  function internalIds() {
+  function stageWordColumns(root = document.body) {
+    const tabs = [];
+    for (const tab of Array.from(root.querySelectorAll('[role="tablist"] [role="tab"]'))) {
+      const label = (tab.textContent || "").trim();
+      if (label !== "" && !tabs.includes(label)) tabs.push(label);
+    }
+    if (tabs.length < 2) return { total: 0, wordsOnly: [] };
+    const skipTag = /^(SCRIPT|STYLE|TITLE|META|LINK|NOSCRIPT|TEMPLATE)$/;
+    const notContent = 'nav, [role="banner"], [role="tab"], [role="tablist"]';
+    const markMin = 4;
+    const pictureMin = 32;
+    const nameReach = 360;
+    const unpainted = (ground) => ground === "" || ground === "transparent" || /,\s*0(?:\.0+)?\)\s*$/.test(ground);
+    const leaves = [];
+    const labels = [];
+    const walk = (node) => {
+      if (node.nodeType === Node.TEXT_NODE) {
+        const text = (node.textContent || "").trim();
+        const parent = node.parentElement;
+        if (!text || !parent || skipTag.test(parent.tagName)) return;
+        if (typeof parent.checkVisibility === "function" && !parent.checkVisibility()) return;
+        const rect = parent.getBoundingClientRect();
+        if (rect.width === 0 && rect.height === 0) return;
+        const box = {
+          text,
+          left: Math.round(rect.left),
+          right: Math.round(rect.right),
+          top: Math.round(rect.top)
+        };
+        labels.push(box);
+        if (tabs.includes(text) && !parent.closest(notContent)) leaves.push({ el: parent, ...box });
+        return;
+      }
+      node.childNodes.forEach(walk);
+    };
+    walk(root);
+    const clusters = [];
+    for (const leaf of [...leaves].sort((a, b) => a.left - b.left || a.top - b.top)) {
+      const cluster = clusters.find((c) => leaf.left < c.right && leaf.right > c.left);
+      if (cluster !== void 0) {
+        cluster.items.push(leaf);
+        cluster.left = Math.min(cluster.left, leaf.left);
+        cluster.right = Math.max(cluster.right, leaf.right);
+      } else {
+        clusters.push({ left: leaf.left, right: leaf.right, items: [leaf] });
+      }
+    }
+    const nameOf2 = (left, right, top) => {
+      const above = labels.filter((label) => label.top < top && top - label.top <= nameReach && label.left < right && label.right > left).sort((a, b) => b.top - a.top)[0];
+      const beside = labels.filter((label) => Math.abs(label.top - top) <= 8 && label.right <= left).sort((a, b) => b.right - a.right)[0];
+      return (above ?? beside)?.text.slice(0, 40) ?? "";
+    };
+    const cellOf = (leaf, left, right) => {
+      let cell = leaf.el;
+      let node = leaf.el.parentElement;
+      while (node !== null) {
+        const r = node.getBoundingClientRect();
+        if (Math.round(r.left) < left - pictureMin || Math.round(r.right) > right + pictureMin) break;
+        cell = node;
+        node = node.parentElement;
+      }
+      return cell;
+    };
+    const holdsMark = (cell, word) => Array.from(cell.querySelectorAll("*")).some((el) => {
+      if (el === word || el.contains(word)) return false;
+      const r = el.getBoundingClientRect();
+      if (r.width < markMin || r.height < markMin) return false;
+      if (el.getAttribute("aria-hidden") === "true") return false;
+      if (el.getAttribute("role") === "img") return (el.getAttribute("aria-label") || "").trim() !== "";
+      if (r.width >= pictureMin && r.height >= pictureMin) return false;
+      if ((el.textContent || "").trim() !== "") return false;
+      return !unpainted(getComputedStyle(el).backgroundColor);
+    });
+    const columns = [];
+    const wordsOnly = [];
+    for (const cluster of clusters) {
+      if (cluster.items.length < 3) continue;
+      const cells = cluster.items.map((leaf) => ({ leaf, cell: cellOf(leaf, cluster.left, cluster.right) }));
+      const column = {
+        slot: nameOf2(cluster.left, cluster.right, Math.min(...cluster.items.map((item) => item.top))),
+        size: cluster.items.length,
+        values: tabs.filter((tab) => cluster.items.some((item) => item.text === tab))
+      };
+      columns.push(column);
+      const marked = cells.some(({ cell, leaf }) => holdsMark(cell, leaf.el)) || new Set(cells.map(({ cell }) => getComputedStyle(cell).backgroundColor)).size > 1;
+      if (!marked) wordsOnly.push(column);
+    }
+    return { total: columns.length, wordsOnly };
+  }
+  function internalIds(root = document.body) {
     const skipTag = /^(SCRIPT|STYLE|TITLE|META|LINK|NOSCRIPT|TEMPLATE)$/;
     const id = /\b(?:opt|fld|tbl|rec|wfl|mbr|app|wsp)_[A-Za-z0-9]{6,}\b/g;
     const ids = /* @__PURE__ */ new Set();
@@ -217,11 +404,11 @@ var __loticsProbe = (() => {
       }
       node.childNodes.forEach(walk);
     };
-    walk(document.body);
+    walk(root);
     return { total, ids: [...ids] };
   }
-  function tabStrips() {
-    const all = Array.from(document.querySelectorAll('[role="tablist"]')).filter((el) => {
+  function tabStrips(root = document.body) {
+    const all = Array.from(root.querySelectorAll('[role="tablist"]')).filter((el) => {
       const r = el.getBoundingClientRect();
       return r.width > 0 && r.height > 0;
     });
@@ -232,13 +419,13 @@ var __loticsProbe = (() => {
       strips: counted.map((el) => Array.from(el.querySelectorAll('[role="tab"]')).map((tab) => (tab.textContent || "").trim()))
     };
   }
-  function truncatedLeaves() {
+  function truncatedLeaves(root = document.body) {
     const skipTag = /^(SCRIPT|STYLE|TITLE|META|LINK|NOSCRIPT|TEMPLATE)$/;
-    const clippedAway = /^inset\(\s*50%/;
+    const clippedAway2 = /^inset\(\s*50%/;
     const breakable = /[\t\n\v\f\r \u200b\u3000]/;
     const cut = [];
     let total = 0;
-    for (const el of Array.from(document.querySelectorAll("*"))) {
+    for (const el of Array.from(root.querySelectorAll("*"))) {
       if (skipTag.test(el.tagName) || el.children.length > 0) continue;
       const text = (el.textContent || "").trim();
       if (!text) continue;
@@ -246,7 +433,7 @@ var __loticsProbe = (() => {
       const style = getComputedStyle(el);
       const box = el.getBoundingClientRect();
       if (box.width <= 1 && box.height <= 1) continue;
-      if (clippedAway.test(style.getPropertyValue("clip-path"))) continue;
+      if (clippedAway2.test(style.getPropertyValue("clip-path"))) continue;
       total += 1;
       if (style.overflow === "visible") continue;
       const states = (property) => {
@@ -262,7 +449,7 @@ var __loticsProbe = (() => {
     }
     return { total, cut };
   }
-  function bannedGlyphs() {
+  function bannedGlyphs(root = document.body) {
     const skipTag = /^(SCRIPT|STYLE|TITLE|META|LINK|NOSCRIPT|TEMPLATE)$/;
     const found = [];
     let total = 0;
@@ -278,10 +465,10 @@ var __loticsProbe = (() => {
       }
       node.childNodes.forEach(walk);
     };
-    walk(document.body);
+    walk(root);
     return { total, found };
   }
-  function compactMoneyWords() {
+  function compactMoneyWords(root = document.body) {
     const skipTag = /^(SCRIPT|STYLE|TITLE|META|LINK|NOSCRIPT|TEMPLATE)$/;
     const any = /\d[\d.,]*\s?(?:[KMB](?![a-z])|tr(?![a-z])|tỷ)/i;
     const dongInEnglishWords = /\d[\d.,]*\s?[KMB]\s?(?:₫|đ|VND)|(?:₫|VND)\s?\d[\d.,]*\s?[KMB](?![a-z])/i;
@@ -300,11 +487,11 @@ var __loticsProbe = (() => {
       }
       node.childNodes.forEach(walk);
     };
-    walk(document.body);
+    walk(root);
     return { total, foreign };
   }
-  function scanStackedPairs() {
-    const px = (el) => parseFloat(getComputedStyle(el).fontSize);
+  function scanStackedPairs(root = document.body) {
+    const px2 = (el) => parseFloat(getComputedStyle(el).fontSize);
     const weight = (el) => parseInt(getComputedStyle(el).fontWeight, 10) || 400;
     const isLeaf = (el) => el.children.length === 0 && (el.textContent || "").trim().length > 0;
     const leafOf = (el, depth = 3) => {
@@ -313,9 +500,16 @@ var __loticsProbe = (() => {
       return leafOf(el.children[0], depth - 1);
     };
     const sameColumn = 8;
+    const heading = 'h1, h2, h3, h4, h5, h6, [role="heading"]';
+    const collection = 'ul, ol, dl, table, [role="list"], [role="grid"], [role="table"]';
+    const pairShaped = (box) => box.children.length === 2 && leafOf(box.children[0]) !== null && leafOf(box.children[1]) !== null;
+    const names = (line, box) => {
+      const id = line.getAttribute("id") || "";
+      return id !== "" && (box.getAttribute("aria-labelledby") || "").split(/\s+/).includes(id);
+    };
     let total = 0;
     const overDemoted = [];
-    for (const el of Array.from(document.querySelectorAll("div"))) {
+    for (const el of Array.from(root.querySelectorAll("div"))) {
       const kids = Array.from(el.children);
       if (kids.length !== 2) continue;
       const [first, second] = kids;
@@ -328,19 +522,22 @@ var __loticsProbe = (() => {
       if (b.top < a.bottom - 2) continue;
       if (Math.abs(b.left - a.left) > sameColumn) continue;
       if (a.height === 0 || b.height === 0) continue;
+      if (first.matches(heading) || first.querySelector(heading) !== null) continue;
+      if ([first, subject].some((line) => [el, second].some((box) => names(line, box)))) continue;
+      if (second.matches(collection) || Array.from(second.children).some(pairShaped)) continue;
       total += 1;
-      if (px(supporting) < px(subject) && weight(subject) > weight(supporting)) {
+      if (px2(supporting) < px2(subject) && weight(subject) > weight(supporting)) {
         overDemoted.push({
           subject: (subject.textContent || "").trim().slice(0, 60),
           supporting: (supporting.textContent || "").trim().slice(0, 60),
-          sizes: [px(subject), px(supporting)],
+          sizes: [px2(subject), px2(supporting)],
           weights: [weight(subject), weight(supporting)]
         });
       }
     }
     return { total, overDemoted };
   }
-  function scanRowMarks() {
+  function scanRowMarks(root = document.body) {
     const marks = [];
     const seen = [];
     const record = (el, text) => {
@@ -350,7 +547,7 @@ var __loticsProbe = (() => {
       marks.push({ text, w: Math.round(r.width), y: Math.round(r.y), x: Math.round(r.x) });
     };
     const inContent = (el) => el.closest('[role="banner"]') === null;
-    for (const el of Array.from(document.querySelectorAll('[data-mark="identity"]'))) {
+    for (const el of Array.from(root.querySelectorAll('[data-mark="identity"]'))) {
       const r = el.getBoundingClientRect();
       if (r.height === 0 || !inContent(el)) continue;
       record(el, (el.textContent || "").trim() || "\u25A3");
@@ -362,7 +559,7 @@ var __loticsProbe = (() => {
       if (depth === 0) return false;
       return Array.from(el.children).some((child) => grounded(child, depth - 1));
     };
-    for (const el of Array.from(document.querySelectorAll("*"))) {
+    for (const el of Array.from(root.querySelectorAll("*"))) {
       const r = el.getBoundingClientRect();
       if (r.width < 12 || r.width > 56) continue;
       if (Math.abs(r.width - r.height) > 1) continue;
@@ -390,63 +587,1079 @@ var __loticsProbe = (() => {
     return { total: marks.length, mismatches };
   }
 
+  // src/probe_collectors/naming.ts
+  var HOLDS_A_VALUE = 'input, textarea, select, [contenteditable=""], [contenteditable="true"], [role="textbox"], [role="searchbox"], [role="combobox"], [role="listbox"], [role="spinbutton"], [role="slider"]';
+  var HEADING = 'h1, h2, h3, h4, h5, h6, [role="heading"]';
+  function words(el) {
+    return el === null ? "" : (el.textContent || "").replace(/\s+/g, " ").trim();
+  }
+  function pointedAt(el, attribute) {
+    return (el.getAttribute(attribute) || "").split(/\s+/).filter((id) => id !== "").map((id) => el.ownerDocument.getElementById(id)).filter((target) => target !== null);
+  }
+  function stated(el) {
+    const pointed = pointedAt(el, "aria-labelledby").map(words).filter((name) => name !== "").join(" ");
+    if (pointed !== "") return pointed;
+    return (el.getAttribute("aria-label") || "").trim();
+  }
+  function labelling(el) {
+    const id = el.getAttribute("id") || "";
+    const explicit = id === "" ? void 0 : Array.from(el.ownerDocument.querySelectorAll("label[for]")).find((label2) => label2.getAttribute("for") === id);
+    const label = explicit ?? el.closest("label");
+    if (label === null || label === void 0) return "";
+    const said = [];
+    const walk = (node) => {
+      if (node === el) return;
+      if (node.nodeType === Node.TEXT_NODE) {
+        said.push(node.textContent || "");
+        return;
+      }
+      node.childNodes.forEach(walk);
+    };
+    walk(label);
+    return said.join(" ").replace(/\s+/g, " ").trim();
+  }
+  function regionName(region) {
+    const said = stated(region);
+    return said !== "" ? said : words(region.querySelector(HEADING));
+  }
+  function nameOf(el) {
+    const said = stated(el);
+    if (said !== "") return said;
+    if (el.tagName === "DETAILS") {
+      const summary = words(el.querySelector("summary"));
+      if (summary !== "") return summary;
+    }
+    const labelled = labelling(el);
+    if (labelled !== "") return labelled;
+    if (!el.matches(HOLDS_A_VALUE)) {
+      const own = words(el);
+      if (own !== "") return own;
+    }
+    const tooltip = (el.getAttribute("title") || "").trim();
+    if (tooltip !== "") return tooltip;
+    for (const region of pointedAt(el, "aria-controls")) {
+      const named = regionName(region);
+      if (named !== "") return named;
+    }
+    return "";
+  }
+
+  // src/probe_collectors/on_screen.ts
+  var CLIP_RECT = /^rect\(\s*(-?[\d.]+)px[,\s]+(-?[\d.]+)px[,\s]+(-?[\d.]+)px[,\s]+(-?[\d.]+)px\s*\)$/;
+  var INSET = /^inset\(([^)]*?)(?:\s+round\s+[^)]*)?\)$/;
+  var inset = (value, extent) => value.endsWith("%") ? parseFloat(value) / 100 * extent : parseFloat(value);
+  var meets = (near, far, extent) => extent > 0 && inset(near, extent) + inset(far, extent) >= extent;
+  function clippedAway(el) {
+    const style = getComputedStyle(el);
+    const box = el.getBoundingClientRect();
+    const rect = CLIP_RECT.exec(style.clip);
+    if (rect !== null && (Number(rect[2]) - Number(rect[4]) <= 0 || Number(rect[3]) - Number(rect[1]) <= 0)) return true;
+    const path = INSET.exec(style.clipPath);
+    if (path === null || path[1].trim() === "") return false;
+    const [top, right = top, bottom = top, left = right] = path[1].trim().split(/\s+/);
+    return meets(left, right, box.width) || meets(top, bottom, box.height);
+  }
+  function onScreen(el) {
+    if (el.closest("[inert]") !== null) return false;
+    if (typeof el.checkVisibility === "function" && !el.checkVisibility()) return false;
+    const shown = getComputedStyle(el).visibility;
+    if (shown === "hidden" || shown === "collapse") return false;
+    for (let up = el; up !== null; up = up.parentElement) {
+      if (clippedAway(up)) return false;
+    }
+    const box = el.getBoundingClientRect();
+    return box.width > 0 && box.height > 0;
+  }
+
+  // src/probe_collectors/scope.ts
+  var OVERLAY = '[aria-modal="true"], dialog[open], [role="dialog"], [role="alertdialog"], [role="menu"], [role="listbox"]';
+  var AWAY = '[aria-hidden="true"], [inert]';
+  function measuredSurface() {
+    const away = Array.from(document.querySelectorAll(AWAY));
+    const open = Array.from(document.querySelectorAll(OVERLAY)).filter((el) => {
+      if (!onScreen(el)) return false;
+      if (away.some((hidden) => hidden.contains(el))) return false;
+      if (el.matches('[aria-modal="true"], dialog[open]')) return true;
+      return away.some((hidden) => hidden.parentElement === document.body && !hidden.contains(el));
+    });
+    const inner = open.filter((el) => !open.some((other) => other !== el && el.contains(other)));
+    return inner[inner.length - 1] ?? document.body;
+  }
+  function within(root, selector) {
+    const inside = Array.from(root.querySelectorAll(selector));
+    return root.matches(selector) ? [root, ...inside] : inside;
+  }
+
+  // src/probe_collectors/clutter.ts
+  var overlaySurface = '[role="dialog"], [role="alertdialog"], dialog[open]';
+  var DRAWS = 'svg, img, picture, canvas, video, [role="img"], input, textarea, select, button, [role="button"], [role="textbox"], [role="combobox"], [role="checkbox"], [role="switch"], [role="meter"], [role="progressbar"]';
+  function clutterCensus(root = document.body) {
+    const skipTag = /^(SCRIPT|STYLE|TITLE|META|LINK|NOSCRIPT|TEMPLATE)$/;
+    const chrome = 'nav, [role="banner"]';
+    const recordSurface = '.lotics-record-page, [role="dialog"]';
+    const noteFloor = 3;
+    const formFloor = 3;
+    const hueStep = 30;
+    const chromaFloor = 0.15;
+    const sameColour = 24;
+    const sameEdge = 8;
+    const words3 = (el) => el === null ? "" : (el.textContent || "").trim().slice(0, 40);
+    const surfaces = within(root, recordSurface).filter(onScreen);
+    const called2 = (el) => el.matches(recordSurface) ? words3(el.querySelector(".lotics-record-page__heading, h1, h2")) || "the record" : "the screen";
+    const rules = [];
+    const primary = '[data-variant="primary"]';
+    const acts = within(root, primary).filter(
+      (el) => onScreen(el) && el.closest(chrome) === null && (el.parentElement === null || el.parentElement.closest(primary) === null)
+    );
+    const page = within(root, '[role="main"], main')[0] ?? root;
+    const held = /* @__PURE__ */ new Map();
+    for (const act of acts) {
+      const owner = act.closest(recordSurface) ?? page;
+      const run2 = held.get(owner);
+      if (run2 === void 0) held.set(owner, [act]);
+      else run2.push(act);
+    }
+    let surplusActs = 0;
+    const loud = [];
+    for (const [owner, run2] of held) {
+      if (run2.length <= 1) continue;
+      surplusActs += run2.length - 1;
+      if (loud.length < 3) loud.push(`${called2(owner)}: ${run2.length} primary acts \u2014 ${run2.map((act) => `"${words3(act)}"`).join(", ")}`);
+    }
+    rules.push({
+      law: "hierarchy.md",
+      rule: "One primary act per surface",
+      total: acts.length,
+      count: surplusActs,
+      offenders: loud
+    });
+    const money = /^[-+−]?\s?(?:(?:[$€]|USD|EUR|VND)\s?[\d.,]+\s?(?:[KMB]|tr|tỷ)?|[\d.,]+\s?(?:tr|tỷ)?\s?(?:₫|đ|VND|USD|EUR|[$€]))$/i;
+    const dated = /^\d{1,4}[/.-]\d{1,2}(?:[/.-]\d{1,4})?$/;
+    const coded = /^(?=[^0-9]*[0-9])(?=[^A-Z]*[A-Z])[A-Z0-9][A-Z0-9/_.-]{4,}$/;
+    const places = /* @__PURE__ */ new Map();
+    const shown = /* @__PURE__ */ new Map();
+    for (let index = 0; index < surfaces.length; index++) {
+      const walk = (node) => {
+        if (node.nodeType === Node.TEXT_NODE) {
+          const text = (node.textContent || "").trim();
+          const parent = node.parentElement;
+          if (text === "" || parent === null || skipTag.test(parent.tagName)) return;
+          if (!onScreen(parent)) return;
+          if (!money.test(text) && !dated.test(text) && !coded.test(text)) return;
+          const key = `${index}\0${text}`;
+          shown.set(key, text);
+          const edges = places.get(key);
+          const left = Math.round(parent.getBoundingClientRect().left);
+          if (edges === void 0) places.set(key, [left]);
+          else edges.push(left);
+          return;
+        }
+        node.childNodes.forEach(walk);
+      };
+      walk(surfaces[index]);
+    }
+    let twice = 0;
+    const repeated = [];
+    for (const [key, edges] of places) {
+      const columns = [];
+      for (const left of edges) if (!columns.some((edge) => Math.abs(edge - left) <= sameEdge)) columns.push(left);
+      if (columns.length < 2) continue;
+      twice += 1;
+      if (repeated.length < 3) repeated.push(`"${shown.get(key)}" drawn in ${columns.length} places`);
+    }
+    rules.push({
+      law: "hierarchy.md",
+      rule: "One fact, one place",
+      total: places.size,
+      count: twice,
+      offenders: repeated
+    });
+    const absent = /^[—–-]$/;
+    let facts = 0;
+    let standing = 0;
+    const open = [];
+    for (const surface of surfaces) {
+      if (surface.querySelector(".lotics-record-facts__more") === null) continue;
+      for (const cell of Array.from(surface.querySelectorAll(".lotics-record-facts__fact"))) {
+        const value = cell.querySelector(".lotics-record-facts__value");
+        if (value === null || !onScreen(cell)) continue;
+        facts += 1;
+        if (!absent.test((value.textContent || "").trim())) continue;
+        standing += 1;
+        if (open.length < 3) open.push(`"${words3(cell.querySelector(".lotics-record-facts__label")) || words3(cell)}" is unstated and drawn`);
+      }
+    }
+    rules.push({
+      law: "hierarchy.md",
+      rule: "How a record derives them",
+      total: facts,
+      count: standing,
+      offenders: open
+    });
+    let boxes = 0;
+    let overReserved = 0;
+    const reserved = [];
+    for (const box of within(root, 'textarea, [role="textbox"], [contenteditable="true"]')) {
+      if (!onScreen(box) || box.closest(chrome) !== null) continue;
+      const style = getComputedStyle(box);
+      const line = parseFloat(style.lineHeight) || parseFloat(style.fontSize) * 1.5;
+      if (!Number.isFinite(line) || line <= 0) continue;
+      const pad = (parseFloat(style.paddingTop) || 0) + (parseFloat(style.paddingBottom) || 0);
+      boxes += 1;
+      const lines = Math.round((box.getBoundingClientRect().height - pad) / line);
+      const written = Math.round((box.scrollHeight - pad) / line);
+      if (lines <= noteFloor || written > 1) continue;
+      overReserved += 1;
+      if (reserved.length < 3) {
+        const named = nameOf(box).slice(0, 40);
+        reserved.push(`"${named === "" ? "(unnamed)" : named}": ${lines} lines reserved for 1`);
+      }
+    }
+    for (const surface of within(root, overlaySurface).filter(onScreen)) {
+      const box = surface.getBoundingClientRect();
+      if (box.height <= 0) continue;
+      boxes += 1;
+      const bands = [];
+      const ink = (el) => {
+        if (!onScreen(el)) return;
+        const rect = el.getBoundingClientRect();
+        const top = Math.max(rect.top, box.top);
+        const bottom = Math.min(rect.bottom, box.bottom);
+        if (bottom > top) bands.push([top, bottom]);
+      };
+      const walkInk = (node) => {
+        if (node.nodeType === Node.TEXT_NODE) {
+          const parent = node.parentElement;
+          if (parent !== null && (node.textContent || "").trim() !== "" && !skipTag.test(parent.tagName)) ink(parent);
+          return;
+        }
+        node.childNodes.forEach(walkInk);
+      };
+      walkInk(surface);
+      for (const drawn of Array.from(surface.querySelectorAll(DRAWS))) ink(drawn);
+      bands.sort((a, b) => a[0] - b[0]);
+      let filled = 0;
+      let empty = 0;
+      let edge = null;
+      for (const [top, bottom] of bands) {
+        if (edge !== null && top <= edge) {
+          if (bottom > edge) filled += bottom - edge;
+        } else {
+          if (edge !== null) empty = Math.max(empty, top - edge);
+          filled += bottom - top;
+        }
+        edge = edge === null ? bottom : Math.max(edge, bottom);
+      }
+      if (empty <= filled) continue;
+      overReserved += 1;
+      if (reserved.length < 3) {
+        reserved.push(`${called2(surface)}: ${Math.round(empty)}px of nothing, ${Math.round(filled)}px drawn`);
+      }
+    }
+    rules.push({
+      law: "hierarchy.md",
+      rule: "Whitespace is structure",
+      total: boxes,
+      count: overReserved,
+      offenders: reserved
+    });
+    const fields = within(root, ".lotics-form-field").filter(onScreen);
+    const forms = /* @__PURE__ */ new Map();
+    for (const field of fields) {
+      const owner = field.closest('form, [role="form"]') ?? field.parentElement;
+      if (owner === null) continue;
+      const run2 = forms.get(owner);
+      if (run2 === void 0) forms.set(owner, [field]);
+      else run2.push(field);
+    }
+    let inForms = 0;
+    let overMarked = 0;
+    const marks = [];
+    for (const run2 of forms.values()) {
+      if (run2.length < formFloor) continue;
+      inForms += run2.length;
+      const carried = run2.filter((field) => field.querySelector(".lotics-form-field__mark") !== null);
+      if (carried.length * 2 <= run2.length) continue;
+      overMarked += carried.length;
+      if (marks.length < 3) {
+        marks.push(
+          `${carried.length} of ${run2.length} fields marked \u2014 ` + carried.slice(0, 3).map((field) => `"${words3(field.querySelector(".lotics-form-field__label")) || words3(field)}"`).join(", ")
+        );
+      }
+    }
+    rules.push({
+      law: "hierarchy.md",
+      rule: "Markers on the minority side",
+      total: inForms,
+      count: overMarked,
+      offenders: marks
+    });
+    const theme = getComputedStyle(document.documentElement);
+    const rgbOf = (value) => {
+      const channels = value.match(/^rgba?\(\s*([\d.]+)[,\s]+([\d.]+)[,\s]+([\d.]+)/i);
+      if (channels !== null) return [Number(channels[1]), Number(channels[2]), Number(channels[3])];
+      const hex = value.trim().match(/^#([0-9a-f]{3}|[0-9a-f]{6})$/i);
+      if (hex === null) return null;
+      const digits = hex[1];
+      const pair = (at) => parseInt(digits.length === 3 ? digits[at].repeat(2) : digits.slice(at * 2, at * 2 + 2), 16);
+      return [pair(0), pair(1), pair(2)];
+    };
+    const valence = [];
+    for (const token of ["--lotics-ink-danger", "--lotics-ink-warning", "--lotics-ink-success", "--lotics-ink-inactive"]) {
+      const ink = rgbOf(theme.getPropertyValue(token));
+      if (ink !== null) valence.push(ink);
+    }
+    const hues = /* @__PURE__ */ new Map();
+    let chromatic = 0;
+    if (valence.length > 0) {
+      const stateInk = '[role="status"], [role="alert"], [aria-invalid="true"], [aria-disabled="true"]';
+      const walk = (node) => {
+        if (node.nodeType === Node.TEXT_NODE) {
+          const text = (node.textContent || "").trim();
+          const parent = node.parentElement;
+          if (text === "" || parent === null || skipTag.test(parent.tagName)) return;
+          if (!onScreen(parent) || parent.closest(chrome) !== null || parent.closest(stateInk) !== null) return;
+          const ink = rgbOf(getComputedStyle(parent).color);
+          if (ink === null) return;
+          if (valence.some((tone) => Math.abs(tone[0] - ink[0]) + Math.abs(tone[1] - ink[1]) + Math.abs(tone[2] - ink[2]) <= sameColour)) return;
+          const red = ink[0] / 255;
+          const green = ink[1] / 255;
+          const blue = ink[2] / 255;
+          const top = Math.max(red, green, blue);
+          const bottom = Math.min(red, green, blue);
+          const light = (top + bottom) / 2;
+          const chroma = top - bottom;
+          const saturation = chroma === 0 ? 0 : chroma / (1 - Math.abs(2 * light - 1));
+          if (saturation < chromaFloor || light < 0.12 || light > 0.92) return;
+          const angle = top === red ? (green - blue) / chroma % 6 * 60 : top === green ? ((blue - red) / chroma + 2) * 60 : ((red - green) / chroma + 4) * 60;
+          const bucket = Math.round((angle + 360) % 360 / hueStep) * hueStep % 360;
+          chromatic += 1;
+          const tally = hues.get(bucket);
+          if (tally === void 0) hues.set(bucket, { count: 1, sample: text.slice(0, 40) });
+          else tally.count += 1;
+          return;
+        }
+        node.childNodes.forEach(walk);
+      };
+      walk(root);
+    }
+    const ranked = [...hues.entries()].sort((a, b) => b[1].count - a[1].count);
+    const second = ranked.slice(1);
+    rules.push({
+      law: "hierarchy.md",
+      rule: "Colour carries meaning only",
+      total: chromatic,
+      count: second.reduce((sum, [, tally]) => sum + tally.count, 0),
+      offenders: second.slice(0, 3).map(([bucket, tally]) => `a second hue at ${bucket}\xB0 on ${tally.count} runs \u2014 "${tally.sample}"`)
+    });
+    return rules;
+  }
+
+  // src/probe_collectors/ink_and_air.ts
+  var HEADING2 = 'h1, h2, h3, h4, h5, h6, [role="heading"]';
+  var GRAPHIC = 'svg, img, picture, canvas, [role="img"], [role="figure"]';
+  var CONTROL = 'a[href], button, summary, [role="button"], [role="link"], [role="menuitem"], [role="tab"], [role="checkbox"], [role="switch"]';
+  var NAVIGATION = 'nav, [role="navigation"], [role="banner"]';
+  var EDITOR = 'input, textarea, select, [contenteditable=""], [contenteditable="true"], [contenteditable="plaintext-only"], [role="textbox"], [role="searchbox"], [role="combobox"], [role="spinbutton"]';
+  var FIELD = EDITOR + ', [role="checkbox"], [role="switch"], [role="radio"], [role="slider"]';
+  var GROUP = '[role="group"], fieldset';
+  var TEXT_ENTRY = /* @__PURE__ */ new Set([
+    "text",
+    "search",
+    "url",
+    "tel",
+    "email",
+    "password",
+    "number",
+    "date",
+    "datetime-local",
+    "month",
+    "week",
+    "time"
+  ]);
+  var EDGES = ["top", "right", "bottom", "left"];
+  var HAIR = 0.5;
+  var words2 = (el) => el === null ? "" : (el.textContent || "").replace(/\s+/g, " ").trim();
+  var called = (el) => {
+    const named = nameOf(el).slice(0, 40);
+    return named === "" ? "(unnamed)" : named;
+  };
+  var px = (value) => {
+    const measure = parseFloat(value);
+    return Number.isFinite(measure) ? measure : 0;
+  };
+  var opaque = (colour) => {
+    if (colour === "") return true;
+    if (/^transparent$/i.test(colour)) return false;
+    const alpha = /^rgba\(\s*[\d.]+[,\s]+[\d.]+[,\s]+[\d.]+[,\s/]+([\d.]+)\s*\)/i.exec(colour);
+    return alpha === null || Number(alpha[1]) > 0;
+  };
+  var ringOf = (shadow) => {
+    if (shadow === "" || shadow === "none") return 0;
+    let widest = 0;
+    for (const segment of shadow.split(/,(?![^(]*\))/)) {
+      if (!opaque((/rgba?\([^)]*\)/i.exec(segment) ?? [""])[0])) continue;
+      const lengths = (segment.match(/-?[\d.]+px/g) ?? []).map((length) => parseFloat(length));
+      if (lengths.length < 3) continue;
+      const [x, y, blur, spread = 0] = lengths;
+      if (Math.abs(x) > HAIR || Math.abs(y) > HAIR) continue;
+      widest = Math.max(widest, spread > 0 ? spread : blur);
+    }
+    return widest;
+  };
+  var sidesOf = (style) => EDGES.filter((edge) => {
+    const line = style.getPropertyValue(`border-${edge}-style`);
+    if (line === "" || line === "none" || line === "hidden") return false;
+    if (px(style.getPropertyValue(`border-${edge}-width`)) <= 0) return false;
+    return opaque(style.getPropertyValue(`border-${edge}-color`));
+  }).length;
+  var closed = (style) => sidesOf(style) === EDGES.length || ringOf(style.boxShadow) > 0;
+  var editorsIn = (root) => within(root, EDITOR).filter((el) => {
+    if (!onScreen(el)) return false;
+    if (el.tagName !== "INPUT") return true;
+    return TEXT_ENTRY.has((el.getAttribute("type") || "text").toLowerCase());
+  });
+  function inkAndAirCensus(root = document.body) {
+    const rules = [];
+    const rank = (el) => {
+      const stated2 = parseInt(el.getAttribute("aria-level") || "", 10);
+      if (Number.isFinite(stated2)) return stated2;
+      const tag = /^H([1-6])$/.exec(el.tagName);
+      return tag === null ? 2 : Number(tag[1]);
+    };
+    const headings = within(root, HEADING2).filter(
+      (el) => onScreen(el) && el.closest(NAVIGATION) === null && words2(el) !== ""
+    );
+    const shallowest = headings.reduce((top, el) => Math.min(top, rank(el)), Infinity);
+    const pageTitle = headings.find((el) => rank(el) === shallowest);
+    const headerRow = (heading) => {
+      const own = words2(heading);
+      let row = heading;
+      for (let up = heading.parentElement; up !== null && up !== root; up = up.parentElement) {
+        if (words2(up) !== own) break;
+        row = up;
+      }
+      return row;
+    };
+    const graphicIn = (row) => Array.from(row.querySelectorAll(GRAPHIC)).find((mark) => onScreen(mark) && mark.closest(CONTROL) === null) ?? null;
+    let sections = 0;
+    let badged = 0;
+    const badges = [];
+    for (const heading of headings) {
+      if (heading === pageTitle) continue;
+      sections += 1;
+      const mark = graphicIn(headerRow(heading));
+      if (mark === null) continue;
+      badged += 1;
+      if (badges.length < 3) {
+        badges.push(`"${words2(heading).slice(0, 40)}": the heading row draws <${mark.tagName.toLowerCase()}>`);
+      }
+    }
+    rules.push({
+      law: "hierarchy.md",
+      rule: "Ink and air state what a thing is \u2192 A section's heading",
+      total: sections,
+      count: badged,
+      offenders: badges
+    });
+    const editors = editorsIn(root);
+    const fieldsIn = (box) => within(box, FIELD).filter(onScreen);
+    const labelsIn = (box) => within(box, "label").filter((el) => onScreen(el) && words2(el) !== "");
+    const oneControl = (el) => el.matches(GROUP) || (el.getAttribute("aria-label") || "").trim() !== "" || (el.getAttribute("aria-labelledby") || "").trim() !== "";
+    const around = (outer, inner) => outer.left <= inner.left + HAIR && outer.top <= inner.top + HAIR && outer.right + HAIR >= inner.right && outer.bottom + HAIR >= inner.bottom;
+    let open = 0;
+    let units = 0;
+    const bare = [];
+    const claimed = /* @__PURE__ */ new Set();
+    for (const editor of editors) {
+      if (claimed.has(editor)) continue;
+      let unit = editor;
+      let parts = fieldsIn(editor);
+      let framed = closed(getComputedStyle(unit));
+      for (let up = unit.parentElement; !framed && up !== null && up !== root; up = up.parentElement) {
+        if (labelsIn(up).length > 0) break;
+        const held = fieldsIn(up);
+        if (held.some((field) => !parts.includes(field))) {
+          if (!oneControl(up) || held.some((field) => claimed.has(field))) break;
+          unit = up;
+          parts = held;
+          framed = closed(getComputedStyle(up));
+          continue;
+        }
+        if (!around(up.getBoundingClientRect(), unit.getBoundingClientRect())) continue;
+        framed = closed(getComputedStyle(up));
+      }
+      for (const part of parts) claimed.add(part);
+      units += 1;
+      if (framed) continue;
+      open += 1;
+      if (bare.length < 3) {
+        bare.push(`"${called(unit)}": ${sidesOf(getComputedStyle(unit))} of 4 sides painted at rest`);
+      }
+    }
+    rules.push({
+      law: "hierarchy.md",
+      rule: "Ink and air state what a thing is \u2192 An editor at rest",
+      total: units,
+      count: open,
+      offenders: bare
+    });
+    const drawn = (el) => Array.from(el.children).filter(onScreen);
+    const captionOf = (group) => {
+      const first = drawn(group)[0];
+      if (first === void 0) return null;
+      if (first.matches(HEADING2)) return first;
+      const inside = first.querySelector(HEADING2);
+      return inside !== null && onScreen(inside) && words2(inside) !== "" ? inside : null;
+    };
+    const rowGapOf = (group) => {
+      const rows = drawn(group).slice(1);
+      let gap = null;
+      for (let at = 1; at < rows.length; at++) {
+        const above = rows[at - 1].getBoundingClientRect();
+        const below = rows[at].getBoundingClientRect();
+        const air = below.top - above.bottom;
+        if (air < 0) continue;
+        gap = gap === null ? air : Math.min(gap, air);
+      }
+      return gap;
+    };
+    let pairs = 0;
+    let level = 0;
+    const merged = [];
+    for (const parent of [root, ...Array.from(root.querySelectorAll("*"))]) {
+      const groups = drawn(parent);
+      for (let at = 1; at < groups.length; at++) {
+        const first = groups[at - 1];
+        const second = groups[at];
+        const opens = captionOf(first);
+        const caption = captionOf(second);
+        if (opens === null || caption === null) continue;
+        const gap = rowGapOf(first) ?? rowGapOf(second);
+        if (gap === null) continue;
+        pairs += 1;
+        const above = caption.getBoundingClientRect().top - first.getBoundingClientRect().bottom;
+        if (above > gap) continue;
+        level += 1;
+        if (merged.length < 3) {
+          merged.push(
+            `"${words2(caption).slice(0, 40)}": ${Math.round(above)}px above the caption, ${Math.round(gap)}px between the rows it follows`
+          );
+        }
+      }
+    }
+    rules.push({
+      law: "hierarchy.md",
+      rule: "Ink and air state what a thing is \u2192 Two named groups",
+      total: pairs,
+      count: level,
+      offenders: merged
+    });
+    return rules;
+  }
+  function focusRingCensus(root = document.body) {
+    const clipperOf = (el) => {
+      for (let up = el.parentElement; up !== null; up = up.parentElement) {
+        const style = getComputedStyle(up);
+        const across = style.overflowX || style.overflow;
+        const down = style.overflowY || style.overflow;
+        if (across !== "" && across !== "visible" || down !== "" && down !== "visible") return up;
+      }
+      return null;
+    };
+    const shift = (before, range, short, over) => {
+      const wanted = over > 0 ? over : short > 0 ? -short : 0;
+      return Math.max(0, Math.min(range, before + wanted));
+    };
+    let rings2 = 0;
+    let cut = 0;
+    const clipped = [];
+    for (const editor of editorsIn(root)) {
+      const style = getComputedStyle(editor);
+      const line = style.outlineStyle;
+      const outline = line === "" || line === "none" ? 0 : px(style.outlineWidth) + px(style.outlineOffset);
+      const extent = Math.max(outline, ringOf(style.boxShadow));
+      if (extent <= 0) continue;
+      rings2 += 1;
+      const clipper = clipperOf(editor);
+      if (clipper === null) continue;
+      const scrolled = { top: clipper.scrollTop, left: clipper.scrollLeft };
+      const first = editor.getBoundingClientRect();
+      const port = clipper.getBoundingClientRect();
+      clipper.scrollTop = shift(
+        scrolled.top,
+        clipper.scrollHeight - clipper.clientHeight,
+        port.top - (first.top - extent),
+        first.bottom + extent - port.bottom
+      );
+      clipper.scrollLeft = shift(
+        scrolled.left,
+        clipper.scrollWidth - clipper.clientWidth,
+        port.left - (first.left - extent),
+        first.right + extent - port.right
+      );
+      const box = editor.getBoundingClientRect();
+      const clip = clipper.getBoundingClientRect();
+      const outside = [
+        { edge: "top", by: clip.top - (box.top - extent) },
+        { edge: "right", by: box.right + extent - clip.right },
+        { edge: "bottom", by: box.bottom + extent - clip.bottom },
+        { edge: "left", by: clip.left - (box.left - extent) }
+      ].filter((side) => side.by > HAIR);
+      clipper.scrollTop = scrolled.top;
+      clipper.scrollLeft = scrolled.left;
+      if (outside.length === 0) continue;
+      cut += 1;
+      if (clipped.length < 3) {
+        const worst = Math.round(Math.max(...outside.map((side) => side.by)));
+        clipped.push(
+          `"${called(editor)}": a ${extent}px focus ring cut by up to ${worst}px, on the ` + outside.map((side) => side.edge).join(", ")
+        );
+      }
+    }
+    return [
+      {
+        law: "hierarchy.md",
+        rule: "Ink and air state what a thing is \u2192 A focus ring",
+        total: rings2,
+        count: cut,
+        offenders: clipped
+      }
+    ];
+  }
+
+  // src/probe_collectors/right_form.ts
+  var DAY_RUN_PART = ".lotics-itinerary";
+  var SIDE = 'aside, [role="complementary"], nav, [role="navigation"]';
+  var IN_PAGE = 'button, summary, [role="button"], [role="link"], [role="tab"], [role="menuitem"], a[href^="#"]';
+  var HEADING3 = 'h1, h2, h3, h4, h5, h6, [role="heading"]';
+  var RECORD_ROWS = 'table, [role="table"], [role="grid"], [role="treegrid"], [role="row"], [role="list"], ul, ol';
+  var PARKED = [
+    {
+      is: 'input, textarea, select, [contenteditable=""], [contenteditable="true"], [role="textbox"], [role="searchbox"], [role="combobox"], [role="spinbutton"], [role="slider"], [role="checkbox"], [role="radio"], [role="switch"], form, [role="form"]',
+      called: "a field"
+    },
+    { is: 'table, [role="table"], [role="grid"], [role="treegrid"], [role="row"], [role="listbox"]', called: "a list of rows" },
+    { is: 'article, [role="article"], [role="feed"], [role="log"]', called: "a conversation" },
+    { is: 'img, svg, picture, canvas, [role="img"], [role="figure"]', called: "a picture" },
+    { is: "a[href]", called: "a link out of the page" }
+  ];
+  function rightFormCensus(root = document.body) {
+    const skipTag = /^(SCRIPT|STYLE|TITLE|META|LINK|NOSCRIPT|TEMPLATE)$/;
+    const recordSurface = '.lotics-record-page, [role="dialog"]';
+    const columnFloor = 3;
+    const twoTrackWidth = 1016;
+    const trackHeight = 240;
+    const words3 = (el) => el === null ? "" : (el.textContent || "").trim().slice(0, 40);
+    const surfaces = within(root, recordSurface).filter(onScreen);
+    const called2 = (el) => words3(el.querySelector(".lotics-record-page__heading, h1, h2")) || "the record";
+    const readingInside = (side) => {
+      for (const kind of PARKED) {
+        for (const el of Array.from(side.querySelectorAll(kind.is))) {
+          if (!onScreen(el) || el.closest(IN_PAGE) !== null) continue;
+          const named = nameOf(el).slice(0, 40) || words3(el);
+          return named === "" ? kind.called : `${kind.called} ("${named}")`;
+        }
+      }
+      return null;
+    };
+    const rules = [];
+    const choosers = within(root, 'select, [role="listbox"]').filter(onScreen);
+    let twoOption = 0;
+    const pairs = [];
+    for (const chooser of choosers) {
+      const options = Array.from(
+        chooser.tagName === "SELECT" ? chooser.querySelectorAll("option") : chooser.querySelectorAll('[role="option"]')
+      ).map((option) => (option.textContent || "").trim()).filter((label) => label !== "");
+      if (options.length !== 2) continue;
+      twoOption += 1;
+      if (pairs.length < 3) {
+        const field = chooser.closest(".lotics-form-field");
+        const named = nameOf(chooser).slice(0, 40) || words3(field === null ? null : field.querySelector(".lotics-form-field__label")) || "(unnamed)";
+        pairs.push(`"${named}": a two-option select \u2014 ${options.map((option) => `"${option}"`).join(" / ")}`);
+      }
+    }
+    rules.push({
+      law: "data_entry.md",
+      rule: "Choosing a CHOICE control \u2014 by option count, not by taste",
+      total: choosers.length,
+      count: twoOption,
+      offenders: pairs
+    });
+    let dayRuns = false;
+    for (const sheet of Array.from(document.styleSheets)) {
+      try {
+        for (const rule of Array.from(sheet.cssRules)) {
+          if (rule.cssText.includes(DAY_RUN_PART)) {
+            dayRuns = true;
+            break;
+          }
+        }
+      } catch {
+        continue;
+      }
+      if (dayRuns) break;
+    }
+    const dated = /^\d{1,4}[/.-]\d{1,2}(?:[/.-]\d{1,4})?$/;
+    const dates = [];
+    const headings = [];
+    if (dayRuns) {
+      const walk = (node) => {
+        if (node.nodeType === Node.TEXT_NODE) {
+          const text = (node.textContent || "").trim();
+          const parent = node.parentElement;
+          if (text === "" || parent === null || skipTag.test(parent.tagName)) return;
+          if (!onScreen(parent)) return;
+          const box = parent.getBoundingClientRect();
+          const leaf = { text, left: Math.round(box.left), right: Math.round(box.right), top: Math.round(box.top) };
+          if (dated.test(text)) dates.push(leaf);
+          else headings.push(leaf);
+          return;
+        }
+        node.childNodes.forEach(walk);
+      };
+      walk(root);
+    }
+    const stacks = [];
+    for (const leaf of [...dates].sort((a, b) => a.left - b.left || a.top - b.top)) {
+      const stack = stacks.find((column) => leaf.left < column.right && leaf.right > column.left);
+      if (stack !== void 0) {
+        stack.items.push(leaf);
+        stack.left = Math.min(stack.left, leaf.left);
+        stack.right = Math.max(stack.right, leaf.right);
+      } else {
+        stacks.push({ left: leaf.left, right: leaf.right, items: [leaf] });
+      }
+    }
+    const columns = stacks.filter((stack) => stack.items.length >= columnFloor);
+    let grouped = 0;
+    const runs = [];
+    for (const column of columns) {
+      const days = new Set(column.items.map((leaf) => leaf.text));
+      if (days.size >= column.items.length) continue;
+      grouped += 1;
+      if (runs.length < 3) {
+        const top = Math.min(...column.items.map((leaf) => leaf.top));
+        const over = headings.filter((label) => label.top < top && top - label.top <= 360 && label.left < column.right && label.right > column.left).sort((a, b) => b.top - a.top)[0];
+        runs.push(
+          `${over === void 0 ? "(unnamed)" : over.text}: ${column.items.length} rows over ${days.size} days, the date repeated per row`
+        );
+      }
+    }
+    rules.push({
+      law: "templates.md",
+      rule: "Which device answers the question \u2192 Read a trip's stops in order",
+      total: columns.length,
+      count: grouped,
+      offenders: runs
+    });
+    const namesItself = (region) => {
+      const heading = Array.from(region.querySelectorAll(HEADING3)).find((el) => el.closest("summary") === null);
+      return heading !== void 0 || region.querySelector(RECORD_ROWS) !== null;
+    };
+    let folds = 0;
+    let sections = 0;
+    const hidden = [];
+    for (const surface of surfaces) {
+      for (const fold of Array.from(surface.querySelectorAll(".lotics-accordion__trigger, details, [aria-expanded]"))) {
+        if (!onScreen(fold) || fold.closest('[role="complementary"]') !== null) continue;
+        if (fold.hasAttribute("aria-haspopup") || fold.matches(HOLDS_A_VALUE)) continue;
+        folds += 1;
+        const opened = fold.tagName === "DETAILS" ? [fold] : pointedAt(fold, "aria-controls");
+        if (!fold.matches(".lotics-accordion__trigger") && !opened.some(namesItself)) continue;
+        sections += 1;
+        if (hidden.length < 3) {
+          const named = nameOf(fold).slice(0, 40);
+          hidden.push(`${called2(surface)}: "${named === "" ? "(unnamed)" : named}" is a section behind a fold`);
+        }
+      }
+    }
+    rules.push({
+      law: "templates.md",
+      rule: "Which device answers the question \u2192 See what NAMES this record",
+      total: folds,
+      count: sections,
+      offenders: hidden
+    });
+    let read = 0;
+    let split = 0;
+    const tracks = [];
+    if (window.innerWidth >= twoTrackWidth) {
+      for (const surface of surfaces) {
+        read += 1;
+        const box = surface.getBoundingClientRect();
+        const owners = [surface, ...Array.from(surface.querySelectorAll("*"))];
+        let found = null;
+        for (const owner of owners) {
+          const columnsHere = Array.from(owner.children).filter((child) => {
+            if (!onScreen(child)) return false;
+            if (child.matches(SIDE) || child.querySelector(SIDE) !== null) return false;
+            const rect = child.getBoundingClientRect();
+            return rect.height >= trackHeight && rect.height >= box.height * 0.5 && rect.width >= box.width * 0.2;
+          });
+          for (let a = 0; a < columnsHere.length && found === null; a++) {
+            for (let b = a + 1; b < columnsHere.length && found === null; b++) {
+              const left = columnsHere[a].getBoundingClientRect();
+              const right = columnsHere[b].getBoundingClientRect();
+              const apart = left.right <= right.left + 8 || right.right <= left.left + 8;
+              const overlap = Math.min(left.bottom, right.bottom) - Math.max(left.top, right.top);
+              const together = Math.max(left.right, right.right) - Math.min(left.left, right.left);
+              if (apart && overlap >= Math.min(left.height, right.height) * 0.5 && together >= box.width * 0.7) {
+                found = [columnsHere[a], columnsHere[b]];
+              }
+            }
+          }
+          if (found !== null) break;
+        }
+        if (found !== null) {
+          split += 1;
+          if (tracks.length < 3) {
+            const left = Math.round(found[0].getBoundingClientRect().width);
+            const right = Math.round(found[1].getBoundingClientRect().width);
+            tracks.push(`${called2(surface)}: two columns side by side, ${left}px and ${right}px`);
+          }
+          continue;
+        }
+        for (const side of Array.from(surface.querySelectorAll(SIDE))) {
+          if (!onScreen(side)) continue;
+          const rect = side.getBoundingClientRect();
+          if (rect.width > box.width * 0.6) continue;
+          const column = Array.from(surface.querySelectorAll("*")).some((other) => {
+            if (other === side || side.contains(other) || other.contains(side) || !onScreen(other)) return false;
+            const beside = other.getBoundingClientRect();
+            const apart = beside.left >= rect.right - 8 || beside.right <= rect.left + 8;
+            const overlap = Math.min(beside.bottom, rect.bottom) - Math.max(beside.top, rect.top);
+            return apart && beside.width >= box.width * 0.4 && overlap >= rect.height * 0.5;
+          });
+          if (!column) continue;
+          const parked = readingInside(side);
+          if (parked === null) continue;
+          split += 1;
+          if (tracks.length < 3) tracks.push(`${called2(surface)}: ${parked} beside the reading column`);
+        }
+      }
+    }
+    rules.push({
+      law: "hierarchy.md",
+      rule: "Depth \u2014 four surfaces, four jobs",
+      total: read,
+      count: split,
+      offenders: tracks
+    });
+    return rules;
+  }
+
+  // src/probe_collectors/surface.ts
+  function surfaceChrome(root = document.body) {
+    const round = (n) => Math.round(n * 10) / 10;
+    const anchor = (el) => el === void 0 ? null : { text: (el.textContent || "").trim().slice(0, 80), left: round(el.getBoundingClientRect().left) };
+    const nav = within(root, "nav")[0] ?? null;
+    const navFirst = nav === null ? void 0 : Array.from(nav.querySelectorAll('a[href], [role="link"]')).filter(
+      (item) => onScreen(item) && (item.textContent || "").trim() !== ""
+    )[0];
+    const headings = within(root, "h1, h2, h3, h4, h5, h6").filter(
+      (el) => onScreen(el) && el.closest('nav, [role="banner"]') === null && (el.textContent || "").trim() !== ""
+    );
+    const title = headings[0];
+    const rank = (el) => Number(el.tagName.slice(1));
+    const heading = title === void 0 ? void 0 : headings.slice(1).find((el) => rank(el) > rank(title));
+    const primaries = within(root, '[data-variant="primary"]').filter(
+      (el) => onScreen(el) && el.closest('nav, [role="banner"]') === null
+    );
+    const folds = within(root, '[aria-expanded="false"]').filter(
+      (el) => onScreen(el) && el.getAttribute("aria-haspopup") === null
+    );
+    const foldNames = folds.map((el) => nameOf(el).slice(0, 60));
+    const folded = folds.reduce((sum, el) => {
+      const digits = /\d+/.exec((el.textContent || "").trim());
+      return sum + (digits === null ? 0 : Number(digits[0]));
+    }, 0);
+    return {
+      nav: anchor(navFirst),
+      title: anchor(title),
+      heading: anchor(heading),
+      primary: {
+        count: primaries.length,
+        names: primaries.map((el) => nameOf(el).slice(0, 40))
+      },
+      facts: { visible: labelValuePairs(root), folded, folds: foldNames }
+    };
+  }
+  function labelValuePairs(root) {
+    const px2 = (el) => parseFloat(getComputedStyle(el).fontSize);
+    const isLeaf = (el) => el.children.length === 0 && (el.textContent || "").trim().length > 0;
+    const leafOf = (el, depth = 3) => {
+      if (isLeaf(el)) return el;
+      if (depth === 0 || el.children.length === 0) return null;
+      return leafOf(el.children[0], depth - 1);
+    };
+    let pairs = 0;
+    for (const el of Array.from(root.querySelectorAll("div"))) {
+      const kids = Array.from(el.children);
+      if (kids.length !== 2) continue;
+      if (el.closest('nav, [role="banner"]') !== null) continue;
+      const label = leafOf(kids[0]);
+      const value = leafOf(kids[1]);
+      if (label === null || value === null) continue;
+      const a = kids[0].getBoundingClientRect();
+      const b = kids[1].getBoundingClientRect();
+      if (a.height === 0 || b.height === 0) continue;
+      if (px2(label) < px2(value)) pairs += 1;
+    }
+    return pairs;
+  }
+  function repeatedValues(root = document.body) {
+    const skipTag = /^(SCRIPT|STYLE|TITLE|META|LINK|NOSCRIPT|TEMPLATE)$/;
+    const counts = /* @__PURE__ */ new Map();
+    let total = 0;
+    for (const el of Array.from(root.querySelectorAll("*"))) {
+      if (skipTag.test(el.tagName) || el.children.length > 0) continue;
+      const text = (el.textContent || "").trim();
+      if (text.length < 3) continue;
+      if (!/\d/.test(text) || !/[^\d\s]/.test(text)) continue;
+      if (!onScreen(el)) continue;
+      total += 1;
+      counts.set(text, (counts.get(text) || 0) + 1);
+    }
+    const repeated = Array.from(counts.entries()).filter(([, times]) => times > 1).sort((a, b) => b[1] - a[1]).map(([text, times]) => ({ text: text.slice(0, 60), times }));
+    return { total, repeated };
+  }
+  function wrappedMoney(root = document.body) {
+    const skipTag = /^(SCRIPT|STYLE|TITLE|META|LINK|NOSCRIPT|TEMPLATE)$/;
+    const money = /[$€£¥₫₹]|\bUS\$/;
+    const wrapped = [];
+    let total = 0;
+    for (const el of Array.from(root.querySelectorAll("*"))) {
+      if (skipTag.test(el.tagName) || el.children.length > 0) continue;
+      const text = (el.textContent || "").trim();
+      if (text === "" || !money.test(text) || !/\d/.test(text)) continue;
+      if (!onScreen(el)) continue;
+      total += 1;
+      const range = document.createRange();
+      range.selectNodeContents(el);
+      const lines = Array.from(range.getClientRects()).filter((rect) => rect.width > 0).length;
+      if (lines > 1) wrapped.push({ text: text.slice(0, 50), lines });
+    }
+    return { total, wrapped };
+  }
+
   // src/probe_page.ts
   var PROBES = {
     money_edges: {
+      law: "reviewing.md",
       section: "6",
       fix: "One right edge per money column: give every figure in it the same alignment and the same unit."
     },
     reported_values: {
+      law: "reviewing.md",
       section: "9",
       fix: "Encode the column the screen is ABOUT \u2014 a mark, a meter, a chart or a picture \u2014 and leave the rest as text; a meter whose maximum is the bound it alarms at reads the same on every row, so it encodes nothing."
     },
+    empty_marks: {
+      law: "reviewing.md",
+      section: "9",
+      fix: "Fill the picture column or drop it: a mark slot drawn empty on every row states nothing and takes a column's width."
+    },
+    stage_words: {
+      law: "reviewing.md",
+      section: "9",
+      fix: "A state is the one thing a register encodes with COLOUR: give the stage cell its option's swatch, or the glyph its verdict wears. The words stay; the mark is what the reader scans."
+    },
     internal_ids: {
+      law: "reviewing.md",
       section: "8",
       fix: "A key is not a name: render the record's own label, and keep the id in the link."
     },
     tab_strips: {
+      law: "reviewing.md",
       section: "8a",
       fix: "One navigation strip per screen. A second is a filter wearing navigation's clothes \u2014 draw it as one."
     },
     truncation: {
+      law: "reviewing.md",
       section: "8g",
       fix: "Shed a trailing column, or widen this one until the value fits \u2014 a date, a code or a figure cut inside itself reads as a different one."
     },
     banned_glyph: {
+      law: "reviewing.md",
       section: "10",
       fix: "No punctuation doing a word's job \u2014 separate the two facts with layout, or write the word."
     },
     compact_money_words: {
+      law: "reviewing.md",
       section: "10",
       fix: "Abbreviate in the currency's own words: tr/t\u1EF7 beside \u20AB, K/M/B beside $ and \u20AC."
     },
     stacked_pairs: {
+      law: "reviewing.md",
       section: "1",
       fix: "Demote once, not twice: either the size steps down or the subject gets the weight."
     },
     row_marks: {
+      law: "reviewing.md",
       section: "9",
       fix: "One rung per row: a mark's size follows what the row is ABOUT, so the supporting mark takes the smaller one."
     },
     render: {
+      law: "reviewing.md",
       section: "8",
       fix: "Open the screen and read it: nothing below this was measured, so a clean run over the rest means nothing."
     },
     settle: {
+      law: "reviewing.md",
       section: "9c",
       fix: "A screen that never stops changing has a render that re-renders or a request that never lands \u2014 find which."
+    },
+    /**
+     * The three CENSUSES. They differ from every probe above in shape: each one
+     * makes SEVERAL measurements and raises one finding per measurement that
+     * fired, so the signature here is the census's own frame and each detail line
+     * names the rule it is. A screen is cluttered, in the wrong form, or drawn as
+     * something it is not as a WHOLE, which is why none of them reduces to one
+     * number.
+     */
+    clutter: {
+      law: "hierarchy.md",
+      section: "Budgets a reviewer can count",
+      fix: "Move a fact down a tier, fold it, or take it off the screen \u2014 a budget failing is a tiering question, never a permission to shrink something."
+    },
+    right_form: {
+      law: "templates.md",
+      section: "Which device answers the question",
+      fix: "Draw what the JOB names: the device index gives the entry and the wrong device beside it, and a shape is picked by what the reader must do rather than by what the data is."
+    },
+    ink_and_air: {
+      law: "hierarchy.md",
+      section: "Ink and air state what a thing is",
+      fix: "Draw the thing as what it is: words for a heading, a closed frame for an editor, room for its focus ring, and more air between two named groups than between the rows inside either."
     }
   };
   function signature(probe) {
     return PROBES[probe];
   }
+  function censusFindings(probe, rules) {
+    const fired = rules.filter((rule) => rule.count > 0);
+    if (fired.length === 0) return [];
+    return [
+      {
+        probe,
+        ...signature(probe),
+        total: rules.reduce((sum, rule) => sum + rule.total, 0),
+        count: fired.reduce((sum, rule) => sum + rule.count, 0),
+        detail: fired.map(
+          (rule) => `${rule.law} \xA7${rule.rule} \u2014 ${rule.count} of ${rule.total}` + (rule.offenders.length === 0 ? "" : `: ${rule.offenders.join(" | ")}`)
+        )
+      }
+    ];
+  }
   var MONEY_EDGES_ALLOWED = 2;
   var MONEY_COLUMN_MIN = 3;
   var BARE_VALUES_FLOOR = 8;
   var QUANTITY_COLUMN_MIN = 2;
   function run(options) {
     const findings = [];
-    const money = moneyColumns();
+    const surface = measuredSurface();
+    const money = moneyColumns(surface);
     const ragged = money.columns.filter((column) => column.size >= MONEY_COLUMN_MIN && column.edges.length > MONEY_EDGES_ALLOWED);
     if (ragged.length > 0) {
       findings.push({
@@ -457,25 +1670,53 @@ var __loticsProbe = (() => {
         detail: ragged.slice(0, 5).map((column) => `x=${column.x}: ${column.edges.length} right edges over ${column.size} figures \u2014 ${column.samples.join(" | ")}`)
       });
     }
-    const values = reportedValues();
+    const values = reportedValues(surface);
     const measurable = values.columns.some((column) => column.quantities >= QUANTITY_COLUMN_MIN) || values.devices > 0;
-    if (values.bare >= BARE_VALUES_FLOOR && values.encoded === 0 && measurable) {
+    const emptyPictureColumns = values.markSlots.filter((column) => column.filled === 0);
+    const silentColumns = values.columns.filter(
+      (column) => column.quantities === 0 && column.size >= QUANTITY_COLUMN_MIN
+    );
+    const drawnAndSilent = values.devices > 0 && values.encoded === 0 && silentColumns.length > 0 && values.total >= BARE_VALUES_FLOOR;
+    const wordsOnly = values.bare >= BARE_VALUES_FLOOR && values.encoded === 0 && measurable;
+    if (emptyPictureColumns.length > 0) {
+      findings.push({
+        probe: "empty_marks",
+        ...signature("empty_marks"),
+        total: values.markSlots.reduce((sum, column) => sum + column.size, 0),
+        count: emptyPictureColumns.reduce((sum, column) => sum + column.size, 0),
+        detail: emptyPictureColumns.slice(0, 5).map(
+          (column) => `${column.slot === "" ? "(unnamed)" : column.slot}: ${column.size} picture slots, none holding a picture`
+        )
+      });
+    } else if (drawnAndSilent || wordsOnly) {
       findings.push({
         probe: "reported_values",
         ...signature("reported_values"),
         total: values.total,
         count: values.bare,
         detail: [
-          values.devices === 0 ? `${values.bare} values as bare text, nothing drawn as a mark, meter, chart or picture` : `${values.bare} values as bare text; ${values.devices} drawn, none of them reading a value`,
+          values.devices === 0 ? `${values.bare} unnamed figures as bare text, nothing drawn as a mark, meter, chart or picture` : `${values.devices} drawn, none of them reading a value; ${values.bare} unnamed figures as bare text`,
           ...values.columns.slice(0, 5).map((column) => `  ${column.slot === "" ? "(unnamed)" : column.slot}: ${column.size} \u2014 ${column.samples.join(", ")}`)
         ]
       });
     }
-    const ids = internalIds();
+    const ids = internalIds(surface);
     if (ids.ids.length > 0) {
       findings.push({ probe: "internal_ids", ...signature("internal_ids"), total: ids.total, count: ids.ids.length, detail: ids.ids.slice(0, 5) });
     }
-    const strips = tabStrips();
+    const stageWords = stageWordColumns(surface);
+    if (stageWords.wordsOnly.length > 0) {
+      findings.push({
+        probe: "stage_words",
+        ...signature("stage_words"),
+        total: stageWords.total,
+        count: stageWords.wordsOnly.reduce((sum, column) => sum + column.size, 0),
+        detail: stageWords.wordsOnly.slice(0, 5).map(
+          (column) => `${column.slot === "" ? "(unnamed)" : column.slot}: the stage column is words alone \u2014 ${column.size} rows of ${column.values.join(" / ")}, no swatch or glyph`
+        )
+      });
+    }
+    const strips = tabStrips(surface);
     if (strips.counted > 1) {
       findings.push({
         probe: "tab_strips",
@@ -486,7 +1727,7 @@ var __loticsProbe = (() => {
       });
     }
     if (options.truncation) {
-      const cut = truncatedLeaves();
+      const cut = truncatedLeaves(surface);
       if (cut.cut.length > 0) {
         findings.push({
           probe: "truncation",
@@ -497,11 +1738,11 @@ var __loticsProbe = (() => {
         });
       }
     }
-    const glyphs = bannedGlyphs();
+    const glyphs = bannedGlyphs(surface);
     if (glyphs.found.length > 0) {
       findings.push({ probe: "banned_glyph", ...signature("banned_glyph"), total: glyphs.total, count: glyphs.found.length, detail: glyphs.found.slice(0, 5) });
     }
-    const compact = compactMoneyWords();
+    const compact = compactMoneyWords(surface);
     if (compact.foreign.length > 0) {
       findings.push({
         probe: "compact_money_words",
@@ -511,7 +1752,7 @@ var __loticsProbe = (() => {
         detail: compact.foreign.slice(0, 5).map((text) => `"${text}" abbreviates in the other currency's words`)
       });
     }
-    const pairs = scanStackedPairs();
+    const pairs = scanStackedPairs(surface);
     if (pairs.overDemoted.length > 0) {
       findings.push({
         probe: "stacked_pairs",
@@ -521,7 +1762,7 @@ var __loticsProbe = (() => {
         detail: pairs.overDemoted.slice(0, 5).map((pair) => `"${pair.subject}" ${pair.sizes[0]}px/${pair.weights[0]} over "${pair.supporting}" ${pair.sizes[1]}px/${pair.weights[1]}`)
       });
     }
-    const marks = scanRowMarks();
+    const marks = scanRowMarks(surface);
     if (marks.mismatches.length > 0) {
       findings.push({
         probe: "row_marks",
@@ -531,20 +1772,46 @@ var __loticsProbe = (() => {
         detail: marks.mismatches.slice(0, 5).map((row) => `y=${row.y}: ${row.marks.join(", ")}`)
       });
     }
+    findings.push(...censusFindings("clutter", clutterCensus(surface)));
+    findings.push(...censusFindings("right_form", rightFormCensus(surface)));
+    findings.push(...censusFindings("ink_and_air", [...inkAndAirCensus(surface), ...options.rings ?? []]));
     return {
       findings,
       census: {
-        leaves: textLeafCount(),
+        leaves: textLeafCount(surface),
         money: money.total,
         bare: values.bare,
         quantities: values.quantities,
         encoded: values.encoded,
         devices: values.devices,
+        device_kinds: values.deviceKinds.map(
+          (device) => `${device.kind}\xD7${device.slot === "" ? "(unnamed)" : device.slot}: ${device.count}`
+        ),
         strips: strips.counted
       }
     };
   }
-  function textLeafCount() {
+  function rings() {
+    return focusRingCensus(measuredSurface());
+  }
+  function editorSelector() {
+    return EDITOR;
+  }
+  function focused() {
+    const held = document.activeElement;
+    if (held === null || held === document.body) return null;
+    const named = nameOf(held).slice(0, 40);
+    return named === "" ? held.tagName.toLowerCase() : named;
+  }
+  function paintState() {
+    const root = document.getElementById("root");
+    return {
+      leaves: textLeafCount(),
+      loading: document.readyState === "loading",
+      booted: root !== null && root.hasChildNodes()
+    };
+  }
+  function textLeafCount(root = document.body) {
     const skipTag = /^(SCRIPT|STYLE|TITLE|META|LINK|NOSCRIPT|TEMPLATE)$/;
     let count = 0;
     const walk = (node) => {
@@ -555,7 +1822,7 @@ var __loticsProbe = (() => {
       }
       node.childNodes.forEach(walk);
     };
-    walk(document.body);
+    walk(root);
     return count;
   }
   function navItems() {
@@ -586,10 +1853,12 @@ var __loticsProbe = (() => {
   }
   function recordLinks() {
     const here = location.pathname + location.search;
-    const doors = Array.from(document.querySelectorAll('a[href], [data-opens="page"]'));
-    return doors.filter((door) => {
+    const doors2 = Array.from(
+      document.querySelectorAll('a[href], [data-opens="page"], button, [role="button"], [role="link"]')
+    ).filter((door) => door.matches('a[href], [data-opens="page"]') || isEmptyDoor(door));
+    return doors2.filter((door) => {
       if (door.closest('nav, [role="banner"], [role="tablist"]') !== null) return false;
-      if (doors.some((other) => other !== door && other.contains(door))) return false;
+      if (doors2.some((other) => other !== door && other.contains(door))) return false;
       const rect = door.getBoundingClientRect();
       if (rect.width === 0 || rect.height === 0) return false;
       const href = door.getAttribute("href");
@@ -599,7 +1868,7 @@ var __loticsProbe = (() => {
     });
   }
   function recordRows() {
-    return recordLinks().map((door) => (door.textContent || "").trim() || door.getAttribute("href") || "");
+    return recordLinks().map(doorName);
   }
   function openRecord(index) {
     const door = recordLinks()[index];
@@ -607,5 +1876,119 @@ var __loticsProbe = (() => {
     door.click();
     return true;
   }
+  var OVERLAY_ROLES = '[role="dialog"], [role="alertdialog"], [role="menu"], [role="listbox"]';
+  var NEVER_PRESS = /delete|remove|archive|discard|revoke|unlink|detach|cancel|reset|clear|approve|reject|send|publish|\bpay|submit|confirm|void|deactivate|disable|merge|overwrite|\bsign\b|issue|export|download|print|\bsave\b|\bapply\b/i;
+  var NEVER_PRESS_VI_WORDS = [
+    "x[o\xF3][a\xE1]",
+    "h[\u1EE7u][\u1EF7y]",
+    "g[\u1EE1o]",
+    "l[\u01B0u]u",
+    "duy[\u1EC7e]t",
+    "t[\u1EEBu] ch[\u1ED1o]i",
+    "g[\u1EEDu]i",
+    "thanh to[\xE1a]n",
+    "ph[\xE1a]t h[\xE0a]nh",
+    "x[\xE1a]c nh[\u1EADa]n",
+    "k[\xFDy]",
+    "ghi s[\u1ED5o]",
+    "kh[\xF3o]a",
+    "kho[\xE1a]",
+    "ho[\xE0a]n",
+    "ch[\u1ED1o]t",
+    "t[\xE1a]ch",
+    "g[\u1ED9o]p",
+    "xu[\u1EA5a]t",
+    "t[\u1EA3i]i v[\u1EC1e]",
+    "in",
+    "\u0111[\u0103a]ng xu[\u1EA5a]t"
+  ];
+  var NEVER_PRESS_VI = new RegExp(
+    `(?<![\\p{L}\\p{N}])(?:${NEVER_PRESS_VI_WORDS.join("|")})(?![\\p{L}\\p{N}])`,
+    "iu"
+  );
+  function doorName(el) {
+    return (nameOf(el) || el.getAttribute("href") || "").slice(0, 60);
+  }
+  function isChrome(el) {
+    return el.closest('nav, [role="banner"], [role="tablist"]') !== null;
+  }
+  function isEmptyDoor(el) {
+    if (el.childElementCount > 0) return false;
+    if ((el.textContent || "").trim() !== "") return false;
+    return (el.getAttribute("aria-label") || "").trim() !== "";
+  }
+  function doorElements() {
+    const open = Array.from(document.querySelectorAll(OVERLAY_ROLES)).filter(onScreen);
+    const reachable = (el) => onScreen(el) && !isChrome(el) && el.getAttribute("aria-disabled") !== "true" && !(el instanceof HTMLButtonElement && el.disabled) && // NEVER A CONTROL INSIDE AN OPEN OVERLAY. A dialog's own buttons are the
+    // ones that commit it, and the walk photographs a dialog rather than
+    // answering it.
+    !open.some((overlay) => overlay.contains(el));
+    const records = recordLinks().filter(
+      (el) => reachable(el) && el.getAttribute("aria-expanded") === null && el.getAttribute("aria-haspopup") === null
+    );
+    const menus = Array.from(document.querySelectorAll("[aria-haspopup]")).filter(
+      (el) => reachable(el) && el.getAttribute("aria-expanded") !== "true"
+    );
+    const folds = Array.from(document.querySelectorAll('[aria-expanded="false"]')).filter(
+      (el) => reachable(el) && el.getAttribute("aria-haspopup") === null
+    );
+    const acts = Array.from(
+      document.querySelectorAll('[data-variant="primary"], [data-variant="secondary"]')
+    ).filter((el) => {
+      if (!reachable(el)) return false;
+      if (el.tagName !== "BUTTON" && el.getAttribute("role") !== "button") return false;
+      if (el.getAttribute("aria-haspopup") !== null || el.getAttribute("aria-expanded") !== null) return false;
+      if (el.getAttribute("type") === "submit") return false;
+      if (el.closest("form") !== null) return false;
+      const tone = el.getAttribute("data-tone");
+      if (tone === "danger" || tone === "warning") return false;
+      const name = `${doorName(el)} ${(el.textContent || "").trim()}`;
+      return !NEVER_PRESS.test(name) && !NEVER_PRESS_VI.test(name);
+    });
+    return [
+      // One of each state-changing kind — the first row, the acts menu, the first
+      // fold. A second of any is the same surface again; the acts a screen offers
+      // are not, so every one of those is walked.
+      ...records.slice(0, 1).map((el) => ({ kind: "record", el })),
+      ...menus.slice(0, 1).map((el) => ({ kind: "menu", el })),
+      ...folds.slice(0, 1).map((el) => ({ kind: "fold", el })),
+      ...acts.map((el) => ({ kind: "dialog", el }))
+    ];
+  }
+  function doors() {
+    return doorElements().map((door) => ({ kind: door.kind, name: doorName(door.el) }));
+  }
+  function openDoor(index) {
+    const door = doorElements()[index];
+    if (door === void 0) return false;
+    door.el.click();
+    return true;
+  }
+  function overlaysOpen() {
+    return Array.from(document.querySelectorAll(OVERLAY_ROLES)).filter(onScreen).length;
+  }
+  function contentHeight() {
+    let tallest = Math.max(document.documentElement.scrollHeight, document.body.scrollHeight);
+    for (const el of Array.from(document.querySelectorAll("*"))) {
+      if (el.scrollHeight <= el.clientHeight) continue;
+      if (!onScreen(el)) continue;
+      tallest = Math.max(tallest, Math.ceil(el.getBoundingClientRect().top) + el.scrollHeight);
+    }
+    for (const overlay of Array.from(document.querySelectorAll(OVERLAY_ROLES))) {
+      if (!onScreen(overlay)) continue;
+      tallest = Math.max(tallest, Math.ceil(overlay.getBoundingClientRect().top) + overlay.scrollHeight);
+    }
+    return tallest;
+  }
+  function surfaceReport() {
+    const surface = measuredSurface();
+    const cut = truncatedLeaves(surface);
+    return {
+      ...surfaceChrome(surface),
+      repeated: repeatedValues(surface).repeated,
+      wrapped_money: wrappedMoney(surface).wrapped,
+      clipped: cut.cut
+    };
+  }
   return __toCommonJS(probe_page_exports);
 })();