paperlint 13.6.0 → 14.0.0

package/skills/build-label-page/scripts/label-page-core.ts

@@ -8,7 +8,11 @@ import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { z } from "zod";
-import { describeRule, type RuleRef } from "./rule-descriptions.ts";
+import {
+  describeRule,
+  type Described as RuleText,
+  type RuleRef,
+} from "./rule-descriptions.ts";
 
 // ── refusals and output ───────────────────────────────────────────────────────────────────────
 export class Refusal extends Error {
@@ -93,18 +97,22 @@ const readJson = (path: string): Json => {
 // stops the build: a blind page fails by what leaked in, and a field nobody listed is exactly the
 // one nobody thought of. A NEW FIELD IS ADDED HERE ON PURPOSE, after asking "does this tell the
 // labeller what the answer is, or where the item came from?" — never to make a build pass.
-const PAGE_FIELDS = ["group", "title", "body", "code", "context"] as const;
+// prettier-ignore
+const PAGE_FIELDS = ["group", "title", "body", "code", "context", "file"] as const;
 const PRIVATE_FIELDS = ["source_id"] as const;
 // The linter rules an item names ("read as ruff `TID253`"): the page shows each with the linter's
 // own description, looked up at build time (rule-descriptions.ts), never typed into items.json.
 const RULES_FIELD = "rules";
-// One requirement of a line that holds several: the whole line and which part this item is. Shown on
-// the card beneath the item; the line is text the labeller may read, like `context`.
+// The source line an item was drawn from, with its requirement marked (`mark`, words of the line)
+// and which part of the line it is. Shown on the card; the line is text the labeller may read.
 const UNIT_FIELD = "unit";
+// Two readings of one requirement, shown as rows A and B (#374).
+const READINGS_FIELD = "readings";
 const ALLOWED_FIELDS: readonly string[] = [
   ...PAGE_FIELDS,
   RULES_FIELD,
   UNIT_FIELD,
+  READINGS_FIELD,
   ...PRIVATE_FIELDS,
 ];
 
@@ -140,8 +148,9 @@ const SOURCES_SHOWN = `(${SOURCES.map(quoted).join(", ")})`;
 // the field's path (`questions[0].options[1].label`). A NEW FIELD IS A NEW LINE HERE; the
 // build-label-page test walks this very table (`schema` prints it) with a wrong type, null and an
 // empty value for each path, so a field without a line is a test failure, not a review finding.
-// The leak guard on items (ALLOWED_FIELDS) stays separate and stays closed.
-type SchemaNode =
+// The leak guard on items (ALLOWED_FIELDS) stays separate and stays closed. `why` says, in a
+// refusal, what a value must be (a pattern) or why a field is required (a page kind needs it).
+type SchemaNode = (
   | { kind: "string"; required: boolean; pattern?: string }
   | { kind: "integer"; required: boolean }
   | { kind: "boolean"; required: boolean }
@@ -158,12 +167,18 @@ type SchemaNode =
       required: boolean;
       closed: boolean;
       fields: Readonly<Record<string, SchemaNode>>;
-    };
+    }
+) & { why?: string };
 
-const string = (required = true, pattern?: string): SchemaNode =>
+const string = (required = true, pattern?: string, why?: string): SchemaNode =>
   pattern === undefined
     ? { kind: "string", required }
