paperlint 13.3.2 → 13.5.0

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

@@ -14,6 +14,7 @@ import {
   ITEMS,
   PRACTICE,
   QUESTIONS,
+  WORK,
   approval,
   build,
   config,
@@ -26,7 +27,7 @@ import {
 /** A node of the declared config schema, as `example-generator.py schema` prints it. */
 const Node: z.ZodType<SchemaNode> = z.lazy(() =>
   z.object({
-    kind: z.enum(["string", "integer", "map", "array", "object"]),
+    kind: z.enum(["string", "integer", "boolean", "map", "array", "object"]),
     required: z.boolean(),
     pattern: z.string().optional(),
     key_pattern: z.string().optional(),
@@ -39,7 +40,7 @@ const Node: z.ZodType<SchemaNode> = z.lazy(() =>
 );
 
 interface SchemaNode {
-  readonly kind: "string" | "integer" | "map" | "array" | "object";
+  readonly kind: "string" | "integer" | "boolean" | "map" | "array" | "object";
   readonly required: boolean;
   readonly pattern?: string | undefined;
   readonly key_pattern?: string | undefined;
@@ -77,9 +78,18 @@ const FULL: DocObject = (() => {
         QUESTIONS[1],
       ],
       labeller_knows: ["python", "go", "rust"],
+      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,
       ),
     }),
   );
@@ -175,6 +185,7 @@ function spoil(path: string, bad: Doc | undefined): DocObject {
 const WRONG_TYPES: Readonly<Record<SchemaNode["kind"], readonly Doc[]>> = {
   string: [null, 1, true, ["x"], {}, "", "   "],
   integer: [null, "7", true, 7.5, []],
+  boolean: [null, "false", 0, [], {}],
   map: [null, "x", ["x"], 1],
   array: [null, "x", {}, 1],
   object: [null, "x", ["x"], 1],
@@ -238,6 +249,7 @@ const DOCUMENTED_FIELDS = [
   "seed",
   "groups",
   "labeller_knows",
+  "familiarity",
   "familiarity_question",
   "questions",
   "items",
@@ -1162,3 +1174,194 @@ test("🔴 a question dropped between practice rounds: the earlier round's answe
   assert.equal(r.status, 0, r.out);
   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);
+  assert.deepEqual(key.allowed.familiarity, []);
+  const [a] = Object.keys(key.ids);
+  assert.ok(a !== undefined);
+  writeFileSync(
+    join(dir, "dump.json"),
+    JSON.stringify({
+      answers: { [a]: { answers: { keep: "keep" }, source: "page" } },
+      groups: {},
+    }),
+  );
+  const r = exportAt(dir);
+  assert.equal(r.status, 0, r.out);
+  assert.doesNotMatch(r.out, /no familiarity answer|invalid group/);
+  assert.deepEqual(Exported.parse(JSON.parse(labelsFile(dir))).groups, {});
+  writeFileSync(
+    join(dir, "dump.json"),
+    JSON.stringify({
+      answers: {},
+      groups: { python: { familiarity: "well", source: "chat" } },
+    }),
+  );
+  const refused = exportAt(dir);
+  assert.notEqual(refused.status, 0);
+  assert.match(refused.out, /groups\/python: .*familiarity is off/);
+});
+
+test("🔴 familiarity off with a familiarity_question is a contradiction the build refuses", () => {
+  const r = run([
+    "build",
+    join(
+      setup(
+        "familiarity-contradiction",
+        approval({ familiarity: false, familiarity_question: "How well?" }),
+      ),
+      "items.json",
+    ),
+    join(WORK, "contradiction-out"),
+  ]);
+  assert.notEqual(r.status, 0);
+  assert.match(
+    r.out,
+    /REFUSED: familiarity_question: .*`familiarity` is false/,
+  );
+});
+
+test("familiarity left out: every group is still asked (rule 5), and a missing one is reported", () => {
+  const dir = setup("familiarity-default", approval());
+  const { key } = build(dir);
+  assert.deepEqual(key.allowed.familiarity, ["well", "somewhat", "not_really"]);
+  writeFileSync(
+    join(dir, "dump.json"),
+    JSON.stringify({ answers: {}, groups: {} }),
+  );
+  assert.match(exportAt(dir).out, /group python: no familiarity answer/);
+});

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" },
@@ -132,6 +139,7 @@ const SOURCES_SHOWN = `(${SOURCES.map(quoted).join(", ")})`;
 type SchemaNode =
   | { kind: "string"; required: boolean; pattern?: string }
   | { kind: "integer"; required: boolean }
+  | { kind: "boolean"; required: boolean }
   | { kind: "array"; required: boolean; min: number; items: SchemaNode }
   | {
       kind: "map";
@@ -155,6 +163,10 @@ const integer = (required = true): SchemaNode => ({
   kind: "integer",
   required,
 });
+const boolean = (required = true): SchemaNode => ({
+  kind: "boolean",
+  required,
+});
 const array = (items: SchemaNode, required = true, min = 0): SchemaNode => ({
   kind: "array",
   required,
@@ -175,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(
   {
@@ -183,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
 );
@@ -220,6 +239,9 @@ export const CONFIG_SCHEMA = obj({
   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),
@@ -296,6 +318,10 @@ function checkObject(
     );
   }
 }
+function checkBoolean(value: Json, where: string): void {
+  if (typeof value !== "boolean")
+    fail(`${where}: must be true or false, got ${repr(value)}`);
+}
 /** Refuse the first place `value` departs from `node`; the message starts with the field's path. */
 function checkValue(value: Json, node: SchemaNode, path: string): void {
   const where = path || "items.json";
@@ -308,6 +334,9 @@ function checkValue(value: Json, node: SchemaNode, path: string): void {
         fail(`${where}: must be an integer, got ${repr(value)}`);
       }
       break;
+    case "boolean":
+      checkBoolean(value, where);
+      break;
     case "array":
       checkArray(value, node, path, where);
       break;
@@ -333,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;
@@ -352,6 +391,7 @@ interface Config {
   readonly seed: number;
   readonly groups: Readonly<Record<string, string>>;
   readonly labeller_knows?: readonly string[];
+  readonly familiarity?: boolean;
   readonly familiarity_question?: string;
   readonly questions: readonly Question[];
   readonly practice: readonly Practice[];
@@ -368,7 +408,10 @@ function assertConfig(value: Json): asserts value is Json & Config {
  * The page script (`DATA.allowed`) and the exporter (`key.json`) both read this one result, so a
  * stored value counts as an answer on the page exactly when it counts in the export.
  */
-const allowedValues = (questions: readonly Question[]): JsonObject => ({
+const allowedValues = (
+  questions: readonly Question[],
+  asksFamiliarity: boolean,
+): JsonObject => ({
   questions: Object.fromEntries(
     questions.map((q) => [q.id, q.options.map((o) => o.value)]),
   ),
@@ -379,8 +422,10 @@ const allowedValues = (questions: readonly Question[]): JsonObject => ({
       q.options.filter((o) => o.ask_why !== undefined).map((o) => o.value),
     ]),
   ),
-  familiarity: FAMILIARITY.map((o) => o.value),
+  // 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;
 
 /** Two values that read the same once case and surrounding space are gone. */
 const readsAs = (s: string): string => s.trim().toLowerCase();
@@ -464,6 +509,11 @@ function checkPractice(cfg: Config): void {
 }
 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`,
+    );
+  }
   cfg.questions.forEach((q, qn) => {
     checkQuestion(
       q,
@@ -481,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) => {
@@ -503,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, "\\$&");
 /**
@@ -519,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).`,
@@ -586,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) {
@@ -618,10 +750,11 @@ function payloadOf(cfg: Config, page: ReturnType<typeof itemsOnPage>) {
     title: cfg.title,
     intro: cfg.intro ?? "",
     groups: used.map((g) => ({ id: g, label: String(cfg.groups[g]) })),
-    familiarity_question:
-      cfg.familiarity_question ?? "How well do you know {group}?",
-    familiarity: FAMILIARITY,
-    allowed: allowedValues(cfg.questions),
+    familiarity_question: asksFamiliarity(cfg)
+      ? (cfg.familiarity_question ?? "How well do you know {group}?")
+      : "",
+    familiarity: asksFamiliarity(cfg) ? FAMILIARITY : [],
+    allowed: allowedValues(cfg.questions, asksFamiliarity(cfg)),
     questions: cfg.questions,
     practice: { round: practiceRound(cfg), items: practiceOf(cfg) },
     items: page.items.map((i) => ({ id: page.idOf(i), ...shownFields(i) })),
@@ -675,7 +808,7 @@ function keyOf(
     questions: cfg.questions.map((q) => q.id),
     // What counts as an answer: the same lists the page was given (`allowedValues`). `export`
     // checks every stored answer and familiarity against them, so the build's options decide.
-    allowed: allowedValues(cfg.questions),
+    allowed: allowedValues(cfg.questions, asksFamiliarity(cfg)),
     // The practice is scored against this at export; its answers never go into the labels.
     practice: {
       round: practiceRound(cfg),
@@ -702,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");
@@ -931,6 +1065,17 @@ function checkDump(dump: Json, key: Key): asserts dump is JsonObject {
   }
 }
 
+/** A page built with `familiarity: false` asks no group anything: a group document came from elsewhere. */
+function checkNoFamiliarity(dump: JsonObject, allowed: Allowed): void {
+  const groups = isObject(dump["groups"]) ? dump["groups"] : {};
+  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`,
+    );
+  }
+}
+
 // ── export ────────────────────────────────────────────────────────────────────────────────────
 interface Allowed {
   readonly questions: Readonly<Record<string, readonly string[]>>;
@@ -1165,11 +1310,13 @@ function labelsOf(dump: JsonObject, ctx: Ctx, day: string) {
   const items = onPage.map(([nid, meta]) =>
     labelOf(nid, meta, docOf(dump["answers"], nid), ctx),
   );
-  const groups = groupsOf(
-    [...new Set(onPage.map(([, m]) => m.group))],
-    dump["groups"],
-    ctx.allowed,
-  );
+  const groups = ctx.allowed.familiarity.length
+    ? groupsOf(
+        [...new Set(onPage.map(([, m]) => m.group))],
+        dump["groups"],
+        ctx.allowed,
+      )
+    : {};
   return {
     study: ctx.key.study,
     exported: day,
@@ -1197,6 +1344,7 @@ export function exportLabels(
   const allowed = key.allowed;
   assertAllowed(allowed, key, keyPath);
   checkDump(dump, key);
+  checkNoFamiliarity(dump, allowed);
   const out = labelsOf(dump, { key, allowed }, day);
   mkdirSync(outDir, { recursive: true });
   const path = join(outDir, `${key.study}-labels-${day}.json`);

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

@@ -411,3 +411,63 @@ test("🔴 without the store the page is read-only, and the real items stay read
   assert.match(shown, /cannot be saved in this view/);
   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 })),
+  );
+  const practice = Object.fromEntries(
+    APPROVAL_PRACTICE.map((p, n) => [
+      `r1-P${String(n + 1)}`,
+      { answers: p.expected, source: "page" },
+    ]),
+  );
+  const answers = Object.fromEntries(
+    Object.keys(key.ids).map((id) => [
+      id,
+      { answers: { keep: "keep" }, source: "page" },
+    ]),
+  );
+  const shown = await showPage(page, answers, {}, practice);
+  assert.doesNotMatch(shown, /How well/);
+  assert.doesNotMatch(shown, /how well you know it/);
+  assert.match(shown, /Nothing left/, shown);
+});

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

@@ -40,6 +40,7 @@
  *     "seed": 7,                            fixes the order; change it and every id changes
  *     "groups": {"python": "Python"},
  *     "labeller_knows": ["python"],         optional: items of other groups are not put on the page
+ *     "familiarity": false,                 optional: no "how well do you know" question (approval page)
  *     "familiarity_question": "How well do you know {group}?",          optional
  *     "questions": [{"id": "label", "text": "Is this correct?", "short": "correct?",
  *                    "options": [{"value": "yes", "label": "Yes", "example": "one real case",
@@ -52,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