paperlint 14.1.0 → 14.3.0

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

@@ -0,0 +1,381 @@
+/**
+ * Two people answer the same page (`answerers`), and a card must be on screen a while before its
+ * answer saves (`min_seconds`): the build's checks, the key, the dump check and the export. The page
+ * itself is label-page-browser.test.ts. Each check both ways: quiet on a good input, refusing a bad one.
+ */
+import assert from "node:assert/strict";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import * as R from "remeda";
+import { test } from "vitest";
+import { z } from "zod";
+import {
+  DONE_PRACTICE,
+  ITEMS,
+  config,
+  exportAt,
+  labelsFile,
+  run,
+  setup,
+} from "../../../test/label-page-kit.ts";
+
+/** Four items: three shown to both answerers, the fourth to `author` only. */
+const FOUR = [
+  ...ITEMS.slice(0, 3),
+  R.merge(ITEMS[3], { answerers: ["author"] }),
+];
+const TWO = (over: Record<string, unknown> = {}) =>
+  config({ answerers: ["author", "second"], items: FOUR, ...over });
+
+const RawKey = z
+  .object({
+    answerers: z.array(z.string()).optional(),
+    min_seconds: z.number().optional(),
+    ids: z.record(
+      z.string(),
+      z
+        .object({ source_id: z.string(), answerers: z.unknown().optional() })
+        .loose(),
+    ),
+  })
+  .loose();
+const keyOf = (dir: string) =>
+  RawKey.parse(JSON.parse(readFileSync(join(dir, "out", "key.json"), "utf8")));
+const buildAt = (dir: string) =>
+  run(["build", join(dir, "items.json"), join(dir, "out")]);
+/** The neutral id of the item drawn from `case-<n>`. */
+const nidOf = (dir: string, n: number): string => {
+  const hit = R.entries(keyOf(dir).ids).find(
+    ([, v]) => v.source_id === `case-${String(1000 + n)}`,
+  );
+  assert.ok(hit !== undefined);
+  return hit[0];
+};
+const dumpAt = (dir: string, dump: unknown): void => {
+  writeFileSync(join(dir, "dump.json"), JSON.stringify(dump));
+};
+const prefixed = (who: string, docs: Record<string, unknown>) =>
+  R.mapKeys(docs, (k) => `${who}~${k}`);
+
+test("🔴 build refuses answerers that two people could not tell apart, and an item's subset naming someone unknown", () => {
+  const cases: readonly (readonly [string, Record<string, unknown>, string])[] =
+    [
+      [
+        "one",
+        { answerers: ["author"] },
+        "answerers: needs 2 or more entries, has 1",
+      ],
+      [
+        "twice",
+        { answerers: ["author", "second", "author"] },
+        "answerers[2]: 'author' is repeated",
+      ],
+      [
+        "separator",
+        { answerers: ["author", "a~b"] },
+        "answerers[1]: 'a~b' must be letters",
+      ],
+      [
+        "unknown",
+        {
+          answerers: ["author", "second"],
+          items: [{ ...ITEMS[0], answerers: ["third"] }],
+        },
+        "items[0].answerers[0]: 'third' is not in `answerers` (author, second)",
+      ],
+      [
+        "item-twice",
+        {
+          answerers: ["author", "second"],
+          items: [{ ...ITEMS[0], answerers: ["second", "second"] }],
+        },
+        "items[0].answerers[1]: 'second' is repeated",
+      ],
+      [
+        "no-page-list",
+        { items: [{ ...ITEMS[0], answerers: ["author"] }] },
+        "items[0].answerers: the page has no `answerers` — add the page's list, or take this out",
+      ],
+      ["zero", { min_seconds: 0 }, "min_seconds: 0 — must be 1 or more"],
+    ];
+  for (const [name, over, message] of cases) {
+    const r = buildAt(setup(`answerers-refuse-${name}`, config(over)));
+    assert.notEqual(r.status, 0, name);
+    assert.ok(r.out.includes(`REFUSED: ${message}`), `${name}\n${r.out}`);
+  }
+});
+
+test("🔴 the key carries the answerers, each item's own subset and min_seconds; the page gets them", () => {
+  const dir = setup("answerers-key", TWO({ min_seconds: 30 }));
+  const r = buildAt(dir);
+  assert.equal(r.status, 0, r.out);
+  const key = keyOf(dir);
+  assert.deepEqual(key.answerers, ["author", "second"]);
+  assert.equal(key.min_seconds, 30);
+  assert.deepEqual(key.ids[nidOf(dir, 3)]?.answerers, ["author"]);
+  assert.equal(key.ids[nidOf(dir, 0)]?.answerers, undefined);
+  const page = readFileSync(join(dir, "out", "page.html"), "utf8");
+  assert.match(page, /"answerers": \["author", "second"\]/);
+  assert.match(page, /"min_seconds": 30/);
+  assert.match(page, /"answerers": \["author"\]/);
+});
+
+/** What the export writes for one stored document of the page's own: no reason, saved now. */
+const exported = (
+  answers: Record<string, string | null>,
+  more: Record<string, unknown> = {},
+) =>
+  R.merge(
+    {
+      answers,
+      invalid_answers: {},
+      reasons: {},
+      unexplained: [],
+      complete: Object.values(answers).every((v) => v !== null),
+      source: "page",
+      saved_at: null,
+    },
+    more,
+  );
+const YES = { label: "yes", boundary: "clear" };
+const NONE = { label: null, boundary: null };
+const noFamiliarity = { familiarity: null, invalid_familiarity: null };
+
+test("🔴 without answerers or min_seconds, the key, the page data and the export are what they were", () => {
+  const dir = setup("answerers-none", config({ items: ITEMS.slice(0, 2) }));
+  assert.equal(buildAt(dir).status, 0);
+  const rawKey = readFileSync(join(dir, "out", "key.json"), "utf8");
+  assert.doesNotMatch(rawKey, /answerers|min_seconds/);
+  const page = readFileSync(join(dir, "out", "page.html"), "utf8");
+  assert.doesNotMatch(page, /"answerers"|"min_seconds"/);
+  const [a, b] = [nidOf(dir, 0), nidOf(dir, 1)];
+  const saved = "2026-01-02T10:00:00Z";
+  dumpAt(dir, {
+    answers: { [a]: { answers: YES, savedAt: saved, source: "page" } },
+    groups: { rust: { familiarity: "well", source: "page" } },
+    practice: DONE_PRACTICE,
+  });
+  const r = exportAt(dir);
+  assert.equal(r.status, 0, r.out);
+  // The labels list the items in id order.
+  const items = R.sortBy(
+    [
+      [
+        a,
+        exported(YES, {
+          id: a,
+          source_id: "case-1000",
+          group: "rust",
+          saved_at: saved,
+        }),
+      ],
+      [
+        b,
+        exported(NONE, {
+          id: b,
+          source_id: "case-1001",
+          group: "python",
+          source: null,
+        }),
+      ],
+    ] as const,
+    ([id]) => id,
+  ).map(([, item]) => item);
+  assert.deepEqual(JSON.parse(labelsFile(dir)), {
+    study: "demo-gold",
+    exported: "2026-01-02",
+    questions: ["label", "boundary"],
+    items,
+    // Object keys compare in any order: deepEqual reads them as a set.
+    groups: {
+      rust: R.merge(noFamiliarity, {
+        familiarity: "well",
+        source: "page",
+        saved_at: null,
+      }),
+      python: R.merge(noFamiliarity, { source: null, saved_at: null }),
+    },
+    complete_items: 1,
+    invalid_items: 0,
+    invalid_groups: 0,
+    total_items: 2,
+  });
+});
+
+/** The four-item page answered by both: author all but one, second one of three; then exported. */
+function exportTwo() {
+  const dir = setup("answerers-export", TWO({ min_seconds: 30 }));
+  assert.equal(buildAt(dir).status, 0);
+  const [a, d] = [nidOf(dir, 0), nidOf(dir, 3)];
+  const no = { label: "no", boundary: "clear" };
+  dumpAt(dir, {
+    answers: {
+      [`author~${a}`]: { answers: YES, seconds: 41, source: "page" },
+      [`second~${a}`]: { answers: no, seconds: 33, source: "page" },
+      [`author~${d}`]: { answers: YES, seconds: 30, source: "page" },
+    },
+    groups: { "author~rust": { familiarity: "well", source: "page" } },
+    practice: {
+      ...prefixed("author", DONE_PRACTICE),
+      "second~r1-P1": { answers: YES, source: "page" },
+    },
+  });
+  const r = exportAt(dir);
+  assert.equal(r.status, 0, r.out);
+  const file = z
+    .object({
+      answerers: z.array(z.string()),
+      items: z.array(
+        z
+          .object({
+            id: z.string(),
+            by_answerer: z.record(z.string(), z.unknown()),
+          })
+          .loose(),
+      ),
+      by_answerer: z.record(
+        z.string(),
+        z.object({
+          complete_items: z.number(),
+          total_items: z.number(),
+          groups: z.record(z.string(), z.unknown()),
+        }),
+      ),
+    })
+    .loose()
+    .parse(JSON.parse(labelsFile(dir)));
+  return { dir, out: r.out, file, a, d, no };
+}
+
+test("🔴 export keeps each answerer's answers to an item apart, with the seconds on screen", () => {
+  const { file, a, d, no } = exportTwo();
+  assert.deepEqual(file.answerers, ["author", "second"]);
+  assert.deepEqual(
+    file.items.find((i) => i.id === a),
+    {
+      id: a,
+      source_id: "case-1000",
+      group: "rust",
+      answerers: ["author", "second"],
+      by_answerer: {
+        author: exported(YES, { seconds: 41 }),
+        second: exported(no, { seconds: 33 }),
+      },
+    },
+  );
+  assert.deepEqual(
+    Object.keys(file.items.find((i) => i.id === d)?.by_answerer ?? { none: 1 }),
+    ["author"],
+  );
+});
+
+test("🔴 export counts, reports and scores the practice per answerer", () => {
+  const { dir, out, file } = exportTwo();
+  assert.deepEqual(
+    R.mapValues(file.by_answerer, (c) => [
+      c.complete_items,
+      c.total_items,
+      R.keys(c.groups).sort(),
+    ]),
+    {
+      author: [2, 4, ["go", "python", "rust"]],
+      second: [1, 3, ["go", "python", "rust"]],
+    },
+  );
+  assert.match(
+    out,
+    /author: 2 of 4 items complete; second: 1 of 3 items complete/,
+  );
+  assert.match(
+    out,
+    new RegExp(`incomplete second~${nidOf(dir, 1)}: missing label, boundary`),
+  );
+  assert.match(out, /group second~rust: no familiarity answer/);
+  // Each answerer's practice is scored on its own, into its own file.
+  assert.match(out, /practice round 1 \(author\): 3 of 3 matched/);
+  assert.match(
+    out,
+    /practice round 1 \(second\): 1 of 3 matched; missed P2, P3/,
+  );
+  const second = z
+    .object({ answerer: z.string(), matched: z.number() })
+    .loose()
+    .parse(
+      JSON.parse(
+        readFileSync(
+          join(dir, "data", "demo-gold-practice-r1-second-2026-01-02.json"),
+          "utf8",
+        ),
+      ),
+    );
+  assert.deepEqual([second.answerer, second.matched], ["second", 1]);
+});
+
+test("🔴 export refuses a document of no answerer, of an unknown one, or of an item not shown to its answerer", () => {
+  const dir = setup("answerers-refuse-dump", TWO({ min_seconds: 30 }));
+  assert.equal(buildAt(dir).status, 0);
+  const [a, d] = [nidOf(dir, 0), nidOf(dir, 3)];
+  const doc = { answers: { label: "yes" }, source: "page" };
+  const cases: readonly (readonly [string, unknown, string])[] = [
+    [
+      "plain",
+      { answers: { [a]: doc } },
+      `answers/${a}: this page has answerers (author, second), so a document's id is <answerer>~<id>`,
+    ],
+    [
+      "stranger",
+      { answers: { [`third~${a}`]: doc } },
+      `answers/third~${a}: 'third' is not an answerer of this page (author, second)`,
+    ],
+    [
+      "not-shown",
+      { answers: { [`second~${d}`]: doc } },
+      `answers/second~${d}: the key does not know this answer for second`,
+    ],
+    [
+      "group-plain",
+      { groups: { rust: { familiarity: "well", source: "page" } } },
+      "groups/rust: this page has answerers",
+    ],
+    [
+      "practice-unknown",
+      { practice: { "second~r1-P9": { answers: {}, source: "page" } } },
+      "practice/second~r1-P9: the key does not know this practice item",
+    ],
+    [
+      "seconds",
+      {
+        answers: {
+          [`author~${a}`]: R.merge(doc, { seconds: "long" }),
+        },
+      },
+      `answers/author~${a}/seconds: 'long' — must be a whole number of seconds or null`,
+    ],
+  ];
+  for (const [name, dump, message] of cases) {
+    dumpAt(dir, dump);
+    const r = exportAt(dir);
+    assert.notEqual(r.status, 0, name);
+    assert.ok(r.out.includes(`REFUSED: ${message}`), `${name}\n${r.out}`);
+  }
+});
+
+test("🔴 without answerers, a prefixed document id is a document the key does not know", () => {
+  const dir = setup("answerers-none-prefixed", config());
+  assert.equal(buildAt(dir).status, 0);
+  const a = nidOf(dir, 0);
+  dumpAt(dir, {
+    answers: { [`author~${a}`]: { answers: {}, source: "page" } },
+  });
+  const r = exportAt(dir);
+  assert.notEqual(r.status, 0);
+  assert.match(r.out, new RegExp(`answers/author~${a}: the key does not know`));
+  // Nor does a page built without min_seconds store seconds.
+  dumpAt(dir, {
+    answers: { [a]: { answers: {}, seconds: 3, source: "page" } },
+  });
+  assert.match(
+    exportAt(dir).out,
+    new RegExp(`answers/${a}/seconds: not a field of a stored answer`),
+  );
+});

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

