paperlint 13.3.2 → 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;
@@ -19,6 +20,9 @@ type SchemaNode = {
 } | {
     kind: "integer";
     required: boolean;
+} | {
+    kind: "boolean";
+    required: boolean;
 } | {
     kind: "array";
     required: boolean;
@@ -50,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;
@@ -69,6 +83,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[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paperlint",
-  "version": "13.3.2",
+  "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/assess-novelty/scripts/candidate_page.test.ts

@@ -26,42 +26,11 @@ import assert from "node:assert/strict";
 const here = dirname(fileURLToPath(import.meta.url));
 const TOOL = join(here, "candidate_page.ts");
 const FIXTURE = join(here, "fixtures", "novelty");
-// playwright-core is what package.json declares; the browser is whichever chromiumPath() finds (CHROMIUM_PATH, a
-// build in PLAYWRIGHT_BROWSERS_PATH, or the Chrome a GitHub runner ships), so nothing is downloaded.
 import { chromium } from "playwright-core";
-import { existsSync, readdirSync } from "node:fs";
+import { chromiumPath } from "../../../test/chromium.ts";
 import { test } from "vitest";
 
 test("candidate_page", async () => {
-  const BROWSERS_DIR =
-    process.env.PLAYWRIGHT_BROWSERS_PATH || "/opt/pw-browsers";
-  const SYSTEM_CHROME = [
-    "/usr/bin/google-chrome",
-    "/usr/bin/google-chrome-stable",
-    "/usr/bin/chromium",
-    "/usr/bin/chromium-browser",
-    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome", // the macOS runner's Chrome
-  ];
-  const chromiumPath = (): string => {
-    const builds = existsSync(BROWSERS_DIR)
-      ? readdirSync(BROWSERS_DIR)
-          .filter((d) => /^chromium-\d+$/.test(d))
-          .sort((a, b) => Number(b.split("-")[1]) - Number(a.split("-")[1]))
-          .flatMap((d) =>
-            ["chrome-linux64", "chrome-linux"].map((sub) =>
-              join(BROWSERS_DIR, d, sub, "chrome"),
-            ),
-          )
-      : [];
-    const found = [process.env.CHROMIUM_PATH, ...builds, ...SYSTEM_CHROME].find(
-      (p) => p && existsSync(p),
-    );
-    if (!found)
-      throw new Error(
-        `no Chromium: set CHROMIUM_PATH, or install one in ${BROWSERS_DIR} or ${SYSTEM_CHROME[0]}`,
-      );
-    return found;
-  };
   // A 1x1 PNG, enough for an <img> to load.
   const PNG = Buffer.from(
     "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==",

package/skills/build-label-page/SKILL.md

@@ -4,7 +4,7 @@ description: Build a phone labelling page published as a claude.ai Artifact with
 allowed-tools: [Read, Write, Edit, Grep, Glob, Bash, Artifact, ArtifactData]
 ---
 
-<!-- vigiles:sha256:6323fa135f385e8b compiled from skills/build-label-page/SKILL.md.spec.ts -->
+<!-- vigiles:sha256:bd616b2694831fa1 compiled from skills/build-label-page/SKILL.md.spec.ts -->
 
 # build-label-page — a page the person labels on a phone, and the labels back in the repo
 
@@ -63,7 +63,8 @@ building. In one line each:
    source labels on the page. The generator refuses to build when an item carries a field outside an
    allow-list; a page written by hand checks its items against the same list.
 5. **Ask only what the labeller can answer.** Only the languages and tools they know; one "how well do
-   you know it" question per group, used later as an analysis filter; "clear-cut or real boundary"
+   you know it" question per group, used later as an analysis filter (off on an approval page,
+   `"familiarity": false`: the author has not seen those repositories); "clear-cut or real boundary"
    is the labeller's judgement, not the designer's.
 6. **Export into the repository right away**, one JSON per page into the study's `data/` with the
    export date, commit it, and record answers given in chat with `source: "chat"`. If the page fails,

package/skills/build-label-page/SKILL.md.spec.ts

@@ -74,7 +74,8 @@ building. In one line each:
    source labels on the page. The generator refuses to build when an item carries a field outside an
    allow-list; a page written by hand checks its items against the same list.
 5. **Ask only what the labeller can answer.** Only the languages and tools they know; one "how well do
-   you know it" question per group, used later as an analysis filter; "clear-cut or real boundary"
+   you know it" question per group, used later as an analysis filter (off on an approval page,
+   \`"familiarity": false\`: the author has not seen those repositories); "clear-cut or real boundary"
    is the labeller's judgement, not the designer's.
 6. **Export into the repository right away**, one JSON per page into the study's \`data/\` with the
    export date, commit it, and record answers given in chat with \`source: "chat"\`. If the page fails,

package/skills/build-label-page/references/checklist.md

@@ -83,7 +83,9 @@ the text of an allowed field says.
   other groups are not put on the page and get no id.
 - Add one question per group, "how well do you know this language / tool" (well / somewhat / not
   really). It is an analysis filter: the study can report the labels with and without the groups
-  the labeller does not know well.
+  the labeller does not know well. An approval page asks none (`"familiarity": false` in
+  `items.json`): its question is about a drawn unit, not about repositories the author has seen,
+  and an answer to "how well do you know the projects of this group" there means nothing.
 - The per-item judgement "clear-cut or a real boundary case" is the labeller's. The study design
   does not decide it in advance and does not pre-fill it.
 
@@ -92,7 +94,7 @@ answer is the only way to find it afterwards. And a boundary case is boundary be
 person hesitates; a designer who tags it in advance has measured the design, not the item.
 
 **Check.** The build prints how many items were left out; the export has a familiarity value for
-every group.
+every group, or the page was built with `"familiarity": false` and the export has no groups.
 
 ## 6. Export into the repository right away
 

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

@@ -37,12 +37,22 @@ 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,
-  until a reason is saved.
+  until a reason is saved. The reason saves as it is typed (after a pause, and when the page is
+  left), so a labeller who closes the page from inside the box does not leave a drop without its
+  reason; a store echo while typing keeps the box and its focus.
 
 ## The approval page
 
@@ -73,8 +83,15 @@ drop, the drop carrying `ask_why`.
 }
 ```
 
-The items are the drawn units verbatim. The practice is three units whose fate is obvious. Each
-dropped unit carries its reason in the labels file. The author's words, with the date, then go into
+The page sets `"familiarity": false`: the author is judging drawn units, not repositories they
+have seen, so the per-group "how well do you know it" question is left out (and a
+`familiarity_question` beside it is refused).
+
+The items are the drawn units verbatim, in a language the author reads. Units in other languages
+are taken out before the draw, as a population rule the study's `plan.json` states ("English-language
+units only") with the number excluded reported in the paper; a unit dropped at approval because the
+author cannot read it is an exclusion made after the draw and goes unrecorded. The practice is three
+units whose fate is obvious. Each dropped unit carries its reason in the labels file. The author's words, with the date, then go into
 `author_check` of the plan; a dropped unit is replaced by the next one in the draw.
 
 ## The export

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

@@ -0,0 +1,187 @@
+/**
+ * The generator's page in a real Chromium, against a stand-in store whose writes come back as a
+ * snapshot a moment later (as the claude.ai store does). What the fake DOM of label-page-html.test.ts
+ * cannot show: focus, typing, and a page that is left without the box ever losing focus.
+ */
+import assert from "node:assert/strict";
+import { chromium, type Page } from "playwright-core";
+import { test } from "vitest";
+import { z } from "zod";
+import { chromiumPath } from "../../../test/chromium.ts";
+import {
+  APPROVAL_PRACTICE,
+  approval,
+  build,
+  setup,
+} from "../../../test/label-page-kit.ts";
+
+/** A store that keeps every write and echoes it back as a snapshot after `echoMs`. */
+const STORE = (practice: Record<string, unknown>, echoMs: number): string => `
+  window.__writes = [];
+  (function () {
+    var docs = { answers: {}, groups: {}, practice: ${JSON.stringify(practice)} };
+    var subs = {};
+    function snap(n) {
+      (subs[n] || []).forEach(function (cb) {
+        cb({ docs: Object.keys(docs[n]).map(function (id) { return { id: id, data: function () { return docs[n][id]; } }; }) });
+      });
+    }
+    var db = { collection: function (n) { return {
+      onSnapshot: function (cb) { (subs[n] = subs[n] || []).push(cb); snap(n); },
+      doc: function (id) { return { set: function (body) {
+        window.__writes.push(body);
+        docs[n][id] = body;
+        return new Promise(function (r) { setTimeout(function () { r(); snap(n); }, ${String(echoMs)}); });
+      } }; }
+    }; } };
+    window.claude = { use: function () { return Promise.resolve(db); } };
+  })();`;
+
+const PRACTICE_DONE = Object.fromEntries(
+  APPROVAL_PRACTICE.map((p, n) => [
+    `r1-P${String(n + 1)}`,
+    { answers: p.expected, source: "page" },
+  ]),
+);
+
+/** Every document the page wrote, in order, read back as JSON (the stand-in store keeps them). */
+const Writes = z.array(
+  z.object({ reasons: z.record(z.string(), z.string()) }).loose(),
+);
+const writes = async (page: Page) =>
+  Writes.parse(
+    JSON.parse(await page.evaluate("JSON.stringify(window.__writes)")),
+  );
+/** The reason the store was last given for the one question. */
+const storedReason = async (page: Page): Promise<string | undefined> =>
+  (await writes(page)).at(-1)?.reasons["keep"];
+
+/** Wait until the store's last write carries `text` as the reason (the page saves on its own). */
+async function reasonStored(page: Page, text: string): Promise<void> {
+  await page.waitForFunction(
+    `(window.__writes || []).at(-1)?.reasons?.keep === ${JSON.stringify(text)}`,
+    undefined,
+    { timeout: 10_000 },
+  );
+  assert.equal(await storedReason(page), text);
+}
+
+/** A browser test launches Chromium and types: far above vitest's 5 s default on a slow runner. */
+const BROWSER_TEST_MS = 60_000;
+
+async function onApprovalPage(
+  name: string,
+  echoMs: number,
+  steps: (page: Page) => Promise<void>,
+  filter: "all" | "next" = "all",
+): Promise<void> {
+  const { page: html } = build(setup(name, approval()));
+  const browser = await chromium.launch({
+    executablePath: chromiumPath(),
+    args: ["--no-sandbox"],
+  });
+  try {
+    const page = await browser.newPage();
+    await page.addInitScript(STORE(PRACTICE_DONE, echoMs));
+    await page.goto("about:blank");
+    await page.setContent(html, { waitUntil: "domcontentloaded" });
+    if (filter === "next")
+      await page.getByRole("button", { name: "Next unanswered" }).click();
+    await page.getByRole("button", { name: /Drop/ }).first().click();
+    await steps(page);
+  } finally {
+    await browser.close();
+  }
+}
+
+test(
+  "🔴 a reason typed and never blurred is saved: after a pause in typing, and when the page is left",
+  async () => {
+    await onApprovalPage("browser-pause", 20, async (page) => {
+      await page.locator("textarea").first().click();
+      await page.keyboard.type("a process rule");
+      await reasonStored(page, "a process rule");
+    });
+    await onApprovalPage("browser-leave", 20, async (page) => {
+      await page.locator("textarea").first().click();
+      await page.keyboard.type("not a rule");
+      await page.evaluate(() => {
+        window.dispatchEvent(new Event("pagehide"));
+      });
+      await reasonStored(page, "not a rule");
+    });
+  },
+  BROWSER_TEST_MS,
+);
+
+test(
+  "🔴 the store's echo while typing keeps the box, its focus and every keystroke",
+  async () => {
+    await onApprovalPage("browser-echo", 300, async (page) => {
+      await page.locator("textarea").first().click();
+      await page.keyboard.type("a pro");
+      await page.waitForTimeout(450); // the Drop's own write comes back and the page renders again
+      await page.keyboard.type("cess rule");
+      assert.equal(
+        await page.evaluate(() => document.activeElement?.tagName),
+        "TEXTAREA",
+      );
+      assert.equal(
+        await page.locator("textarea").first().inputValue(),
+        "a process rule",
+      );
+      await reasonStored(page, "a process rule");
+    });
+  },
+  BROWSER_TEST_MS,
+);
+
+test(
+  "🔴 under 'Next unanswered', the save that completes an item keeps the box being typed in on the page",
+  async () => {
+    await onApprovalPage(
+      "browser-next",
+      20,
+      async (page) => {
+        await page.locator("textarea").first().click();
+        await page.keyboard.type("a pro");
+        await reasonStored(page, "a pro"); // the item is complete now, and the filter hides complete items
+        await page.keyboard.type("cess rule");
+        assert.equal(
+          await page.evaluate(() => document.activeElement?.tagName),
+          "TEXTAREA",
+        );
+        await reasonStored(page, "a process rule");
+      },
+      "next",
+    );
+  },
+  BROWSER_TEST_MS,
+);
+
+test(
+  "a Keep needs no reason and writes none: the page stays quiet",
+  async () => {
+    const { page: html } = build(setup("browser-keep", approval()));
+    const browser = await chromium.launch({
+      executablePath: chromiumPath(),
+      args: ["--no-sandbox"],
+    });
+    try {
+      const page = await browser.newPage();
+      await page.addInitScript(STORE(PRACTICE_DONE, 20));
+      await page.goto("about:blank");
+      await page.setContent(html, { waitUntil: "domcontentloaded" });
+      await page.getByRole("button", { name: /Keep/ }).first().click();
+      await page.waitForTimeout(1200); // longer than the reason's pause: nothing more may arrive
+      assert.equal(await page.locator("textarea").count(), 0);
+      assert.deepEqual(
+        (await writes(page)).map((w) => w.reasons),
+        [{}],
+      );
+    } finally {
+      await browser.close();
+    }
+  },
+  BROWSER_TEST_MS,
+);

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" },
@@ -123,6 +130,10 @@ const integer = (required = true) => ({
     kind: "integer",
     required,
 });
+const boolean = (required = true) => ({
+    kind: "boolean",
+    required,
+});
 const array = (items, required = true, min = 0) => ({
     kind: "array",
     required,
@@ -136,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).
@@ -173,6 +187,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),
@@ -227,6 +244,10 @@ function checkObject(value, node, path, where) {
         fail(`${at(path, unknown)}: not a known field (known: ${Object.keys(node.fields).join(", ")})`);
     }
 }
+function checkBoolean(value, where) {
+    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, node, path) {
     const where = path || "items.json";
@@ -239,6 +260,9 @@ function checkValue(value, node, path) {
                 fail(`${where}: must be an integer, got ${repr(value)}`);
             }
             break;
+        case "boolean":
+            checkBoolean(value, where);
+            break;
         case "array":
             checkArray(value, node, path, where);
             break;
@@ -258,15 +282,17 @@ function assertConfig(value) {
  * 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) => ({
+const allowedValues = (questions, asksFamiliarity) => ({
     questions: Object.fromEntries(questions.map((q) => [q.id, q.options.map((o) => o.value)])),
     // The answers that need a reason, per question: the page and the export read the same list.
     needs_why: Object.fromEntries(questions.map((q) => [
         q.id,
         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) => cfg.familiarity !== false;
 /** Two values that read the same once case and surrounding space are gone. */
 const readsAs = (s) => s.trim().toLowerCase();
 /** The first entry whose reading repeats an earlier one, with the index of that earlier one. */
@@ -330,6 +356,9 @@ function checkPractice(cfg) {
 }
 function checkConfig(cfg) {
     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, qn, cfg.questions.slice(0, qn).map((x) => x.id));
     });
@@ -337,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) => {
@@ -354,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
@@ -366,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).`);
             }
@@ -407,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;
@@ -432,9 +510,11 @@ function payloadOf(cfg, page) {
         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) })),
@@ -478,7 +558,7 @@ function keyOf(cfg, page, earlier) {
         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),
@@ -503,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");
@@ -658,6 +739,14 @@ function checkDump(dump, key) {
         }
     }
 }
+/** A page built with `familiarity: false` asks no group anything: a group document came from elsewhere. */
+function checkNoFamiliarity(dump, allowed) {
+    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`);
+    }
+}
 /** The key's `allowed` lists, or a refusal naming a key made by an older build. */
 function assertAllowed(a, key, keyPath) {
     const questions = isObject(a) ? a["questions"] : undefined;
@@ -818,7 +907,9 @@ function exportRound(study, round, items, at) {
 function labelsOf(dump, ctx, day) {
     const onPage = Object.entries(ctx.key.ids).filter(([, m]) => m.on_page);
     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,
@@ -839,6 +930,7 @@ export function exportLabels(dumpPath, keyPath, outDir, day) {
     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`);