paperlint 13.4.0 → 13.5.0

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

@@ -12,6 +12,7 @@ type Json = null | boolean | number | string | readonly Json[] | {
 type JsonObject = {
     readonly [key: string]: Json;
 };
+declare const PAGE_FIELDS: readonly ["group", "title", "body", "code", "context"];
 type SchemaNode = {
     kind: "string";
     required: boolean;
@@ -53,9 +54,19 @@ interface Question {
     readonly short?: string;
     readonly options: readonly Option[];
 }
-type Item = Readonly<Record<string, string>> & {
+interface Unit {
+    readonly id: string;
+    readonly text: string;
+    readonly part: number;
+    readonly of: number;
+}
+type Item = {
+    readonly [F in (typeof PAGE_FIELDS)[number]]?: string;
+} & {
     readonly source_id: string;
     readonly group: string;
+    readonly body: string;
+    readonly unit?: Unit;
 };
 interface Practice {
     readonly title?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paperlint",
-  "version": "13.4.0",
+  "version": "13.5.0",
   "description": "A linter for scientific papers written in LaTeX: catches mistakes before you submit to a conference or journal.",
   "type": "module",
   "license": "MIT",

package/skills/build-label-page/references/closed-choice-generator.md

@@ -37,8 +37,16 @@ length.
 - **`practice_round`**: raise it after rewording a question; the practice reopens and the answers of
   the earlier round are kept but not counted.
 - **`items`**: `source_id` (the study's own, never shown), `group`, `body`, and optionally `title`,
-  `code`, `context`. Nothing else: the allow-list is fixed in the generator, and a field outside it
+  `code`, `context`, `unit`. Nothing else: the allow-list is fixed in the generator, and a field outside it
   is taken out of the item, not added to the list to make a build pass.
+- **`unit`**: `{id, text, part, of}` on an item that is one requirement of a line holding several
+  ("TypeScript only (no JavaScript); top-level await is allowed" is two). Each requirement is its
+  own item with its own question, and its card shows "From the line (requirement 1 of 2):" and the
+  whole line beneath, so the labeller judges one requirement at a time and sees where it came from.
+  The build refuses a line whose parts do not add up (one missing, repeated, a different `of`, or
+  split across groups), naming the item. `id` names one occurrence of the line (a file and line
+  number, say) and is never shown: two files holding the same words are two lines, each judged in
+  full. Splitting the line is the study's job, before the page.
 - **`seed`**: fixes the order. Rebuilding with the same seed keeps every id, and a new item gets the
   next one; a different seed is refused once a key exists.
 - **`ask_why`** on an option: a prompt. That answer is incomplete, on the page and in the export,

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

@@ -89,7 +89,14 @@ const readJson = (path) => {
 // 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"];
 const PRIVATE_FIELDS = ["source_id"];
-const ALLOWED_FIELDS = [...PAGE_FIELDS, ...PRIVATE_FIELDS];
+// 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`.
+const UNIT_FIELD = "unit";
+const ALLOWED_FIELDS = [
+    ...PAGE_FIELDS,
+    UNIT_FIELD,
+    ...PRIVATE_FIELDS,
+];
 const FAMILIARITY = [
     { value: "well", label: "Well" },
     { value: "somewhat", label: "Somewhat" },
@@ -140,10 +147,13 @@ const mapping = (values, keyPattern, min = 0) => ({
     key_pattern: keyPattern,
     values,
 });
-const obj = (fields, closed = true) => ({ kind: "object", required: true, closed, fields });
+const obj = (fields, closed = true, required = true) => ({ kind: "object", required, closed, fields });
 const ITEM_SCHEMA = obj({
     source_id: string(),
     ...Object.fromEntries(PAGE_FIELDS.map((f) => [f, string(f === "group" || f === "body")])),
+    [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),
 }, false);
 // `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).
@@ -356,7 +366,41 @@ function checkConfig(cfg) {
 }
 /** The practice as the page shows it and the key keeps it: neutral ids P1, P2 … in the given order. */
 const practiceOf = (cfg) => cfg.practice.map((item, n) => ({ id: `P${String(n + 1)}`, ...item }));
-// ── the items: the leak guard, and the references to the config ───────────────────────────────
+/** The items of each line, in items.json order; a line's list is never empty. */
+const linesOf = (cfg) => cfg.items.reduce((byLine, item, n) => {
+    if (item.unit === undefined)
+        return byLine;
+    const part = { item, unit: item.unit, n };
+    const seen = byLine.get(item.unit.id);
+    return byLine.set(item.unit.id, seen ? [seen[0], ...seen.slice(1), part] : [part]);
+}, new Map());
+/** One part against the first part of its line: same count, in range, not repeated, same group. */
+function checkPart({ item, unit, n }, parts) {
+    const [first] = parts;
+    const at = `items[${String(n)}]`;
+    if (unit.text !== first.unit.text)
+        fail(`${at}.unit.text: ${repr(unit.text)}, but items[${String(first.n)}] of line ${repr(unit.id)} says ${repr(first.unit.text)}`);
+    if (unit.of !== first.unit.of)
+        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(`${at}.unit.part: ${String(unit.part)} repeats items[${String(earlier.n)}].unit.part`);
+    if (item.group !== first.item.group)
+        fail(`${at}.group: ${repr(item.group)}, but items[${String(first.n)}] of the same line is in ${repr(first.item.group)}`);
+}
+function checkUnits(cfg) {
+    for (const [line, parts] of linesOf(cfg)) {
+        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`);
+    }
+}
 function checkItemFields(cfg) {
     const sids = [];
     cfg.items.forEach((item, n) => {
@@ -373,6 +417,11 @@ function checkItemFields(cfg) {
             fail(`items[${String(n)}].group: ${repr(item.group)} is not in \`groups\``);
     });
 }
+/** Every text of an item the labeller sees, by field: the page fields and the line of a unit. */
+const visibleTexts = (item) => [
+    ...PAGE_FIELDS.map((f) => [f, item[f] ?? ""]),
+    [UNIT_FIELD, item.unit?.text ?? ""],
+];
 const escapeRegExp = (s) => s.replace(/[\\^$.*+?()[\]{}|/]/g, "\\$&");
 /**
  * A source id typed into a visible field gives the source away as well as a field would. Short ids
@@ -385,7 +434,7 @@ function checkNoSourceShown(cfg) {
     for (const item of cfg.items) {
         for (const sid of long) {
             const word = new RegExp(`(?<![\\p{L}\\p{N}_-])${escapeRegExp(sid)}(?![\\p{L}\\p{N}_-])`, "u");
-            const field = PAGE_FIELDS.find((f) => word.test(item[f] ?? ""));
+            const field = visibleTexts(item).find(([, text]) => word.test(text))?.[0];
             if (field !== undefined) {
                 fail(`the source id ${repr(sid)} appears in the visible \`${field}\` of item ${item.source_id}. Take it out of the text (or use source ids that are not natural words).`);
             }
@@ -426,11 +475,21 @@ function assignIds(items, seed, keyPath) {
     ]);
     return { ids, entries };
 }
-// ── a build, short of the page ──────────────────────────────────────────────────────────────────
-const shownFields = (item) => Object.fromEntries(PAGE_FIELDS.flatMap((f) => {
-    const v = item[f];
-    return v === undefined ? [] : [[f, v]];
-}));
+const shownFields = (item) => ({
+    ...Object.fromEntries(PAGE_FIELDS.flatMap((f) => {
+        const v = item[f];
+        return v === undefined ? [] : [[f, v]];
+    })),
+    ...(item.unit === undefined
+        ? {}
+        : {
+            [UNIT_FIELD]: {
+                text: item.unit.text,
+                part: item.unit.part,
+                of: item.unit.of,
+            },
+        }),
+});
 /** Only what the labeller can answer goes on the page, and only that gets an id, in id order. */
 function itemsOnPage(cfg, keyPath) {
     const knows = cfg.labeller_knows;
@@ -524,6 +583,7 @@ export function prepareBuild(configPath, outDir) {
     assertConfig(cfg);
     checkConfig(cfg);
     checkItemFields(cfg);
+    checkUnits(cfg);
     checkNoSourceShown(cfg);
     mkdirSync(outDir, { recursive: true });
     const keyPath = join(outDir, "key.json");

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

@@ -81,7 +81,15 @@ const FULL: DocObject = (() => {
       familiarity: true,
       familiarity_question: "How well do you know {group}?",
       items: ITEMS.map((i, n) =>
-        n === 0 ? { ...i, title: "T", code: "c = 1", context: "ctx" } : i,
+        n === 0
+          ? {
+              ...i,
+              title: "T",
+              code: "c = 1",
+              context: "ctx",
+              unit: { id: "L0", text: "One line.", part: 1, of: 1 },
+            }
+          : i,
       ),
     }),
   );
@@ -1167,6 +1175,138 @@ test("🔴 a question dropped between practice rounds: the earlier round's answe
   assert.match(r.out, /practice round 1: 3 of 3 matched/);
 });
 
+/** Items 0 and 3 (both Rust) as the two requirements of one line. */
+const LINE = "TypeScript only (no JavaScript); top-level await is allowed.";
+const withUnit = (
+  parts: readonly (readonly [n: number, unit: Record<string, unknown>])[],
+): Record<string, unknown> =>
+  config({
+    items: ITEMS.map((item, n) => {
+      const u = parts.find(([at]) => at === n);
+      return u === undefined ? item : { ...item, unit: u[1] };
+    }),
+  });
+
+/** A line whose parts do not add up, and the refusal that names it. */
+const UNIT_REFUSALS: readonly (readonly [
+  string,
+  Record<string, unknown>,
+  string,
+])[] = [
+  [
+    "unit-missing-part",
+    withUnit([[0, { id: "L1", text: LINE, part: 1, of: 2 }]]),
+    `items[0].unit: part 2 of 2 of line 'L1' is not among the items`,
+  ],
+  [
+    "unit-part-twice",
+    withUnit([
+      [0, { id: "L1", text: LINE, part: 1, of: 2 }],
+      [3, { id: "L1", text: LINE, part: 1, of: 2 }],
+    ]),
+    "items[3].unit.part: 1 repeats items[0].unit.part",
+  ],
+  [
+    "unit-of-differs",
+    withUnit([
+      [0, { id: "L1", text: LINE, part: 1, of: 2 }],
+      [3, { id: "L1", text: LINE, part: 2, of: 3 }],
+    ]),
+    "items[3].unit.of: 3, but items[0].unit.of says 2 for the same line",
+  ],
+  [
+    "unit-part-range",
+    withUnit([[0, { id: "L1", text: LINE, part: 3, of: 2 }]]),
+    "items[0].unit.part: 3 is not between 1 and 2",
+  ],
+  [
+    "unit-groups-differ",
+    withUnit([
+      [0, { id: "L1", text: LINE, part: 1, of: 2 }],
+      [1, { id: "L1", text: LINE, part: 2, of: 2 }],
+    ]),
+    "items[1].group: 'python', but items[0] of the same line is in 'rust'",
+  ],
+  [
+    "unit-text-differs",
+    withUnit([
+      [0, { id: "L1", text: LINE, part: 1, of: 2 }],
+      [3, { id: "L1", text: "Another line.", part: 2, of: 2 }],
+    ]),
+    "items[3].unit.text: 'Another line.', but items[0] of line 'L1' says",
+  ],
+  [
+    "unit-halves-of-two-occurrences",
+    withUnit([
+      [0, { id: "L1", text: LINE, part: 1, of: 2 }],
+      [3, { id: "L2", text: LINE, part: 2, of: 2 }],
+    ]),
+    "items[0].unit: part 2 of 2 of line 'L1' is not among the items",
+  ],
+  [
+    "unit-leaks-source",
+    withUnit([[0, { id: "L1", text: "as in case-1003", part: 1, of: 1 }]]),
+    "the source id 'case-1003' appears in the visible `unit` of item case-1000",
+  ],
+];
+
+test("🔴 a line with several requirements: build refuses a unit whose parts do not add up, naming the item", () => {
+  for (const [name, cfg, message] of UNIT_REFUSALS) {
+    const dir = setup(name, cfg);
+    const r = run(["build", join(dir, "items.json"), join(dir, "out")]);
+    assert.equal(r.status, 1, `${name}\n${r.out}`);
+    assert.ok(r.out.includes(`REFUSED: ${message}`), `${name}\n${r.out}`);
+  }
+});
+
+test("a line whose every requirement is an item builds, and each item carries its part and the whole line", () => {
+  const dir = setup(
+    "unit-ok",
+    withUnit([
+      [0, { id: "L1", text: LINE, part: 1, of: 2 }],
+      [3, { id: "L1", text: LINE, part: 2, of: 2 }],
+    ]),
+  );
+  const { page } = build(dir);
+  const json =
+    /<script type="application\/json" id="data">([\s\S]*?)<\/script>/.exec(
+      page,
+    )?.[1];
+  assert.ok(json !== undefined);
+  const units = z
+    .object({
+      items: z.array(
+        z.object({
+          unit: z
+            .object({ text: z.string(), part: z.number(), of: z.number() })
+            .optional(),
+        }),
+      ),
+    })
+    .parse(JSON.parse(json.replace(/<\\\//g, "</")))
+    .items.flatMap((i) => (i.unit ? [i.unit] : []))
+    .sort((a, b) => a.part - b.part);
+  // what the page carries: the part and the line, never the line's private id
+  assert.deepEqual(units, [
+    { text: LINE, part: 1, of: 2 },
+    { text: LINE, part: 2, of: 2 },
+  ]);
+});
+
+test("🔴 the same line in two places is two lines: four items, two ids, it builds, and the id stays off the page", () => {
+  const dir = setup(
+    "unit-same-text",
+    withUnit([
+      [0, { id: "a.md:3", text: LINE, part: 1, of: 2 }],
+      [3, { id: "a.md:3", text: LINE, part: 2, of: 2 }],
+      [6, { id: "b.md:9", text: LINE, part: 1, of: 2 }],
+      [9, { id: "b.md:9", text: LINE, part: 2, of: 2 }],
+    ]),
+  );
+  const { page } = build(dir);
+  assert.ok(!page.includes("a.md:3"), "the line's id is private");
+});
+
 test("🔴 familiarity off: the key asks for none, the export reports no missing familiarity, and a stored one is refused", () => {
   const dir = setup("familiarity-off", approval({ familiarity: false }));
   const { key } = build(dir);

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

@@ -94,7 +94,14 @@ const readJson = (path: string): Json => {
 // 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;
 const PRIVATE_FIELDS = ["source_id"] as const;
-const ALLOWED_FIELDS: readonly string[] = [...PAGE_FIELDS, ...PRIVATE_FIELDS];
+// 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`.
+const UNIT_FIELD = "unit";
+const ALLOWED_FIELDS: readonly string[] = [
+  ...PAGE_FIELDS,
+  UNIT_FIELD,
+  ...PRIVATE_FIELDS,
+];
 
 const FAMILIARITY = [
   { value: "well", label: "Well" },
@@ -180,7 +187,8 @@ const mapping = (
 const obj = (
   fields: Readonly<Record<string, SchemaNode>>,
   closed = true,
-): SchemaNode => ({ kind: "object", required: true, closed, fields });
+  required = true,
+): SchemaNode => ({ kind: "object", required, closed, fields });
 
 const ITEM_SCHEMA = obj(
   {
@@ -188,6 +196,12 @@ const ITEM_SCHEMA = obj(
     ...Object.fromEntries(
       PAGE_FIELDS.map((f) => [f, string(f === "group" || f === "body")]),
     ),
+    [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,
+    ),
   },
   false, // an unlisted item field is the leak guard's refusal, with its own message
 );
@@ -348,9 +362,19 @@ interface Question {
   readonly short?: string;
   readonly options: readonly Option[];
 }
-type Item = Readonly<Record<string, string>> & {
+interface Unit {
+  readonly id: string;
+  readonly text: string;
+  readonly part: number;
+  readonly of: number;
+}
+type Item = {
+  readonly [F in (typeof PAGE_FIELDS)[number]]?: string;
+} & {
   readonly source_id: string;
   readonly group: string;
+  readonly body: string;
+  readonly unit?: Unit;
 };
 interface Practice {
   readonly title?: string;
@@ -507,6 +531,69 @@ const practiceOf = (
   cfg.practice.map((item, n) => ({ id: `P${String(n + 1)}`, ...item }));
 
 // ── 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.
+ */
+interface Part {
+  readonly item: Item;
+  readonly unit: Unit;
+  readonly n: number;
+}
+type Parts = readonly [Part, ...Part[]];
+/** The items of each line, in items.json order; a line's list is never empty. */
+const linesOf = (cfg: Config): ReadonlyMap<string, Parts> =>
+  cfg.items.reduce((byLine, item, n) => {
+    if (item.unit === undefined) return byLine;
+    const part: Part = { item, unit: item.unit, n };
+    const seen = byLine.get(item.unit.id);
+    return byLine.set(
+      item.unit.id,
+      seen ? [seen[0], ...seen.slice(1), part] : [part],
+    );
+  }, new Map<string, Parts>());
+/** One part against the first part of its line: same count, in range, not repeated, same group. */
+function checkPart({ item, unit, n }: Part, parts: Parts): void {
+  const [first] = parts;
+  const at = `items[${String(n)}]`;
+  if (unit.text !== first.unit.text)
+    fail(
+      `${at}.unit.text: ${repr(unit.text)}, but items[${String(first.n)}] of line ${repr(unit.id)} says ${repr(first.unit.text)}`,
+    );
+  if (unit.of !== first.unit.of)
+    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(
+      `${at}.unit.part: ${String(unit.part)} repeats items[${String(earlier.n)}].unit.part`,
+    );
+  if (item.group !== first.item.group)
+    fail(
+      `${at}.group: ${repr(item.group)}, but items[${String(first.n)}] of the same line is in ${repr(first.item.group)}`,
+    );
+}
+function checkUnits(cfg: Config): void {
+  for (const [line, parts] of linesOf(cfg)) {
+    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`,
+      );
+  }
+}
 function checkItemFields(cfg: Config): void {
   const sids: string[] = [];
   cfg.items.forEach((item, n) => {
@@ -529,6 +616,11 @@ function checkItemFields(cfg: Config): void {
       );
   });
 }
+/** Every text of an item the labeller sees, by field: the page fields and the line of a unit. */
+const visibleTexts = (item: Item): readonly (readonly [string, string])[] => [
+  ...PAGE_FIELDS.map((f): readonly [string, string] => [f, item[f] ?? ""]),
+  [UNIT_FIELD, item.unit?.text ?? ""],
+];
 const escapeRegExp = (s: string): string =>
   s.replace(/[\\^$.*+?()[\]{}|/]/g, "\\$&");
 /**
@@ -545,7 +637,7 @@ function checkNoSourceShown(cfg: Config): void {
         `(?<![\\p{L}\\p{N}_-])${escapeRegExp(sid)}(?![\\p{L}\\p{N}_-])`,
         "u",
       );
-      const field = PAGE_FIELDS.find((f) => word.test(item[f] ?? ""));
+      const field = visibleTexts(item).find(([, text]) => word.test(text))?.[0];
       if (field !== undefined) {
         fail(
           `the source id ${repr(sid)} appears in the visible \`${field}\` of item ${item.source_id}. Take it out of the text (or use source ids that are not natural words).`,
@@ -612,13 +704,27 @@ function assignIds(
 }
 
 // ── a build, short of the page ──────────────────────────────────────────────────────────────────
-const shownFields = (item: Item): Readonly<Record<string, string>> =>
-  Object.fromEntries(
+/** A unit as the page shows it: the part and the line, without the line's private id. */
+type ShownUnit = Omit<Unit, "id">;
+const shownFields = (
+  item: Item,
+): Readonly<Record<string, string | ShownUnit>> => ({
+  ...Object.fromEntries(
     PAGE_FIELDS.flatMap((f) => {
       const v = item[f];
       return v === undefined ? [] : [[f, v]];
     }),
-  );
+  ),
+  ...(item.unit === undefined
+    ? {}
+    : {
+        [UNIT_FIELD]: {
+          text: item.unit.text,
+          part: item.unit.part,
+          of: item.unit.of,
+        },
+      }),
+});
 
 /** Only what the labeller can answer goes on the page, and only that gets an id, in id order. */
 function itemsOnPage(cfg: Config, keyPath: string) {
@@ -729,6 +835,7 @@ export function prepareBuild(configPath: string, outDir: string) {
   assertConfig(cfg);
   checkConfig(cfg);
   checkItemFields(cfg);
+  checkUnits(cfg);
   checkNoSourceShown(cfg);
   mkdirSync(outDir, { recursive: true });
   const keyPath = join(outDir, "key.json");

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

@@ -412,6 +412,44 @@ 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("🔴 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",
+  );
+});
+
 test("🔴 familiarity off: no group asks how well it is known, and a group is done when its items are", async () => {
   const { page, key } = build(
     setup("familiarity-off-page", approval({ familiarity: false })),

package/skills/build-label-page/scripts/label-page.js

@@ -53,7 +53,11 @@
  *     "practice": [{"body": "…", "expected": {"label": "yes"}, "why": "one line"}, …],   3 or more
  *     "practice_round": 1,                  optional; raise it after rewording, the practice reopens
  *     "items": [{"source_id": "case-0412-b", "group": "python", "body": "…", "code": "…",
- *                "context": "…"}]
+ *                "context": "…",
+ *                "unit": {"id": "a.md:12", "text": "the whole line", "part": 1, "of": 2}}]
+ *                                           unit: optional; one requirement of a line that holds
+ *                                           several. Every part of the line is an item, in one group;
+ *                                           id (never shown) tells two places with the same words apart.
  *   }
  *
  * TypeScript, compiled beside itself to `label-page.js` by `npm run build`: a consumer runs the skill

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

@@ -53,7 +53,11 @@
  *     "practice": [{"body": "…", "expected": {"label": "yes"}, "why": "one line"}, …],   3 or more
  *     "practice_round": 1,                  optional; raise it after rewording, the practice reopens
  *     "items": [{"source_id": "case-0412-b", "group": "python", "body": "…", "code": "…",
- *                "context": "…"}]
+ *                "context": "…",
+ *                "unit": {"id": "a.md:12", "text": "the whole line", "part": 1, "of": 2}}]
+ *                                           unit: optional; one requirement of a line that holds
+ *                                           several. Every part of the line is an item, in one group;
+ *                                           id (never shown) tells two places with the same words apart.
  *   }
  *
  * TypeScript, compiled beside itself to `label-page.js` by `npm run build`: a consumer runs the skill

package/skills/build-label-page/scripts/page-template.html

@@ -312,6 +312,11 @@ pre { overflow-x: auto; background: var(--surface); border: 1px solid var(--line
     card.appendChild(rich("p", "body", item.body));
     if (item.code) card.appendChild(codeBlock(item.code));
     if (item.context) card.appendChild(rich("p", "muted", item.context));
+    // One requirement of a line that holds several: which one, and the whole line it came from.
+    if (item.unit) {
+      card.appendChild(el("p", "muted", "From the line (requirement " + item.unit.part + " of " + item.unit.of + "):"));
+      card.appendChild(rich("p", "quote", item.unit.text));
+    }
     var a = answersOf(item.id);
     askOne(card, a, state.editing[item.id], function (q, v) {
       delete state.editing[item.id];