@@ -8,8 +8,10 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { test } from "vitest";
+import * as R from "remeda";
 import { z } from "zod";
 import {
+  type FakeNode,
   build,
   openLive,
   run,
@@ -204,7 +206,7 @@ const inOrder = (text: string, parts: readonly string[]): readonly string[] => {
   );
 };
 
-test("🔴 a card reads top to bottom: its place and body in the page's words, the repeat, the situation, the excerpt with its marked line labelled and its caption, the question and its answers, then the references, the list and the table, each folded", async () => {
+test("🔴 a card reads top to bottom: its place and body in the page's words, the repeat, the situation, the excerpt with its marked line labelled and its caption, the question and its answers, then the references, the list and the table, each in place", async () => {
   const { page: html, key } = build(setup("blocks-face", page()));
   const shown = await showPage(html, {}, {}, PRACTICE_DONE);
   const id = Object.entries(key.ids).find(
@@ -333,3 +335,277 @@ test("🔴 `labels.line_part` names a unit row whose line holds several requirem
     [true, true],
   );
 });
+
+// ── the approved card (#392): quote, terms with notes, answer sub-lines, the annotated excerpt ──
+const V7 = z
+  .object({ items: z.array(z.record(z.string(), z.unknown())) })
+  .loose()
+  .parse(
+    JSON.parse(
+      readFileSync(
+        join(import.meta.dirname, "fixtures", "v7-cards-items.json"),
+        "utf8",
+      ),
+    ),
+  );
+/** The v7 fixture without its time on screen, its first card changed by `change`. */
+const v7 = (
+  change: (
+    i: Record<string, unknown>,
+  ) => Record<string, unknown> = R.identity(),
+): Record<string, unknown> => ({
+  ...R.omit(V7, ["min_seconds"]),
+  items: V7.items.map((i, n) => (n === 0 ? change(i) : i)),
+});
+const V7_DONE = Object.fromEntries(
+  ["forbid", "allow", "elsewhere"].map((v, n) => [
+    `r1-P${String(n + 1)}`,
+    { answers: { forbid: v }, source: "page" },
+  ]),
+);
+const V7_REFUSED: readonly (readonly [
+  string,
+  Record<string, unknown>,
+  string,
+])[] = [
+  [
+    "v7-term-not-shown",
+    v7((i) => ({
+      ...i,
+      terms: [
+        {
+          term: "NumPy",
+          note: [{ quote: "q", url: "https://e.x/", url_label: "u" }],
+        },
+      ],
+    })),
+    "items[0].terms[0].term: 'NumPy' is not in the card's annotation, quote or quote source — a note opens from words the card shows",
+  ],
+  [
+    "v7-term-across-backticks",
+    v7((i) => ({
+      ...i,
+      terms: [
+        {
+          term: "rule D413",
+          note: [{ quote: "q", url: "https://e.x/", url_label: "u" }],
+        },
+      ],
+    })),
+    "items[0].terms[0].term: 'rule D413' is not in the card's annotation, quote or quote source — a note opens from words the card shows",
+  ],
+  [
+    "v7-terms-overlap",
+    v7((i) => ({
+      ...i,
+      terms: [
+        {
+          term: "Ruff",
+          note: [{ quote: "q", url: "https://e.x/", url_label: "u" }],
+        },
+        {
+          term: "Ruff rule",
+          note: [{ quote: "q", url: "https://e.x/", url_label: "u" }],
+        },
+      ],
+    })),
+    "items[0].terms[0].term: 'Ruff' is inside items[0].terms[1].term 'Ruff rule' — the page draws one of two overlapping terms, so the other note never opens",
+  ],
+  [
+    "v7-terms-twice",
+    v7((i) => ({
+      ...i,
+      terms: ["Ruff", "Ruff"].map((term) => ({
+        term,
+        note: [{ quote: "q", url: "https://e.x/", url_label: "u" }],
+      })),
+    })),
+    "items[0].terms[0].term: 'Ruff' is inside items[0].terms[1].term 'Ruff' — the page draws one of two overlapping terms, so the other note never opens",
+  ],
+  [
+    "v7-note-without-words",
+    v7((i) => ({
+      ...i,
+      terms: [
+        {
+          term: "Ruff",
+          note: [{ says: "a linter", url: "https://e.x/", url_label: "u" }],
+        },
+      ],
+    })),
+    "items[0].terms[0].note[0]: has neither `quote` nor `code` — a note shows its source's own words",
+  ],
+  [
+    "v7-note-unknown-question",
+    v7((i) => ({ ...i, answer_notes: { applies: { forbid: "x" } } })),
+    "items[0].answer_notes.applies: not a question of this page (forbid)",
+  ],
+  [
+    "v7-note-unknown-answer",
+    v7((i) => ({ ...i, answer_notes: { forbid: { maybe: "x" } } })),
+    "items[0].answer_notes.forbid.maybe: not one of forbid, allow, unsettled, elsewhere, cannot",
+  ],
+  [
+    "v7-no-words",
+    v7((i) => R.omit(i, ["quote"])),
+    "items[0].body: is required and missing — a card shows its `body`, or its words as a `quote`",
+  ],
+];
+
+test("🔴 the card text refuses a term the card does not show (or that spans a backtick), a note entry without a quote or a snippet, an answer note on an unknown question or answer, and a card with neither body nor quote", () => {
+  assert.deepEqual(
+    V7_REFUSED.map(([name, cfg]) => {
+      const dir = setup(name, cfg);
+      return run(["build", join(dir, "items.json"), join(dir, "out")]);
+    }),
+    V7_REFUSED.map(([, , message]) => ({
+      status: 1,
+      out: `REFUSED: ${message}\n`,
+    })),
+  );
+});
+
+/** The v7 fixture's first card, as the fixture writes it. */
+const V7_CARD = z
+  .object({
+    source_id: z.string(),
+    quote: z.object({ text: z.string(), source: z.string() }),
+    excerpt: z.object({
+      file: z.string(),
+      lang: z.string(),
+      annotation: z.string(),
+      lines: z.array(
+        z.object({
+          n: z.number(),
+          mark: z.boolean(),
+          context: z.boolean().optional(),
+          gutter: z.string().optional(),
+        }),
+      ),
+    }),
+    answer_notes: z.object({ forbid: z.record(z.string(), z.string()) }),
+  })
+  .loose()
+  .parse(V7.items[0]);
+const V7_QUESTION = z
+  .object({
+    questions: z.tuple([
+      z.object({
+        id: z.string(),
+        short: z.string(),
+        options: z.array(z.object({ value: z.string() })),
+      }),
+    ]),
+  })
+  .loose()
+  .parse(V7).questions[0];
+/** A fixture text as the page shows it: its `backticks` are code spans, not characters. */
+const unticked = (text: string): string => text.split("`").join("");
+/** What a node shows, with the fake DOM's line breaks between elements taken out. */
+const shownBy = (n: FakeNode): string => n.textContent.replace(/\n/g, "");
+/** The kinds of the card's parts, in the order they appear. */
+const KINDS = [
+  "excerpt-path",
+  "code-line",
+  "gap",
+  "annotation",
+  "quote",
+  "quote-source",
+  "question",
+  "answer",
+  "answer-sub",
+  "status",
+];
+
+/** What the card shows, read from the page: every part's values, its text, and the order of the parts. */
+function shownFacts(card: FakeNode) {
+  const of = (kind: string) => card.getByTestId(kind);
+  const texts = (kind: string) => of(kind).map(shownBy);
+  return {
+    path: of("excerpt-path").map((n) => n.meta()),
+    lines: of("code-line").map((n) => n.meta()),
+    gaps: of("gap").map((n) => n.meta()),
+    annotation: [of("annotation").map((n) => n.meta()), texts("annotation")],
+    quote: texts("quote"),
+    source: texts("quote-source"),
+    answers: of("answer").map((n) => n.meta()),
+    subs: of("answer-sub").map((n) => [n.meta(), shownBy(n)]),
+    status: [of("status").map((n) => n.meta()), texts("status")],
+    order: card
+      .all()
+      .map((n) => n.getAttribute("data-test") ?? "")
+      .filter((k) => KINDS.includes(k)),
+  };
+}
+/** The same facts, as the fixture states them. */
+function fixtureFacts() {
+  const lines = V7_CARD.excerpt.lines;
+  const notes = V7_CARD.answer_notes.forbid;
+  const noted = V7_QUESTION.options.filter((o) => o.value in notes);
+  return {
+    path: [{ file: V7_CARD.excerpt.file, lang: V7_CARD.excerpt.lang }],
+    lines: lines.map((l) => ({
+      line: l.n,
+      marked: l.mark,
+      gutter: l.gutter ?? "",
+      context: l.context ?? false,
+    })),
+    gaps: R.zip(lines, lines.slice(1))
+      .filter(([a, b]) => b.n > a.n + 1)
+      .map(([a, b]) => ({ from: a.n + 1, to: b.n - 1 })),
+    annotation: [
+      [{ line: lines.find((l) => l.mark)?.n }],
+      [unticked(V7_CARD.excerpt.annotation)],
+    ],
+    quote: [unticked(V7_CARD.quote.text)],
+    source: [unticked(V7_CARD.quote.source)],
+    answers: V7_QUESTION.options.map((o) => ({
+      question: V7_QUESTION.id,
+      value: o.value,
+    })),
+    subs: noted.map((o) => [
+      { question: V7_QUESTION.id, value: o.value },
+      unticked(notes[o.value] ?? ""),
+    ]),
+    status: [
+      [{ state: "missing", missing: [V7_QUESTION.id] }],
+      [`Still needs: ${V7_QUESTION.short}`],
+    ],
+    order: [
+      "excerpt-path",
+      ...lines.flatMap((l, n) => [
+        ...(l.n > (lines[n - 1]?.n ?? l.n) + 1 ? ["gap"] : []),
+        "code-line",
+        ...(l.mark ? ["annotation"] : []),
+      ]),
+      "quote",
+      "quote-source",
+      "question",
+      ...V7_QUESTION.options.flatMap((o) =>
+        o.value in notes ? ["answer", "answer-sub"] : ["answer"],
+      ),
+      "status",
+    ],
+  };
+}
+
+test("🔴 an approved card reads top to bottom: its path, the code with a gap row for what it leaves out, the marked line and the note under it, the quote, its source, the question, each answer with its sub-line, then what it still needs", async () => {
+  const { page: html, key } = build(setup("v7-face", v7()));
+  const { app } = await openLive(html, { practice: V7_DONE });
+  const id = Object.entries(key.ids).find(
+    ([, v]) => v.source_id === V7_CARD.source_id,
+  )?.[0];
+  const card = app
+    .getByTestId("item")
+    .find((n) => z.object({ id: z.string() }).parse(n.meta()).id === id);
+  assert.ok(id !== undefined && card !== undefined, "the card is drawn");
+  assert.deepEqual(shownFacts(card), fixtureFacts());
+  // Guards: the question's id is not what the line prints; no generator word names a section.
+  assert.notEqual(V7_QUESTION.short, `${V7_QUESTION.id}?`);
+  assert.deepEqual(
+    ["◀ this line", "Requirement", "REQUIREMENT", "CODE"].filter((w) =>
+      shownBy(card).includes(w),
+    ),
+    [],
+  );
+});