@lotics/cli 0.242.0 → 0.244.0

package/dist/probe_page.js

@@ -459,7 +459,7 @@ var __loticsProbe = (() => {
     const walk = (node) => {
       if (node.nodeType === Node.TEXT_NODE) {
         const parent = node.parentElement;
-        if (!parent || skipTag.test(parent.tagName)) return;
+        if (!parent || skipTag.test(parent.tagName) || parent.closest("[data-content]") !== null) return;
         const text = node.textContent || "";
         if (!text.trim()) return;
         total += 1;
@@ -609,25 +609,25 @@ var __loticsProbe = (() => {
     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 said2 = [];
     const walk = (node) => {
       if (node === el) return;
       if (node.nodeType === Node.TEXT_NODE) {
-        said.push(node.textContent || "");
+        said2.push(node.textContent || "");
         return;
       }
       node.childNodes.forEach(walk);
     };
     walk(label);
-    return said.join(" ").replace(/\s+/g, " ").trim();
+    return said2.join(" ").replace(/\s+/g, " ").trim();
   }
   function regionName(region) {
-    const said = stated(region);
-    return said !== "" ? said : words(region.querySelector(HEADING));
+    const said2 = stated(region);
+    return said2 !== "" ? said2 : words(region.querySelector(HEADING));
   }
   function nameOf(el) {
-    const said = stated(el);
-    if (said !== "") return said;
+    const said2 = stated(el);
+    if (said2 !== "") return said2;
     if (el.tagName === "DETAILS") {
       const summary = words(el.querySelector("summary"));
       if (summary !== "") return summary;
@@ -689,8 +689,77 @@ var __loticsProbe = (() => {
     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;
+    const inside2 = Array.from(root.querySelectorAll(selector));
+    return root.matches(selector) ? [root, ...inside2] : inside2;
+  }
+
+  // src/probe_collectors/anatomy.ts
+  var BODY = ".lotics-record-page__body";
+  var BRIEF = ".lotics-record-page__brief";
+  var PRIMARY = '.lotics-button[data-variant="primary"]';
+  var FIRST_VIEWPORTS = [
+    { width: 1280, height: 800 },
+    { width: 375, height: 667 }
+  ];
+  function firstViewport(width) {
+    return FIRST_VIEWPORTS.reduce((near, one) => Math.abs(one.width - width) < Math.abs(near.width - width) ? one : near);
+  }
+  function surfaces(root) {
+    return within(root, BODY).filter(onScreen).flatMap((body) => {
+      const head = body.closest(".lotics-drawer__popup, .lotics-record-page");
+      if (head === null) return [];
+      const title = within(head, "h1, h2").find((one) => !body.contains(one) && onScreen(one));
+      return [{ body, root: head, name: words2(title) || nameOf(head) || "(unnamed record)" }];
+    });
+  }
+  function words2(el) {
+    if (el === null || el === void 0) return "";
+    return (el.textContent || "").replace(/\s+/g, " ").trim();
+  }
+  var said = (text) => text.toLowerCase().replace(/\s+/g, " ").replace(/:$/, "").trim();
+  function headingPrimaries(root = document.body) {
+    const drawn = surfaces(root);
+    const loud = drawn.flatMap(
+      (surface) => within(surface.body, PRIMARY).filter((act) => onScreen(act) && act.closest(".lotics-section-heading") !== null).map((act) => ({ record: surface.name, act: nameOf(act) || words2(act) }))
+    );
+    return { total: drawn.length, loud };
+  }
+  function briefsBelowFold(root = document.body, width = window.innerWidth) {
+    const fold = firstViewport(width).height;
+    const briefs = surfaces(root).flatMap((surface) => {
+      const brief = within(surface.body, BRIEF).find(onScreen);
+      return brief === void 0 ? [] : [{ record: surface.name, bottom: Math.round(brief.getBoundingClientRect().bottom) }];
+    });
+    return { total: briefs.length, fold, below: briefs.filter((one) => one.bottom > fold) };
+  }
+  function briefRepeats(root = document.body) {
+    let total = 0;
+    const repeated = surfaces(root).flatMap((surface) => {
+      const brief = within(surface.body, BRIEF).find(onScreen);
+      if (brief === void 0) return [];
+      const head = new Set(
+        within(surface.root, "*").filter((el) => el.childElementCount === 0 && !surface.body.contains(el) && el.closest('button, [role="button"], [role="tab"]') === null && onScreen(el)).map((el) => said(words2(el))).filter((text) => text.length > 1)
+      );
+      const values = within(brief, ".lotics-record-facts__value").filter(onScreen);
+      total += values.length;
+      return values.flatMap((value) => {
+        const text = said(words2(value));
+        return text !== "" && head.has(text) ? [{ record: surface.name, value: words2(value), where: "head" }] : [];
+      });
+    });
+    return { total, repeated };
+  }
+  function emptyTabs(root = document.body) {
+    let total = 0;
+    const empty = surfaces(root).flatMap((surface) => {
+      const tabs = within(surface.body, '[role="tab"]').filter(onScreen);
+      total += tabs.length;
+      const open = tabs.find((tab) => tab.getAttribute("aria-selected") === "true");
+      const panel = within(surface.body, '[role="tabpanel"]').find(onScreen);
+      const bare = open !== void 0 && panel !== void 0 && within(panel, ".lotics-section").filter(onScreen).length === 0;
+      return bare ? [{ record: surface.name, tab: words2(open).replace(/\d+$/, "").trim() }] : [];
+    });
+    return { total, empty };
   }
 
   // src/probe_collectors/clutter.ts
@@ -707,9 +776,9 @@ var __loticsProbe = (() => {
     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(headings) ? words3(el) || "the section" : el.matches(recordSurface) ? words3(el.querySelector(".lotics-record-page__heading, h1, h2")) || "the record" : "the screen";
+    const words5 = (el) => el === null ? "" : (el.textContent || "").trim().slice(0, 40);
+    const surfaces2 = within(root, recordSurface).filter(onScreen);
+    const called2 = (el) => el.matches(headings) ? words5(el) || "the section" : el.matches(recordSurface) ? words5(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(
@@ -739,7 +808,7 @@ var __loticsProbe = (() => {
     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(", ")}`);
+      if (loud.length < 3) loud.push(`${called2(owner)}: ${run2.length} primary acts \u2014 ${run2.map((act) => `"${words5(act)}"`).join(", ")}`);
     }
     rules.push({
       law: "hierarchy.md",
@@ -753,27 +822,27 @@ var __loticsProbe = (() => {
     const coded = /^(?=[^0-9]*[0-9])(?=[^A-Z]*[A-Z])[A-Z0-9][A-Z0-9/_.-]{4,}$/;
     const trim = /^[\s·•|,:;–—-]+|[\s·•|,:;–—-]+$/g;
     const beside = (el, value) => {
-      const said = [];
+      const said2 = [];
       const walk = (node) => {
         if (node === value) return;
-        if (node.nodeType === Node.TEXT_NODE) said.push(node.textContent || "");
+        if (node.nodeType === Node.TEXT_NODE) said2.push(node.textContent || "");
         else node.childNodes.forEach(walk);
       };
       walk(el);
-      return said.join(" ").replace(/\s+/g, " ").replace(trim, "");
+      return said2.join(" ").replace(/\s+/g, " ").replace(trim, "");
     };
     const named = (value, surface) => {
       for (let up = value; up !== null && up !== surface; up = up.parentElement) {
-        const said = stated(up);
-        if (said !== "") return said.replace(trim, "");
-        const words4 = beside(up, value);
-        if (words4 !== "") return words4.slice(0, 40);
+        const said2 = stated(up);
+        if (said2 !== "") return said2.replace(trim, "");
+        const words6 = beside(up, value);
+        if (words6 !== "") return words6.slice(0, 40);
       }
       return "";
     };
     const places = /* @__PURE__ */ new Map();
     const shown = /* @__PURE__ */ new Map();
-    for (let index = 0; index < surfaces.length; index++) {
+    for (let index = 0; index < surfaces2.length; index++) {
       const walk = (node) => {
         if (node.nodeType === Node.TEXT_NODE) {
           const text = (node.textContent || "").trim();
@@ -781,7 +850,7 @@ var __loticsProbe = (() => {
           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 label = named(parent, surfaces[index]);
+          const label = named(parent, surfaces2[index]);
           const key = `${index}\0${label.toLowerCase()}\0${text}`;
           shown.set(key, { label, text });
           const edges = places.get(key);
@@ -792,7 +861,7 @@ var __loticsProbe = (() => {
         }
         node.childNodes.forEach(walk);
       };
-      walk(surfaces[index]);
+      walk(surfaces2[index]);
     }
     let twice = 0;
     const repeated = [];
@@ -819,7 +888,7 @@ var __loticsProbe = (() => {
     let facts = 0;
     let standing = 0;
     const open = [];
-    for (const surface of surfaces) {
+    for (const surface of surfaces2) {
       for (const block of within(surface, ".lotics-record-facts")) {
         const fold = block.querySelector(".lotics-record-facts__more");
         if (fold === null) continue;
@@ -831,7 +900,7 @@ var __loticsProbe = (() => {
             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`);
+            if (open.length < 3) open.push(`"${words5(cell.querySelector(".lotics-record-facts__label")) || words5(cell)}" is unstated and drawn`);
           }
         }
       }
@@ -930,7 +999,7 @@ var __loticsProbe = (() => {
       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(", ")
+          `${carried.length} of ${run2.length} fields marked \u2014 ` + carried.slice(0, 3).map((field) => `"${words5(field.querySelector(".lotics-form-field__label")) || words5(field)}"`).join(", ")
         );
       }
     }
@@ -1027,7 +1096,7 @@ var __loticsProbe = (() => {
   ]);
   var EDGES = ["top", "right", "bottom", "left"];
   var HAIR = 0.5;
-  var words2 = (el) => el === null ? "" : (el.textContent || "").replace(/\s+/g, " ").trim();
+  var words3 = (el) => el === null ? "" : (el.textContent || "").replace(/\s+/g, " ").trim();
   var called = (el) => {
     const named = nameOf(el).slice(0, 40);
     return named === "" ? "(unnamed)" : named;
@@ -1076,15 +1145,15 @@ var __loticsProbe = (() => {
       return tag === null ? 2 : Number(tag[1]);
     };
     const headings = within(root, HEADING2).filter(
-      (el) => onScreen(el) && el.closest(NAVIGATION) === null && words2(el) !== ""
+      (el) => onScreen(el) && el.closest(NAVIGATION) === null && words3(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);
+      const own = words3(heading);
       let row = heading;
       for (let up = heading.parentElement; up !== null && up !== root; up = up.parentElement) {
-        if (words2(up) !== own) break;
+        if (words3(up) !== own) break;
         row = up;
       }
       return row;
@@ -1100,7 +1169,7 @@ var __loticsProbe = (() => {
       if (mark === null) continue;
       badged += 1;
       if (badges.length < 3) {
-        badges.push(`"${words2(heading).slice(0, 40)}": the heading row draws <${mark.tagName.toLowerCase()}>`);
+        badges.push(`"${words3(heading).slice(0, 40)}": the heading row draws <${mark.tagName.toLowerCase()}>`);
       }
     }
     rules.push({
@@ -1112,7 +1181,7 @@ var __loticsProbe = (() => {
     });
     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 labelsIn = (box) => within(box, "label").filter((el) => onScreen(el) && words3(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;
@@ -1157,8 +1226,8 @@ var __loticsProbe = (() => {
       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 inside2 = first.querySelector(HEADING2);
+      return inside2 !== null && onScreen(inside2) && words3(inside2) !== "" ? inside2 : null;
     };
     const rowGapOf = (group) => {
       const rows = drawn(group).slice(1);
@@ -1191,7 +1260,7 @@ var __loticsProbe = (() => {
         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`
+            `"${words3(caption).slice(0, 40)}": ${Math.round(above)}px above the caption, ${Math.round(gap)}px between the rows it follows`
           );
         }
       }
@@ -1276,6 +1345,232 @@ var __loticsProbe = (() => {
     ];
   }
 
+  // src/probe_collectors/layout.ts
+  var RESERVED_MIN_WIDTH = 40;
+  var RESERVED_BLANK_SHARE = 0.5;
+  var CONTROL2 = 'button, [role="button"], a[href], [role="link"], input, select, textarea, [role="checkbox"], [role="switch"]';
+  function words4(el) {
+    if (el === null || el === void 0) return "";
+    const runs = [];
+    const walk = (node) => {
+      if (node.nodeType === Node.TEXT_NODE) runs.push(node.textContent || "");
+      else node.childNodes.forEach(walk);
+    };
+    walk(el);
+    return runs.join(" ").replace(/\s+/g, " ").trim().slice(0, 40);
+  }
+  var inside = (el, root, selector) => el.closest(selector) === root;
+  var stored = (row) => !row.hasAttribute("data-ghost");
+  function kitRegisters(root) {
+    const table = ".lotics-table";
+    const row = ".lotics-table__row";
+    return within(root, table).filter((register) => onScreen(register) && !register.hasAttribute("data-stacked")).map((register) => {
+      const rows = Array.from(register.querySelectorAll(row)).filter((one) => inside(one, register, table) && onScreen(one) && stored(one));
+      const headings = Array.from(register.querySelectorAll(".lotics-table__column")).filter((heading) => inside(heading, register, table));
+      const cellsOf = (one) => {
+        const box = Array.from(one.querySelectorAll(".lotics-table__cells")).find((cells) => inside(cells, one, row));
+        return box === void 0 ? [] : Array.from(box.children).filter((cell) => cell.classList.contains("lotics-table__cell"));
+      };
+      const gutterOf = (one) => Array.from(one.querySelectorAll(".lotics-table__trailing")).find((gutter) => inside(gutter, one, row));
+      const grid = rows.map(cellsOf);
+      const columns = Math.max(headings.length, ...grid.map((cells) => cells.length), 0);
+      const slots = Array.from({ length: columns }, (_, index) => ({
+        name: words4(headings[index]) || `column ${index + 1}`,
+        kind: "column",
+        heading: headings[index],
+        cells: grid.map((cells) => cells[index])
+      }));
+      const gutters = rows.map(gutterOf);
+      if (gutters.some((gutter) => gutter !== void 0)) slots.push({ name: "the row's acts", kind: "gutter", cells: gutters });
+      return { root: register, rows, slots };
+    });
+  }
+  function ariaRegisters(root) {
+    const table = '[role="table"], [role="grid"]';
+    return within(root, table).filter(onScreen).map((register) => {
+      const headings = Array.from(register.querySelectorAll('[role="columnheader"]')).filter((heading) => inside(heading, register, table)).map(words4);
+      const grid = Array.from(register.querySelectorAll('[role="row"]')).filter((one) => inside(one, register, table) && onScreen(one) && stored(one)).map((one) => ({
+        row: one,
+        cells: Array.from(one.querySelectorAll('[role="cell"], [role="gridcell"]')).filter(
+          (cell) => inside(cell, one, '[role="row"]')
+        )
+      })).filter((one) => one.cells.length > 0);
+      const columns = Math.max(headings.length, ...grid.map((one) => one.cells.length), 0);
+      return {
+        root: register,
+        rows: grid.map((one) => one.row),
+        slots: Array.from({ length: columns }, (_, index) => ({
+          name: headings[index] || `column ${index + 1}`,
+          kind: "column",
+          cells: grid.map((one) => one.cells[index])
+        }))
+      };
+    });
+  }
+  function inkSpan(cell) {
+    const box = cell.getBoundingClientRect();
+    let left = Number.POSITIVE_INFINITY;
+    let right = Number.NEGATIVE_INFINITY;
+    const take = (rect) => {
+      if (rect.width <= 0 || rect.height <= 0) return;
+      left = Math.min(left, Math.max(rect.left, box.left));
+      right = Math.max(right, Math.min(rect.right, box.right));
+    };
+    const walk = (node) => {
+      if (node.nodeType === Node.TEXT_NODE) {
+        const parent = node.parentElement;
+        if (parent === null || (node.textContent || "").trim() === "" || !onScreen(parent)) return;
+        const range = document.createRange();
+        range.selectNodeContents(node);
+        take(range.getBoundingClientRect());
+        return;
+      }
+      node.childNodes.forEach(walk);
+    };
+    walk(cell);
+    for (const drawn of within(cell, DRAWS)) if (onScreen(drawn)) take(drawn.getBoundingClientRect());
+    return right > left ? { left, right } : null;
+  }
+  var laidControls = (cell) => within(cell, CONTROL2).filter((control) => {
+    const rect = control.getBoundingClientRect();
+    const laid = typeof control.checkVisibility !== "function" || control.checkVisibility();
+    return laid && control.closest("[inert]") === null && rect.width > 0 && rect.height > 0;
+  });
+  function occupied(cell) {
+    if (cell === void 0) return 0;
+    const box = cell.getBoundingClientRect();
+    const ink = inkSpan(cell);
+    const spans = [
+      ...ink === null ? [] : [ink],
+      ...laidControls(cell).map((control) => {
+        const rect = control.getBoundingClientRect();
+        return { left: Math.max(rect.left, box.left), right: Math.min(rect.right, box.right) };
+      })
+    ].filter((span) => span.right > span.left);
+    if (spans.length === 0) return 0;
+    return Math.max(...spans.map((span) => span.right)) - Math.min(...spans.map((span) => span.left));
+  }
+  var leavesRoom = (slot, cell, width) => slot.kind === "column" ? occupied(cell) === 0 : width - occupied(cell) >= RESERVED_MIN_WIDTH;
+  var widthOf = (slot) => Math.round(Math.max(0, ...slot.cells.map((cell) => cell === void 0 ? 0 : cell.getBoundingClientRect().width)));
+  function reservedBlanks(root = document.body) {
+    let total = 0;
+    const found = [];
+    for (const register of [...kitRegisters(root), ...ariaRegisters(root)]) {
+      if (register.rows.length === 0) continue;
+      for (const slot of register.slots) {
+        const width = widthOf(slot);
+        if (width < RESERVED_MIN_WIDTH) continue;
+        total += 1;
+        const empty = slot.cells.filter((cell) => leavesRoom(slot, cell, width)).length;
+        if (empty <= register.rows.length * RESERVED_BLANK_SHARE) continue;
+        found.push({ slot: slot.name, kind: slot.kind, width, blank: empty, rows: register.rows.length });
+      }
+    }
+    return { total, blank: found };
+  }
+  function shedOf(register) {
+    const said2 = register.getAttribute("data-shed");
+    if (said2 === null) return [];
+    const parsed = JSON.parse(said2);
+    if (!Array.isArray(parsed)) throw new Error(`data-shed is not a list: ${said2.slice(0, 80)}`);
+    return parsed.map((entry) => {
+      const label = entry !== null && typeof entry === "object" ? Reflect.get(entry, "label") : void 0;
+      const width = entry !== null && typeof entry === "object" ? Reflect.get(entry, "width") : void 0;
+      if (typeof label !== "string" || typeof width !== "number") throw new Error(`data-shed names a column without a label and a width: ${said2.slice(0, 80)}`);
+      return { label, width };
+    });
+  }
+  function spare(slot) {
+    const width = widthOf(slot);
+    if (slot.kind === "gutter") {
+      const used = slot.cells.map(occupied).sort((a, b) => a - b);
+      return Math.max(0, width - (used[Math.floor(used.length * RESERVED_BLANK_SHARE)] ?? 0));
+    }
+    if (slot.heading?.hasAttribute("data-fixed") === true || slot.cells.some((cell) => cell?.hasAttribute("data-fixed") === true)) return 0;
+    const heading = slot.heading === void 0 ? null : inkSpan(slot.heading);
+    const drawn = Math.max(
+      heading === null ? 0 : heading.right - heading.left,
+      ...slot.cells.map((cell) => {
+        const span = cell === void 0 ? null : inkSpan(cell);
+        return span === null ? 0 : span.right - span.left;
+      })
+    );
+    return Math.max(0, width - drawn);
+  }
+  function slotGap(register) {
+    const boxes = register.slots.map((slot) => slot.cells[0]).filter((cell) => cell !== void 0).map((cell) => cell.getBoundingClientRect()).sort((a, b) => a.left - b.left);
+    return boxes.length < 2 ? 0 : Math.max(0, Math.round(boxes[1].left - boxes[0].right));
+  }
+  function shedWithRoom(root = document.body) {
+    let total = 0;
+    const found = [];
+    for (const register of kitRegisters(root)) {
+      const shed = shedOf(register.root);
+      if (shed.length === 0 || register.rows.length === 0) continue;
+      total += shed.length;
+      const unused = Math.round(register.slots.reduce((sum, slot) => sum + spare(slot), 0));
+      const gap = slotGap(register);
+      for (const column of shed) if (column.width + gap <= unused) found.push({ ...column, gap, unused });
+    }
+    return { total, shed: found };
+  }
+  var CREATE = "[data-create]";
+  var ITEM = '.lotics-row, .lotics-table__row, .lotics-table__block, .lotics-timeline__day, .lotics-region-state, [role="row"], [role="listitem"], li';
+  var HEADINGS = 'h1, h2, h3, h4, h5, h6, [role="heading"]';
+  function offHeadingActs(root = document.body) {
+    const section = ".lotics-section";
+    let total = 0;
+    const off = [];
+    for (const one of within(root, section).filter(onScreen)) {
+      const heading = Array.from(one.children).find((child) => child.classList.contains("lotics-section-heading"));
+      if (heading === void 0) continue;
+      const titles = within(one, HEADINGS).filter((title) => inside(title, one, section) && onScreen(title));
+      for (const act of within(one, CREATE)) {
+        if (!onScreen(act) || !inside(act, one, section)) continue;
+        const name = nameOf(act) || words4(act);
+        const item = act.closest(ITEM);
+        if (item !== null && one.contains(item)) continue;
+        let owner;
+        for (const title2 of titles) {
+          if (!title2.contains(act) && (title2.compareDocumentPosition(act) & Node.DOCUMENT_POSITION_FOLLOWING) !== 0) owner = title2;
+        }
+        if (owner !== void 0 && !heading.contains(owner)) continue;
+        total += 1;
+        const said2 = `"${words4(heading.querySelector(HEADINGS)) || words4(heading) || "(untitled)"}": "${name.slice(0, 40)}"`;
+        if (!heading.contains(act)) {
+          off.push(`${said2} drawn in the section's body`);
+          continue;
+        }
+        const title = heading.querySelector(HEADINGS);
+        if (title !== null && !title.contains(act) && act.getBoundingClientRect().top >= title.getBoundingClientRect().bottom) {
+          off.push(`${said2} wrapped under the heading`);
+        }
+      }
+    }
+    return { total, off };
+  }
+  var OF_TOTAL = /^\d[\d.,]*(?:\s*[–-]\s*\d[\d.,]*)?\s*(?:of|trên|\/)\s*(\d[\d.,]*)$/i;
+  var FIGURE = /^\d{1,3}(?:[.,]\d{3})+$|^\d+$/;
+  var figure = (text) => FIGURE.test(text) ? Number(text.replace(/[.,]/g, "")) : null;
+  function statedCounts(root = document.body) {
+    const stated2 = [];
+    for (const el of within(root, "*")) {
+      if (!onScreen(el) || el.closest('nav, [role="banner"]') !== null) continue;
+      const text = words4(el);
+      const total = OF_TOTAL.exec(text);
+      if (total !== null && !Array.from(el.children).some((child) => OF_TOTAL.test(words4(child)))) {
+        const value2 = figure(total[1]);
+        if (value2 !== null) stated2.push({ text, value: value2 });
+        continue;
+      }
+      const holder = el.closest('[role="tab"], .lotics-count');
+      if (el.childElementCount > 0 || holder === null) continue;
+      const value = figure(text);
+      if (value !== null) stated2.push({ text: words4(el.closest('[role="tab"]') ?? holder), value });
+    }
+    return stated2;
+  }
+
   // src/probe_collectors/right_form.ts
   var DAY_RUN_PART = ".lotics-timeline__dayhead";
   var SIDE = 'aside, [role="complementary"], nav, [role="navigation"]';
@@ -1298,14 +1593,14 @@ var __loticsProbe = (() => {
     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 words5 = (el) => el === null ? "" : (el.textContent || "").trim().slice(0, 40);
+    const surfaces2 = within(root, recordSurface).filter(onScreen);
+    const called2 = (el) => words5(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);
+          const named = nameOf(el).slice(0, 40) || words5(el);
           return named === "" ? kind.called : `${kind.called} ("${named}")`;
         }
       }
@@ -1323,7 +1618,7 @@ var __loticsProbe = (() => {
       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)";
+        const named = nameOf(chooser).slice(0, 40) || words5(field === null ? null : field.querySelector(".lotics-form-field__label")) || "(unnamed)";
         pairs.push(`"${named}": a two-option select \u2014 ${options.map((option) => `"${option}"`).join(" / ")}`);
       }
     }
@@ -1419,7 +1714,7 @@ var __loticsProbe = (() => {
     let folds = 0;
     let sections = 0;
     const hidden = [];
-    for (const surface of surfaces) {
+    for (const surface of surfaces2) {
       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;
@@ -1444,7 +1739,7 @@ var __loticsProbe = (() => {
     let split = 0;
     const tracks = [];
     if (window.innerWidth >= twoTrackWidth) {
-      for (const surface of surfaces) {
+      for (const surface of surfaces2) {
         read += 1;
         const box = surface.getBoundingClientRect();
         const owners = [surface, ...Array.from(surface.querySelectorAll("*"))];
@@ -1659,6 +1954,46 @@ var __loticsProbe = (() => {
       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."
     },
+    reserved_blank: {
+      law: "reviewing.md",
+      section: "8l",
+      fix: "Give the room back: a column or row-act gutter most rows leave empty goes, and what the few rows hold rides those rows instead."
+    },
+    shed_with_room: {
+      law: "reviewing.md",
+      section: "8m",
+      fix: "Seat the column the width can hold: reclaim what a slot reserves beyond what it must seat \u2014 a flexible column wider than its ink, a gutter held for acts most rows lack \u2014 before the fit gives a reading up."
+    },
+    action_off_heading: {
+      law: "reviewing.md",
+      section: "8n",
+      fix: "Mount the section's add in its heading row (`RecordSection.action`, a `SectionHeadingAdd`), and let what it opens stand in the body: one place for a section's add, whatever its body draws."
+    },
+    partial_count: {
+      law: "reviewing.md",
+      section: "8o",
+      fix: "State the server's count of the set, never the rows a page loaded: count the read (`useCount`) and step or badge against that total."
+    },
+    record_primary: {
+      law: "hierarchy.md",
+      section: "One primary act per surface",
+      fix: "Draw a section's add secondary (`SectionHeadingAdd`): the record's one primary act is its head's \u2014 the next queued act, else the step its stage leads with."
+    },
+    brief_fold: {
+      law: "hierarchy.md",
+      section: "Depth \u2014 four surfaces, four jobs",
+      fix: "Keep in the brief only what the head's act needs \u2014 the newest entry, the words to say, the one band placed first \u2014 and move the rest to a tab, until its foot is in the first viewport unscrolled."
+    },
+    brief_repeats: {
+      law: "hierarchy.md",
+      section: "One fact, one place",
+      fix: "Take the value out of the brief's band: the head already states it, so the band read under it is the same fact twice."
+    },
+    empty_tab: {
+      law: "hierarchy.md",
+      section: "Depth \u2014 four surfaces, four jobs",
+      fix: "Draw no tab over nothing: a tab is drawn only over a part with a body, so a part with no rows passes none."
+    },
     render: {
       law: "reviewing.md",
       section: "8",
@@ -1831,6 +2166,97 @@ var __loticsProbe = (() => {
         detail: marks.mismatches.slice(0, 5).map((row) => `y=${row.y}: ${row.marks.join(", ")}`)
       });
     }
+    const reserved = reservedBlanks(surface);
+    if (reserved.blank.length > 0) {
+      findings.push({
+        probe: "reserved_blank",
+        ...signature("reserved_blank"),
+        total: reserved.total,
+        count: reserved.blank.length,
+        detail: reserved.blank.slice(0, 5).map(
+          (slot) => `${slot.slot}: ${slot.width}px, ${slot.kind === "gutter" ? `${RESERVED_MIN_WIDTH}px or more beside the acts` : "blank"} on ${slot.blank} of ${slot.rows} rows`
+        )
+      });
+    }
+    const shed = shedWithRoom(surface);
+    if (shed.shed.length > 0) {
+      findings.push({
+        probe: "shed_with_room",
+        ...signature("shed_with_room"),
+        total: shed.total,
+        count: shed.shed.length,
+        detail: shed.shed.slice(0, 5).map((column) => `"${column.label}" (${column.width}px + ${column.gap}px gap) shed beside ${column.unused}px the slots hold beyond what they seat`)
+      });
+    }
+    const adds = offHeadingActs(surface);
+    if (adds.off.length > 0) {
+      findings.push({
+        probe: "action_off_heading",
+        ...signature("action_off_heading"),
+        total: adds.total,
+        count: adds.off.length,
+        detail: adds.off.slice(0, 5)
+      });
+    }
+    const served = options.served;
+    if (served !== void 0) {
+      const stated2 = statedCounts(surface);
+      const partial = stated2.flatMap((count) => {
+        const read = served.reads.find(
+          (one) => one.in_hand === count.value && one.total !== count.value && !served.counted.some((counted) => counted.alias === one.alias && counted.value === count.value)
+        );
+        return read === void 0 ? [] : [`"${count.text}" states ${count.value} \u2014 the rows in hand of "${read.alias}", which the server counts ${read.total}`];
+      });
+      if (partial.length > 0) {
+        findings.push({
+          probe: "partial_count",
+          ...signature("partial_count"),
+          total: stated2.length,
+          count: partial.length,
+          detail: partial.slice(0, 5)
+        });
+      }
+    }
+    const primaries = headingPrimaries(surface);
+    if (primaries.loud.length > 0) {
+      findings.push({
+        probe: "record_primary",
+        ...signature("record_primary"),
+        total: primaries.total,
+        count: primaries.loud.length,
+        detail: primaries.loud.slice(0, 5).map((one) => `"${one.record}": "${one.act}" is primary in a section's heading row, beside the head's act`)
+      });
+    }
+    const folded = briefsBelowFold(surface);
+    if (folded.below.length > 0) {
+      findings.push({
+        probe: "brief_fold",
+        ...signature("brief_fold"),
+        total: folded.total,
+        count: folded.below.length,
+        detail: folded.below.slice(0, 5).map((one) => `"${one.record}": the brief ends at ${one.bottom}px, past the ${folded.fold}px first viewport`)
+      });
+    }
+    const repeats = briefRepeats(surface);
+    if (repeats.repeated.length > 0) {
+      findings.push({
+        probe: "brief_repeats",
+        ...signature("brief_repeats"),
+        total: repeats.total,
+        count: repeats.repeated.length,
+        detail: repeats.repeated.slice(0, 5).map((one) => `"${one.record}": the brief states "${one.value}", which the head already says`)
+      });
+    }
+    const tabs = emptyTabs(surface);
+    if (tabs.empty.length > 0) {
+      findings.push({
+        probe: "empty_tab",
+        ...signature("empty_tab"),
+        total: tabs.total,
+        count: tabs.empty.length,
+        detail: tabs.empty.slice(0, 5).map((one) => `"${one.record}": the tab "${one.tab}" holds nothing`)
+      });
+    }
     findings.push(...censusFindings("clutter", clutterCensus(surface)));
     findings.push(...censusFindings("right_form", rightFormCensus(surface)));
     findings.push(...censusFindings("ink_and_air", [...inkAndAirCensus(surface), ...options.rings ?? []]));