-    : { kind: "string", required, pattern };
+    : {
+        kind: "string",
+        required,
+        pattern,
+        ...(why === undefined ? {} : { why }),
+      };
 const integer = (required = true): SchemaNode => ({
   kind: "integer",
   required,
@@ -195,26 +210,82 @@ const obj = (
   required = true,
 ): SchemaNode => ({ kind: "object", required, closed, fields });
 
-const ITEM_SCHEMA = obj(
-  {
-    source_id: string(),
-    ...Object.fromEntries(
-      PAGE_FIELDS.map((f) => [f, string(f === "group" || f === "body")]),
-    ),
-    [RULES_FIELD]: array(
-      obj({ linter: string(true, "eslint|ruff"), id: string() }),
-      false,
-      1,
-    ),
-    [UNIT_FIELD]: obj(
-      // `id` names one occurrence of the line (two files may hold the same words): never shown.
-      { id: string(), text: string(), part: integer(), of: integer() },
-      true,
-      false,
-    ),
+// What an item and a practice item both may carry beyond text: a practice card looks like the real
+// cards it rehearses. Each is optional here; a page's `kind` makes some of them required (KINDS).
+const CARD_FIELDS: Readonly<Record<string, SchemaNode>> = {
+  [RULES_FIELD]: array(
+    obj({
+      linter: string(true, "eslint|ruff", "eslint or ruff"),
+      id: string(),
+    }),
+    false,
+    1,
+  ),
+  [UNIT_FIELD]: obj(
+    // `id` names one occurrence of the line (two files may hold the same words): never shown.
+    {
+      id: string(),
+      text: string(),
+      mark: string(),
+      part: integer(),
+      of: integer(),
+    },
+    true,
+    false,
+  ),
+  [READINGS_FIELD]: obj({ a: string(), b: string() }, true, false),
+  file: string(false),
+};
+/**
+ * THE PAGE KINDS, and the card fields each requires on every item and practice card (#373). A fix to
+ * a card is a field; a kind that needs it makes it required, so a page built without it fails the
+ * schema with the field named instead of shipping the old card.
+ */
+type Kind = "approval" | "witness" | "labels";
+const KINDS: Readonly<Record<Kind, Readonly<Record<string, string>>>> = {
+  // keep or drop a drawn requirement: the line it came from, marked, and the rule read for it
+  approval: {
+    [UNIT_FIELD]:
+      "an approval card shows the line its requirement was drawn from, the requirement marked",
+    [RULES_FIELD]:
+      "an approval card shows the rule read for it, with the linter's own description",
   },
-  false, // an unlisted item field is the leak guard's refusal, with its own message
-);
+  // why two readings of one requirement disagree on a file
+  witness: {
+    [RULES_FIELD]:
+      "a witness card shows the rule both readings configure, with the linter's description",
+    [READINGS_FIELD]: "a witness card shows the two readings, one row each",
+    file: "a witness card shows the file the readings disagree on, on its own row",
+  },
+  // gold labels, a blind review: the card is the item, nothing more is required
+  labels: {},
+};
+const KIND_NAMES = Object.keys(KINDS).join(", ");
+/** The card fields of a page of `kind`: those it needs, required and saying why. */
+const cardFields = (kind: Kind): Readonly<Record<string, SchemaNode>> =>
+  Object.fromEntries(
+    Object.entries(CARD_FIELDS).map(([name, node]) => {
+      const why = KINDS[kind][name];
+      return [
+        name,
+        why === undefined ? node : { ...node, required: true, why },
+      ];
+    }),
+  );
+const itemSchema = (kind: Kind): SchemaNode =>
+  obj(
+    {
+      source_id: string(),
+      ...Object.fromEntries(
+        PAGE_FIELDS.filter((f) => f !== "file").map((f) => [
+          f,
+          string(f === "group" || f === "body"),
+        ]),
+      ),
+      ...cardFields(kind),
+    },
+    false, // an unlisted item field is the leak guard's refusal, with its own message
+  );
 // `icon` (an emoji) tells the buttons apart at a glance. No coloured side stripe on a button: it
 // reads as decoration, not meaning (the build-label-page look test refuses one).
 // `ask_why` (a prompt) makes the answer incomplete until the labeller says why: an approval page's "drop".
@@ -225,16 +296,18 @@ const OPTION_SCHEMA = obj({
   icon: string(false),
   ask_why: string(false),
 });
-const PRACTICE_SCHEMA = obj({
-  ...Object.fromEntries(
-    PAGE_FIELDS.filter((f) => f !== "group").map((f) => [
-      f,
-      string(f === "body"),
-    ]),
-  ),
-  expected: mapping(string(), NAME_PATTERN, 1),
-  why: string(),
-});
+const practiceSchema = (kind: Kind): SchemaNode =>
+  obj({
+    ...Object.fromEntries(
+      PAGE_FIELDS.filter((f) => f !== "group" && f !== "file").map((f) => [
+        f,
+        string(f === "body"),
+      ]),
+    ),
+    ...cardFields(kind),
+    expected: mapping(string(), NAME_PATTERN, 1),
+    why: string(),
+  });
 const MIN_PRACTICE = 3;
 const QUESTION_SCHEMA = obj({
   id: string(true, NAME_PATTERN),
@@ -242,22 +315,26 @@ const QUESTION_SCHEMA = obj({
   short: string(false),
   options: array(OPTION_SCHEMA, true, 2),
 });
-export const CONFIG_SCHEMA = obj({
-  study: string(true, NAME_PATTERN), // becomes a file name
-  title: string(),
-  intro: string(false),
-  seed: integer(),
-  groups: mapping(string(), NAME_PATTERN, 1), // ids become store document ids
-  labeller_knows: array(string(true, NAME_PATTERN), false),
-  // false: no "how well do you know {group}" question (an approval page: the author has never seen
-  // these repositories, so its answer means nothing). Left out, every group is asked (rule 5).
-  familiarity: boolean(false),
-  familiarity_question: string(false),
-  questions: array(QUESTION_SCHEMA, true, 1),
-  practice: array(PRACTICE_SCHEMA, true, MIN_PRACTICE),
-  practice_round: integer(false),
-  items: array(ITEM_SCHEMA, true, 1),
-});
+const configSchema = (kind: Kind): SchemaNode =>
+  obj({
+    study: string(true, NAME_PATTERN), // becomes a file name
+    kind: string(true, Object.keys(KINDS).join("|"), `one of ${KIND_NAMES}`),
+    title: string(),
+    intro: string(false),
+    seed: integer(),
+    groups: mapping(string(), NAME_PATTERN, 1), // ids become store document ids
+    labeller_knows: array(string(true, NAME_PATTERN), false),
+    // true: a "how well do you know {group}" question per group, for a study that filters on it
+    // (rule 5). Left out, none is asked: an approval page's author has never seen the repositories.
+    familiarity: boolean(false),
+    familiarity_question: string(false),
+    questions: array(QUESTION_SCHEMA, true, 1),
+    practice: array(practiceSchema(kind), true, MIN_PRACTICE),
+    practice_round: integer(false),
+    items: array(itemSchema(kind), true, 1),
+  });
+/** The declared schema (`schema` prints it): every field, those a kind requires left optional. */
+export const CONFIG_SCHEMA = configSchema("labels");
 
 // ── checking a value against the schema ──────────────────────────────────────────────────────
 const at = (path: string, name: string): string =>
@@ -268,13 +345,13 @@ const ID_RULE = "letters, digits, - and _ only";
 
 function checkString(
   value: Json,
-  node: { pattern?: string },
+  node: { pattern?: string; why?: string },
   where: string,
 ): void {
   if (typeof value !== "string" || !value.trim()) {
     fail(`${where}: must be a non-empty string, got ${repr(value)}`);
   } else if (node.pattern !== undefined && !fullMatch(node.pattern, value)) {
-    fail(`${where}: ${repr(value)} must be ${ID_RULE}`);
+    fail(`${where}: ${repr(value)} must be ${node.why ?? ID_RULE}`);
   }
 }
 const checkCount = (n: number, min: number, where: string): void => {
@@ -319,7 +396,10 @@ function checkObject(
     return fail(`${where}: must be an object, got ${repr(value)}`);
   for (const [name, sub] of Object.entries(node.fields)) {
     if (has(value, name)) checkValue(value[name] ?? null, sub, at(path, name));
-    else if (sub.required) fail(`${at(path, name)}: is required and missing`);
+    else if (sub.required)
+      fail(
+        `${at(path, name)}: is required and missing${sub.why === undefined ? "" : ` — ${sub.why}`}`,
+      );
   }
   const unknown = Object.keys(value).find((name) => !has(node.fields, name));
   if (node.closed && unknown !== undefined) {
@@ -375,28 +455,27 @@ interface Question {
 interface Unit {
   readonly id: string;
   readonly text: string;
+  readonly mark: string;
   readonly part: number;
   readonly of: number;
 }
-type Item = {
+/** What a card shows, on an item and on a practice item alike. */
+type Card = {
   readonly [F in (typeof PAGE_FIELDS)[number]]?: string;
 } & {
-  readonly source_id: string;
-  readonly group: string;
   readonly body: string;
   readonly rules?: readonly RuleRef[];
   readonly unit?: Unit;
+  readonly readings?: { readonly a: string; readonly b: string };
 };
-interface Practice {
-  readonly title?: string;
-  readonly body: string;
-  readonly code?: string;
-  readonly context?: string;
+type Item = Card & { readonly source_id: string; readonly group: string };
+type Practice = Card & {
   readonly expected: Readonly<Record<string, string>>;
   readonly why: string;
-}
+};
 interface Config {
   readonly study: string;
+  readonly kind: Kind;
   readonly title: string;
   readonly intro?: string;
   readonly seed: number;
@@ -436,7 +515,7 @@ const allowedValues = (
   // Empty when the page asks no familiarity: the export then expects no group document at all.
   familiarity: asksFamiliarity ? FAMILIARITY.map((o) => o.value) : [],
 });
-const asksFamiliarity = (cfg: Config): boolean => cfg.familiarity !== false;
+const asksFamiliarity = (cfg: Config): boolean => cfg.familiarity === true;
 
 /** Two values that read the same once case and surrounding space are gone. */
 const readsAs = (s: string): string => s.trim().toLowerCase();
@@ -522,7 +601,7 @@ function checkConfig(cfg: Config): void {
   checkGroups(cfg);
   if (!asksFamiliarity(cfg) && cfg.familiarity_question !== undefined) {
     fail(
-      `familiarity_question: ${repr(cfg.familiarity_question)} is never asked, because \`familiarity\` is false — remove one of the two`,
+      `familiarity_question: ${repr(cfg.familiarity_question)} is never asked, because \`familiarity\` is not true — remove it, or set "familiarity": true`,
     );
   }
   cfg.questions.forEach((q, qn) => {
@@ -544,8 +623,9 @@ const practiceOf = (
 // ── the items: the leak guard, and the references to the config ───────────────────────────────
 /**
  * A line with several requirements is split upstream into one item per requirement, each carrying
- * `unit: {text, part, of}`. Every part of a line must be an item, once, in one group (so
- * `labeller_knows` keeps or drops the whole line): a lost part is a requirement nobody judged.
+ * `unit: {text, mark, part, of}`. A drawn sample may hold one part of a line and not the others; the
+ * parts it holds agree on the line, are not repeated, and sit in one group (so `labeller_knows`
+ * keeps or drops them together).
  */
 interface Part {
   readonly item: Item;
@@ -576,10 +656,6 @@ function checkPart({ item, unit, n }: Part, parts: Parts): void {
     fail(
       `${at}.unit.of: ${String(unit.of)}, but items[${String(first.n)}].unit.of says ${String(first.unit.of)} for the same line`,
     );
-  if (unit.part < 1 || unit.part > unit.of)
-    fail(
-      `${at}.unit.part: ${String(unit.part)} is not between 1 and ${String(unit.of)}`,
-    );
   const earlier = parts.find((p) => p.n < n && p.unit.part === unit.part);
   if (earlier !== undefined)
     fail(
@@ -590,21 +666,33 @@ function checkPart({ item, unit, n }: Part, parts: Parts): void {
       `${at}.group: ${repr(item.group)}, but items[${String(first.n)}] of the same line is in ${repr(first.item.group)}`,
     );
 }
+/** One unit on its own: its part in range, and its mark the requirement's words in the line. */
+function checkUnit(unit: Unit | undefined, at: string): void {
+  if (unit === undefined) return;
+  if (unit.part < 1 || unit.part > unit.of)
+    fail(
+      `${at}.unit.part: ${String(unit.part)} is not between 1 and ${String(unit.of)}`,
+    );
+  if (!unit.text.includes(unit.mark))
+    fail(
+      `${at}.unit.mark: ${repr(unit.mark)} is not in the line ${repr(unit.text)} — mark the requirement with the line's own words`,
+    );
+}
 function checkUnits(cfg: Config): void {
-  for (const [line, parts] of linesOf(cfg)) {
+  cardsOf(cfg).forEach(([at, card]) => {
+    checkUnit(card.unit, at);
+  });
+  for (const parts of linesOf(cfg).values()) {
     parts.forEach((p) => {
       checkPart(p, parts);
     });
-    const [first] = parts;
-    const missing = Array.from({ length: first.unit.of }, (_, k) => k + 1).find(
-      (k) => !parts.some((p) => p.unit.part === k),
-    );
-    if (missing !== undefined)
-      fail(
-        `items[${String(first.n)}].unit: part ${String(missing)} of ${String(first.unit.of)} of line ${repr(line)} is not among the items`,
-      );
   }
 }
+/** Every card of the config, items then practice, by path. */
+const cardsOf = (cfg: Config) => [
+  ...cfg.items.map((i, n) => [`items[${String(n)}]`, i] as const),
+  ...cfg.practice.map((p, n) => [`practice[${String(n)}]`, p] as const),
+];
 function checkItemFields(cfg: Config): void {
   const sids: string[] = [];
   cfg.items.forEach((item, n) => {
@@ -631,6 +719,7 @@ function checkItemFields(cfg: Config): void {
 const visibleTexts = (item: Item): readonly (readonly [string, string])[] => [
   ...PAGE_FIELDS.map((f): readonly [string, string] => [f, item[f] ?? ""]),
   [UNIT_FIELD, item.unit?.text ?? ""],
+  [READINGS_FIELD, `${item.readings?.a ?? ""} ${item.readings?.b ?? ""}`],
 ];
 const escapeRegExp = (s: string): string =>
   s.replace(/[\\^$.*+?()[\]{}|/]/g, "\\$&");
@@ -715,11 +804,13 @@ function assignIds(
 }
 
 // ── a build, short of the page ──────────────────────────────────────────────────────────────────
-/** A unit as the page shows it: the part and the line, without the line's private id. */
+/** A unit as the page shows it: the line, its mark and its part, without the line's private id. */
 type ShownUnit = Omit<Unit, "id">;
 const shownFields = (
-  item: Item,
-): Readonly<Record<string, string | ShownUnit>> => ({
+  item: Card,
+): Readonly<
+  Record<string, string | ShownUnit | NonNullable<Card["readings"]>>
+> => ({
   ...Object.fromEntries(
     PAGE_FIELDS.flatMap((f) => {
       const v = item[f];
@@ -731,37 +822,39 @@ const shownFields = (
     : {
         [UNIT_FIELD]: {
           text: item.unit.text,
+          mark: item.unit.mark,
           part: item.unit.part,
           of: item.unit.of,
         },
       }),
+  ...(item.readings === undefined ? {} : { [READINGS_FIELD]: item.readings }),
 });
-/** Rule → the linter's description, for every rule an item on the page names. */
-type Described = ReadonlyMap<string, string>;
+/** Rule → the linter's description (and a ruff rule's family), for every rule a card names. */
+type Described = ReadonlyMap<string, RuleText>;
 const ruleKey = (r: RuleRef): string => `${r.linter} ${r.id}`;
 /** Ask the linter for every rule named; refuse, by path, a rule it cannot describe. */
 function describeRules(cfg: Config, fromDir: string): Described {
   return new Map(
-    cfg.items.flatMap((item, n) =>
-      (item.rules ?? []).map((r, k): readonly [string, string] => {
+    cardsOf(cfg).flatMap(([at, card]) =>
+      (card.rules ?? []).map((r, k): readonly [string, RuleText] => {
         const text = describeRule(r, fromDir);
         return text === undefined
           ? fail(
-              `items[${String(n)}].rules[${String(k)}]: ${r.linter} ${repr(r.id)} has no description from the linter (${r.linter === "ruff" ? "`ruff rule` does not know it, or ruff is not on PATH" : "not a rule of the ESLint, or of a plugin, installed where items.json is"}) — check the id`,
+              `${at}.rules[${String(k)}]: ${r.linter} ${repr(r.id)} has no description from the linter (${r.linter === "ruff" ? "`ruff rule` does not know it, or ruff is not on PATH" : "not a rule of the ESLint, or of a plugin, installed where items.json is"}) — check the id`,
             )
           : [ruleKey(r), text];
       }),
     ),
   );
 }
-const rulesShown = (item: Item, described: Described) =>
-  item.rules === undefined
+const rulesShown = (card: Card, described: Described) =>
+  card.rules === undefined
     ? {}
     : {
-        [RULES_FIELD]: item.rules.map((r) => ({
+        [RULES_FIELD]: card.rules.map((r) => ({
           linter: r.linter,
           id: r.id,
-          description: String(described.get(ruleKey(r))),
+          ...described.get(ruleKey(r)),
         })),
       };
 
@@ -780,6 +873,15 @@ function itemsOnPage(cfg: Config, keyPath: string) {
 }
 const practiceRound = (cfg: Config): number => cfg.practice_round ?? 1;
 
+/** The practice as its cards show it, with the answers the page checks against. */
+const practiceShown = (cfg: Config, described: Described) =>
+  practiceOf(cfg).map((p) => ({
+    id: p.id,
+    expected: p.expected,
+    why: p.why,
+    ...shownFields(p),
+    ...rulesShown(p, described),
+  }));
 /** What a page shows: the questions, the practice and the items, blind, with their neutral ids. */
 function payloadOf(
   cfg: Config,
@@ -799,7 +901,10 @@ function payloadOf(
     familiarity: asksFamiliarity(cfg) ? FAMILIARITY : [],
     allowed: allowedValues(cfg.questions, asksFamiliarity(cfg)),
     questions: cfg.questions,
-    practice: { round: practiceRound(cfg), items: practiceOf(cfg) },
+    practice: {
+      round: practiceRound(cfg),
+      items: practiceShown(cfg, described),
+    },
     items: page.items.map((i) => ({
       id: page.idOf(i),
       ...shownFields(i),
@@ -880,6 +985,8 @@ function keyOf(
 export function prepareBuild(configPath: string, outDir: string) {
   const cfg = readJson(configPath);
   assertConfig(cfg);
+  // Once its `kind` is known to be one, the fields that kind needs on every card.
+  checkValue(cfg, configSchema(cfg.kind), "");
   checkConfig(cfg);
   checkItemFields(cfg);
   checkUnits(cfg);
@@ -1119,7 +1226,7 @@ function checkNoFamiliarity(dump: JsonObject, allowed: Allowed): void {
   const [first] = Object.keys(groups).sort(byText);
   if (allowed.familiarity.length === 0 && first !== undefined) {
     fail(
-      `groups/${first}: familiarity is off for this page (items.json \`familiarity: false\`), so no group document is expected — take it out of the dump`,
+      `groups/${first}: familiarity is off for this page (items.json does not set \`"familiarity": true\`), so no group document is expected — take it out of the dump`,
     );
   }
 }

package/skills/build-label-page/scripts/label-page-html.test.ts

@@ -412,29 +412,52 @@ test("🔴 without the store the page is read-only, and the real items stay read
   assert.match(shown, /G001/, "a real item is shown read-only");
 });
 
-test("🔴 an item that names a rule: its card says which rule and what it does, in the linter's words", async () => {
+test("🔴 a card shows each field on its own labelled row: the line with its requirement marked, the rule, readings A and B, the file", async () => {
+  const line = "TypeScript only (no JavaScript); top-level await is allowed.";
+  const card = {
+    body: "top-level await is allowed",
+    unit: {
+      id: "L1",
+      text: line,
+      mark: "top-level await is allowed",
+      part: 2,
+      of: 2,
+    },
+    rules: [{ linter: "eslint", id: "no-console" }],
+    readings: { a: "allows it", b: "forbids it" },
+    file: "`src/a.ts`: B flags it",
+  };
   const { page } = build(
     setup(
-      "rules-card",
-      config({
-        items: ITEMS.map((item, n) =>
-          n === 0
-            ? { ...item, rules: [{ linter: "eslint", id: "no-console" }] }
-            : item,
-        ),
-      }),
+      "card-rows",
+      config({ items: ITEMS.map((i, n) => (n === 0 ? { ...i, ...card } : i)) }),
     ),
   );
-  const shown = await showPage(page, {}, {});
-  assert.match(
-    shown,
-    /Rule eslint no-console: Disallow the use of \nconsole\n/,
-    shown,
+  const { app } = await openLive(page, { practice: DONE_PRACTICE });
+  // Guards: a short label per row, in this order, the two readings told apart by their class.
+  assert.deepEqual(
+    app
+      .all()
+      .filter((n) => n.className.startsWith("row"))
+      .map((n) => [n.className, ...n.children.map((c) => c.textContent)]),
+    [
+      [
+        "row",
+        "Line · part 2 of 2",
+        "TypeScript only (no JavaScript); \ntop-level await is allowed\n.",
+      ],
+      ["row", "Rule", "eslint \nno-console\n: Disallow the use of \nconsole"],
+      ["row reading a", "Reading A", "allows it"],
+      ["row reading b", "Reading B", "forbids it"],
+      ["row", "File", "src/a.ts\n: B flags it"],
+    ],
   );
-  assert.equal(
-    occurrences(shown, "Rule eslint"),
-    1,
-    "only the item that names it",
+  assert.deepEqual(
+    app
+      .all()
+      .filter((n) => n.tag === "mark")
+      .map((n) => n.textContent),
+    ["top-level await is allowed"],
   );
 });
 
@@ -459,41 +482,3 @@ test("🔴 familiarity off: no group asks how well it is known, and a group is d
   assert.doesNotMatch(shown, /how well you know it/);
   assert.match(shown, /Nothing left/, shown);
 });
-
-test("🔴 one requirement of a line: its card shows which part it is and the whole line beneath", async () => {
-  const line = "TypeScript only (no JavaScript); top-level await is allowed.";
-  const { page } = build(
-    setup(
-      "unit-card",
-      config({
-        items: ITEMS.map((item, n) =>
-          n === 0
-            ? {
-                ...item,
-                body: "TypeScript only (no JavaScript)",
-                unit: { id: "L1", text: line, part: 1, of: 2 },
-              }
-            : n === 3
-              ? {
-                  ...item,
-                  body: "top-level await is allowed",
-                  unit: { id: "L1", text: line, part: 2, of: 2 },
-                }
-              : item,
-        ),
-      }),
-    ),
-  );
-  const shown = await showPage(page, {}, {});
-  assert.match(
-    shown,
-    /From the line \(requirement 1 of 2\):\nTypeScript only \(no JavaScript\); top-level await is allowed\./,
-    shown,
-  );
-  assert.match(shown, /From the line \(requirement 2 of 2\):/);
-  assert.equal(
-    occurrences(shown, "From the line"),
-    2,
-    "only the two parts carry the line",
-  );
-});