@scientific-method/standard-checker 0.1.0 → 0.2.0

package/dist/checks/parity.js

@@ -0,0 +1,189 @@
+// The parity matrix. The parity rows live in parity/, one file per area, split by kind and then by
+// block where the limit requires it. PARITY.md holds the totals and is written by the check.
+import { existsSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { collectPlaceholders } from "../code-files.js";
+import { mayBeInterrupted, onlyEmulatedRuns } from "../evidence.js";
+import { markdownTree, walk } from "../files.js";
+import { areaOf, compareIds, kindOf } from "../ids.js";
+import { readText, tables } from "../markdown.js";
+import { LINE_LIMIT } from "../standard.js";
+import { blockOf, layout } from "../generate/layout.js";
+/** The columns of a parity table. */
+export const PARITY_HEADER = ["Spec ID", "Title", "Spec status", "Code", "Tests", "Deviations", "Status", "Notes"];
+/**
+ * Checks the rows in parity/ against the spec, the deviations and the code, and that each area is
+ * split exactly where the line limit requires. Then reports a live deviation that departs from no
+ * entry with a row.
+ */
+export function checkParity(ctx, deviations) {
+    const { problem } = ctx;
+    const { entries, areas } = ctx.spec;
+    const { repoDir } = ctx.config;
+    const parityDir = join(repoDir, "parity");
+    const parityRows = new Map(); // spec ID -> { cells, file }
+    const parityCounts = { status: {}, code: {} };
+    const validatedTests = new Map(); // marked test file of a validated row -> [{ specId, file }]
+    // A test file that reads the original's files through GAME_DIR says so with this comment. It runs
+    // only on a maintainer's machine, so its validated rows need it in VALIDATION.md; every other test
+    // runs in CI.
+    const NEEDS_GAME = /needs:\s*GAME_DIR/;
+    const needsGame = (p) => existsSync(p) && NEEDS_GAME.test(readFileSync(p, "utf8"));
+    // A PARITY.md that still holds the rows is left alone until they have moved, so the check does not
+    // overwrite them with the totals.
+    const legacyParity = existsSync(join(repoDir, "PARITY.md")) &&
+        tables(readText(join(repoDir, "PARITY.md"))).some((t) => t.header.join("|") === PARITY_HEADER.join("|"));
+    {
+        if (!existsSync(parityDir))
+            problem(null, "parity/ is missing");
+        if (legacyParity)
+            problem(join(repoDir, "PARITY.md"), "the rows move to parity/, one <AREA>.md per area, and the check writes PARITY.md");
+        const placeholders = collectPlaceholders(ctx.codeFiles());
+        const files = existsSync(parityDir) ? markdownTree(parityDir) : new Map();
+        walk(parityDir, (f) => {
+            if (!f.endsWith(".md") && basename(f) !== ".gitkeep")
+                problem(f, "is not a parity file; parity/ holds one <AREA>.md per area");
+        });
+        const byArea = new Map(); // area -> Map of path -> ids in the file
+        for (const [path, file] of files) {
+            const text = readText(file);
+            if (!text.startsWith(`# ${path}\n`))
+                problem(file, `opens with its path as a # heading: # ${path}`);
+            const [area, kind, block, ...rest] = path.split("/");
+            if (!areas.includes(area)) {
+                problem(file, `${area} is not an area in the area list`);
+                continue;
+            }
+            if (rest.length > 0 || (kind !== undefined && !["RULE", "FMT", "SCR"].includes(kind))) {
+                problem(file, "is not an area, kind or block file of parity/");
+                continue;
+            }
+            const ts = tables(text);
+            if (ts.length !== 1 || ts[0].header.join("|") !== PARITY_HEADER.join("|")) {
+                problem(file, `holds one table with the columns ${PARITY_HEADER.join(" | ")}`);
+                continue;
+            }
+            if (!byArea.has(area))
+                byArea.set(area, new Map());
+            const inFile = [];
+            byArea.get(area).set(path, inFile);
+            let previous = "";
+            for (const row of ts[0].rows) {
+                if (row.length !== PARITY_HEADER.length) {
+                    problem(file, `the row ${row.join(" | ")} has ${row.length} cells, not ${PARITY_HEADER.length}`);
+                    continue;
+                }
+                const cells = row.map((c) => c.replaceAll("`", "").trim());
+                const [specId, title, specStatus, code, tests, devs, status, notes] = cells;
+                if (parityRows.has(specId))
+                    problem(file, `${specId} has more than one row`);
+                parityRows.set(specId, { cells: row, file });
+                inFile.push(specId);
+                if (areaOf(specId) !== area || (kind && kindOf(specId) !== kind) || (block && blockOf(specId) !== block))
+                    problem(file, `${specId} does not belong in parity/${path}.md`);
+                if (compareIds(specId, previous) < 0)
+                    problem(file, `${specId} is out of ID order`);
+                previous = specId;
+                const e = entries.get(specId);
+                if (!e) {
+                    problem(file, `${specId} does not exist in the spec`);
+                    continue;
+                }
+                if (!["RULE", "FMT", "SCR"].includes(e.kind) || e.meta.status === "superseded")
+                    problem(file, `${specId} cannot have a row`);
+                if (title !== e.meta.title)
+                    problem(file, `${specId}: Title must be "${e.meta.title}"`);
+                if (specStatus !== e.meta.status)
+                    problem(file, `${specId}: Spec status must be ${e.meta.status}`);
+                if (!["missing", "partial", "complete"].includes(code))
+                    problem(file, `${specId}: Code must be missing, partial or complete`);
+                if (code === "complete" && e.meta.status === "unknown")
+                    problem(file, `${specId}: an unknown entry cannot be complete`);
+                if (code === "complete" && placeholders.has(specId))
+                    problem(file, `${specId}: a PLACEHOLDER comment cites it, so it cannot be complete`);
+                const testFiles = tests === "None"
+                    ? []
+                    : tests
+                        .split(",")
+                        .map((x) => x.trim())
+                        .filter(Boolean);
+                for (const tf of testFiles) {
+                    const p = join(repoDir, tf);
+                    if (!existsSync(p))
+                        problem(file, `${specId}: test file ${tf} does not exist`);
+                    else {
+                        const text = readFileSync(p, "utf8");
+                        if (!text.includes(specId))
+                            problem(file, `${specId}: test file ${tf} does not mention ${specId}`);
+                        if (text.includes("GAME_DIR") && !NEEDS_GAME.test(text))
+                            problem(file, `${specId}: test file ${tf} mentions GAME_DIR without a "needs: GAME_DIR" comment, so CI would skip it unseen`);
+                    }
+                }
+                const listedDevs = devs === "None"
+                    ? []
+                    : devs
+                        .split(",")
+                        .map((x) => x.trim())
+                        .filter(Boolean);
+                const expectedDevs = [...deviations]
+                    .filter(([, d]) => !d.dropped && d.departs.includes(specId))
+                    .map(([k]) => k)
+                    .sort(compareIds);
+                if (listedDevs.slice().sort(compareIds).join(",") !== expectedDevs.join(","))
+                    problem(file, `${specId}: Deviations must be ${expectedDevs.join(", ") || "None"}`);
+                let expectedStatus;
+                if (code !== "complete" || e.meta.status === "disputed")
+                    expectedStatus = e.meta.status;
+                else if (testFiles.length === 0)
+                    expectedStatus = "implemented";
+                else if (["supported", "established"].includes(e.meta.status))
+                    expectedStatus = "validated";
+                else {
+                    problem(file, `${specId}: complete with tests while the spec status is ${e.meta.status}; the evidence belongs in the spec entry first`);
+                    expectedStatus = status;
+                }
+                if (status !== expectedStatus)
+                    problem(file, `${specId}: Status must be ${expectedStatus}`);
+                if (expectedStatus === "validated")
+                    for (const tf of testFiles.filter((x) => needsGame(join(repoDir, x)))) {
+                        if (!validatedTests.has(tf))
+                            validatedTests.set(tf, []);
+                        validatedTests.get(tf).push({ specId, file });
+                    }
+                if (expectedStatus === "validated" && mayBeInterrupted(e) && onlyEmulatedRuns(entries, e))
+                    problem(file, `${specId}: another rule may interrupt it (# may run:), so tests against emulated calls alone cannot validate it`, "STATUS-15");
+                for (const cell of [code, tests, devs, notes])
+                    if (cell === "")
+                        problem(file, `${specId}: an empty cell says None`);
+                parityCounts.status[status] = (parityCounts.status[status] ?? 0) + 1;
+                parityCounts.code[code] = (parityCounts.code[code] ?? 0) + 1;
+            }
+        }
+        for (const [id, e] of entries)
+            if (["RULE", "FMT", "SCR"].includes(e.kind) && e.meta.status !== "superseded" && !parityRows.has(id))
+                problem(parityDir, `${id} has no row`);
+        // Each area is split exactly where the limit requires it, going by the rows it has.
+        for (const [area, actual] of byArea) {
+            const ids = [...actual.values()]
+                .flat()
+                .filter((x) => entries.has(x))
+                .sort(compareIds);
+            const render = (subset, path) => [
+                `# ${path}`,
+                "",
+                `| ${PARITY_HEADER.join(" | ")} |`,
+                `|${"---|".repeat(PARITY_HEADER.length)}`,
+                ...subset.map((x) => `| ${parityRows.get(x).cells.join(" | ")} |`),
+                "",
+            ].join("\n");
+            const expected = [...layout(ctx, area, ids, render, 1).keys()];
+            const found = [...actual.keys()].sort();
+            if (expected.slice().sort().join(",") !== found.join(","))
+                problem(parityDir, `the rows of ${area} belong in ${expected.map((p) => `parity/${p}.md`).join(", ")}, split only where the ${LINE_LIMIT}-line limit requires it; found ${found.map((p) => `parity/${p}.md`).join(", ")}`);
+        }
+    }
+    for (const [dev, d] of deviations)
+        if (!d.dropped && !d.departs.some((x) => parityRows.has(x)))
+            problem(d.file, `${dev} departs from no entry that has a parity row`);
+    return { rows: parityRows, counts: parityCounts, validatedTests, legacy: legacyParity };
+}

package/dist/checks/references.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from "../context.ts";
+import type { Deviation } from "./deviations.ts";
+/** Checks the IDs that the code, the references, parity/ and deviations/ cite. */
+export declare function checkReferences(ctx: Context, deviations: Map<string, Deviation>): void;

package/dist/checks/references.js

@@ -0,0 +1,37 @@
+// Implementation references: every spec and deviation ID in code, tests, the parity files and the
+// deviation files resolves. A deviation keeps citing what it departed from after that is superseded.
+import { readFileSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
+import { isSuperseded } from "../evidence.js";
+import { walk } from "../files.js";
+import { idsIn, isAlias } from "../ids.js";
+import { DEV_RE } from "../standard.js";
+/** Checks the IDs that the code, the references, parity/ and deviations/ cite. */
+export function checkReferences(ctx, deviations) {
+    const { problem } = ctx;
+    const { entries } = ctx.spec;
+    const { repoDir } = ctx.config;
+    const parityDir = join(repoDir, "parity");
+    const devDir = join(repoDir, "deviations");
+    const isDeviationFile = (f) => resolve(f).startsWith(devDir + sep);
+    const scan = ctx.codeFiles().filter(({ file }) => !file.endsWith(".fs"));
+    for (const dir of [parityDir, devDir])
+        walk(dir, (f) => {
+            if (f.endsWith(".md"))
+                scan.push({ file: f, text: readFileSync(f, "utf8") });
+        });
+    for (const { file: f, text } of scan) {
+        for (const x of idsIn(text)) {
+            if (isAlias(x) && !entries.has(x))
+                continue; // aliases can collide with ordinary words
+            if (!entries.has(x))
+                problem(f, `cites ${x}, which does not exist in the spec`);
+            else if (isSuperseded(entries, x) && !isDeviationFile(f))
+                problem(f, `cites ${x}, which is superseded; cite what replaced it`);
+        }
+        if (!isDeviationFile(f))
+            for (const x of new Set(text.match(DEV_RE) ?? []))
+                if (!deviations.has(x))
+                    problem(f, `cites ${x}, which is not in deviations/`);
+    }
+}

package/dist/checks/rules.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from "../context.ts";
+import type { FormatNames } from "./formats.ts";
+/** Checks every rule's procedure. Sets Entry.code on every rule entry, superseded ones included. */
+export declare function checkRules(ctx: Context, { enumNames }: FormatNames): void;

package/dist/checks/rules.js

@@ -0,0 +1,259 @@
+// Rules: procedures against the glossary and the formats. Reads each rule's Procedure into
+// Entry.code, then checks the names every live procedure declares, calls, reads and relies on.
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { mayBeInterrupted, onlyEmulatedRuns } from "../evidence.js";
+import { asList, idsIn, kindOf } from "../ids.js";
+import { readCsv } from "../markdown.js";
+import { KINDS, LIST_LIMIT } from "../standard.js";
+const BUILTINS = new Set([
+    "min",
+    "max",
+    "abs",
+    "count",
+    "append",
+    "insert",
+    "remove_at",
+    "copy",
+    "stable_sort",
+    "sprintf",
+    "floor",
+    "ceil",
+    "round_even",
+    "draw",
+    "resource",
+    "read_file",
+    "write_file",
+    "free",
+    "fmod",
+    "UINT8",
+    "INT8",
+    "UINT16",
+    "INT16",
+    "UINT32",
+    "INT32",
+    "UINT64",
+    "INT64",
+    "FLOAT32",
+    "FLOAT64",
+    "FLOAT80",
+    "REAL48",
+]);
+const KEYWORDS = new Set([
+    "for",
+    "each",
+    "in",
+    "if",
+    "else",
+    "while",
+    "break",
+    "continue",
+    "return",
+    "let",
+    "and",
+    "or",
+    "not",
+    "true",
+    "false",
+    "call",
+    "define",
+    "emit",
+    "drain",
+    "show",
+    "new",
+    "table",
+    "clock",
+    "from",
+    "Hz",
+]);
+/** Checks every rule's procedure. Sets Entry.code on every rule entry, superseded ones included. */
+export function checkRules(ctx, { enumNames }) {
+    const { problem } = ctx;
+    const { entries, glossary, glossaryDir } = ctx.spec;
+    const defined = new Map(); // function/table/clock name -> rule IDs
+    // A superseded rule keeps its procedure for history, but its declarations own no active name.
+    const historical = new Map(); // name declared by superseded rules -> rule IDs
+    for (const [id, e] of entries) {
+        if (e.kind !== "RULE")
+            continue;
+        const proc = e.sections.find((s) => s.title === "Procedure")?.text ?? "";
+        e.code = [...proc.matchAll(/```text\n([\s\S]*?)```/g)].map((m) => m[1]).join("\n");
+        const owners = e.meta.status === "superseded" ? historical : defined;
+        for (const m of e.code.matchAll(/^\s*(?:define\s+([a-z_][a-z0-9_]*)\s*\(|table\s+([a-z_][a-z0-9_]*)\s*:|clock\s+([a-z_][a-z0-9_]*)\s*:)/gm)) {
+            const name = m[1] ?? m[2] ?? m[3];
+            if (!owners.has(name))
+                owners.set(name, []);
+            owners.get(name).push(id);
+        }
+    }
+    // A live procedure cannot rely on a name only a superseded rule declares.
+    const onlyHistorical = (name) => !defined.has(name) && historical.has(name);
+    for (const [name, ids] of defined) {
+        const splitGroup = asList(entries.get(ids[0]).meta.split_with).concat(ids[0]);
+        if (ids.length > 1 && !ids.every((x) => splitGroup.includes(x)))
+            problem(null, `${name} is defined by more than one rule: ${ids.join(", ")}`);
+        if (!glossary.has(name))
+            problem(glossaryDir, `${name}, defined by ${ids[0]}, has no glossary entry`);
+    }
+    for (const [id, e] of entries) {
+        if (e.kind !== "RULE" || e.meta.status === "superseded")
+            continue;
+        const { file, meta } = e;
+        // Types in a define's signature (`define roll(n: UINT16) -> char[]:`) are not names the
+        // procedure reads, so they are dropped before the name checks.
+        const TYPE = String.raw `(?:[A-Za-z][A-Za-z0-9]*|FMT-[A-Z0-9]+-\d+)(?:\[[^\]]*\])?`;
+        const code = e
+            .code.replace(/#.*$/gm, "")
+            .replace(/"[^"]*"/g, '""')
+            .replace(new RegExp(String.raw `(\bdefine\s+[a-z_][a-z0-9_]*\s*\()([^)]*)\)(\s*->\s*${TYPE})?`, "g"), (_, head, params) => `${head}${params
+            .split(",")
+            .map((p) => p.split(":")[0].trim())
+            .join(", ")})`);
+        const related = asList(meta.related);
+        const openQuestions = e.sections.find((s) => s.title === "Open questions")?.text ?? "";
+        // Names are letters, digits and underscores, so best_score does not count as listing score.
+        const listsOpen = (name) => new RegExp(`(?<![A-Za-z0-9_])${name}(?![A-Za-z0-9_])`).test(openQuestions);
+        if (meta.status !== "unknown" && e.code.trim() === "")
+            problem(file, "Procedure has no ```text block");
+        const usedTerms = new Set();
+        const useTerm = (name) => {
+            if (glossary.has(name))
+                usedTerms.add(name);
+            return glossary.has(name);
+        };
+        // Lists written out hold at most LIST_LIMIT values; a table of more takes them from a value file.
+        for (const m of code.matchAll(/=\s*\[([^\]]*)\]/g)) {
+            const count = m[1].split(",").filter((x) => x.trim() !== "").length;
+            if (count > LIST_LIMIT)
+                problem(file, `writes out a list of ${count} values; a list of more than ${LIST_LIMIT} is a table with a value file`);
+        }
+        for (const m of e.code.matchAll(/^\s*table\s+([a-z_][a-z0-9_]*)\s*:\s*[A-Za-z0-9]+\[([^\]]*)\]\s*from\s*"([^"]*)"/gm)) {
+            const [, name, count, csvName] = m;
+            const expected = `${id}.${name}.csv`;
+            if (csvName !== expected) {
+                problem(file, `table ${name} takes its values from ${expected}, not ${csvName}`);
+                continue;
+            }
+            const path = join(dirname(file), csvName);
+            if (!existsSync(path)) {
+                problem(file, `value file ${csvName} does not exist`);
+                continue;
+            }
+            const csv = readCsv(path, problem);
+            if (!csv)
+                continue;
+            if (csv.header.join("|") !== "value")
+                problem(path, "a table's value file has the single column value");
+            if (/^\d+$/.test(count.trim()) && csv.rows.length !== Number(count))
+                problem(path, `has ${csv.rows.length} values, but table ${name} has ${count}`);
+            for (const [v] of csv.rows)
+                if (!/^-?(?:0x[0-9A-Fa-f]+|\d+(?:\.\d+)?)$/.test(v.trim())) {
+                    problem(path, `${v} is not a number`);
+                    break;
+                }
+        }
+        for (const m of code.matchAll(/\bcall\s+(RULE-[A-Z0-9]+-\d+)/g))
+            if (!related.includes(m[1]))
+                problem(file, `calls ${m[1]}; add it to related`, "ENTRY-TYPES-6");
+        for (const m of code.matchAll(/\bshow\s+(SCR-[A-Z0-9]+-\d+)/g))
+            if (!related.includes(m[1]))
+                problem(file, `shows ${m[1]}; add it to related`, "ENTRY-TYPES-6");
+        for (const m of code.matchAll(/\b(FMT-[A-Z0-9]+-\d+)/g))
+            if (!related.includes(m[1]))
+                problem(file, `uses ${m[1]}; add it to related`, "ENTRY-TYPES-6");
+        for (const m of e.code.matchAll(/# may run: (RULE-[A-Z0-9]+-\d+)/g))
+            if (!related.includes(m[1]))
+                problem(file, `may be interrupted by ${m[1]}; add it to related`, "ENTRY-TYPES-6");
+        if (meta.status === "established" && mayBeInterrupted(e) && onlyEmulatedRuns(entries, e))
+            problem(file, "another rule may interrupt this procedure (# may run:), so emulated calls alone cannot establish it", "STATUS-15");
+        if (asList(meta.complete_reading).length > 0 && /# may run: RULE-/.test(e.code))
+            problem(file, "another rule may interrupt this procedure (# may run:), so a complete reading cannot establish it; leave complete_reading empty", "STATUS-4");
+        for (const x of idsIn(code))
+            if (!entries.has(x))
+                problem(file, `procedure names ${x}, which does not exist`);
+        for (const m of code.matchAll(/\bemit\s+([A-Za-z_][A-Za-z0-9_]*)/g))
+            if (!useTerm(m[1]))
+                problem(file, `emits ${m[1]}, which has no glossary entry`);
+        for (const m of code.matchAll(/\bdrain\s+([A-Za-z_][A-Za-z0-9_]*)/g))
+            if (!useTerm(m[1]))
+                problem(file, `drains ${m[1]}, which has no glossary entry`);
+        for (const m of code.matchAll(/\b((?:fn|g|scr)_[A-Za-z0-9_]+)\b/g)) {
+            if (!useTerm(m[1]))
+                problem(file, `uses the neutral name ${m[1]}, which has no glossary entry`);
+            if (!listsOpen(m[1]))
+                problem(file, `uses the neutral name ${m[1]}; list it in Open questions`);
+        }
+        const noNeutral = code.replace(/\b(?:fn|g|scr)_[A-Za-z0-9_]+\b/g, "");
+        if (/\b0x[0-9A-Fa-f]{6,}\b/.test(noNeutral) && /\b0x00[4-9A-F][0-9A-F]{5}\b/.test(noNeutral))
+            problem(file, "the procedure contains what looks like an address outside a neutral name");
+        // Functions called without `call`
+        const locals = new Set();
+        for (const m of code.matchAll(/\blet\s+([a-z_][a-z0-9_]*)/g))
+            locals.add(m[1]);
+        for (const m of code.matchAll(/\bfor\s+(?:each\s+)?([a-z_][a-z0-9_]*)\s+in\b/g))
+            locals.add(m[1]);
+        for (const m of code.matchAll(/\bdefine\s+[a-z_][a-z0-9_]*\s*\(([^)]*)\)/g))
+            for (const p of m[1].split(","))
+                locals.add(p.split(":")[0].trim());
+        const params = e.sections.find((s) => s.title === "Parameters")?.text ?? "";
+        for (const m of params.matchAll(/`([a-z_][a-z0-9_]*)`/g))
+            locals.add(m[1]);
+        for (const m of code.matchAll(/(?<![.\w])([a-z_][a-z0-9_]*)\s*\(/g)) {
+            const name = m[1];
+            if (BUILTINS.has(name) || KEYWORDS.has(name) || locals.has(name))
+                continue;
+            if (onlyHistorical(name)) {
+                problem(file, `calls ${name}(), which only superseded ${historical.get(name).join(", ")} defines`);
+                continue;
+            }
+            if (!defined.has(name) && !useTerm(name)) {
+                problem(file, `calls ${name}(), which no rule defines and the glossary does not list`);
+                continue;
+            }
+            for (const owner of defined.get(name) ?? [])
+                if (owner !== id && !related.includes(owner))
+                    problem(file, `uses ${name} from ${owner}; add ${owner} to related`, "ENTRY-TYPES-6");
+        }
+        for (const m of code.matchAll(/(?<![.\w])([A-Z][A-Z0-9_]*[A-Z0-9])(?![\w-])/g)) {
+            const name = m[1];
+            if (BUILTINS.has(name) || KINDS[name] || /^(?:FMT|RULE|SCR)$/.test(name))
+                continue;
+            if (!enumNames.has(name)) {
+                problem(file, `upper-case name ${name} is not an enumeration name of any format`);
+                continue;
+            }
+            for (const fmt of enumNames.get(name))
+                if (!related.includes(fmt))
+                    problem(file, `uses ${name} from ${fmt}; add it to related`, "ENTRY-TYPES-6");
+        }
+        // Names read or assigned without let that are neither locals nor glossary terms
+        for (const m of code.matchAll(/(?<![.\w])([a-z_][a-z0-9_]*)(?=\s*(?:\.|\[|=[^=]|$))/gm)) {
+            const name = m[1];
+            if (locals.has(name) || KEYWORDS.has(name) || BUILTINS.has(name) || defined.has(name))
+                continue;
+            if (onlyHistorical(name)) {
+                problem(file, `${name} is declared only by superseded ${historical.get(name).join(", ")}`);
+                continue;
+            }
+            if (!useTerm(name))
+                problem(file, `${name} is neither a local nor a glossary term`);
+        }
+        // A glossary claim a procedure relies on counts toward the rule's status: its evidence is the
+        // rule's evidence, and while it is (unknown) the rule lists it as an open question and is not
+        // established.
+        for (const term of usedTerms) {
+            const text = glossary.get(term);
+            for (const b of text.matchAll(/\[([^\]]*)\]/g))
+                for (const x of idsIn(b[1])) {
+                    if (["FND", "EXP"].includes(kindOf(x)) && !asList(meta.evidence).includes(x))
+                        problem(file, `relies on ${term}, whose glossary entry cites ${x}; add it to evidence`);
+                }
+            if (text.includes("(unknown)")) {
+                if (!listsOpen(term))
+                    problem(file, `relies on ${term}, a glossary claim that is (unknown); list it in Open questions`);
+                if (meta.status === "established")
+                    problem(file, `relies on ${term}, a glossary claim that is (unknown), so it cannot be established`);
+            }
+        }
+    }
+}

package/dist/checks/screens.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from "../context.ts";
+import type { Entry } from "../types.ts";
+/** Checks a screen entry. */
+export declare function checkScreen(ctx: Context, e: Entry): void;

package/dist/checks/screens.js

@@ -0,0 +1,44 @@
+// The checks of a screen entry: its resolution, the tables of its sections, and the evidence and
+// related entries those tables cite.
+import { checkResolves } from "../evidence.js";
+import { asList, idsIn, kindOf } from "../ids.js";
+import { tables } from "../markdown.js";
+import { SCREEN_TABLES } from "../standard.js";
+import { tableIds } from "./formats.js";
+/** Checks a screen entry. */
+export function checkScreen(ctx, e) {
+    const { problem } = ctx;
+    const { file, meta } = e;
+    if (!/^\d+x\d+$/.test(String(meta.resolution)))
+        problem(file, "resolution must be written WIDTHxHEIGHT");
+    for (const s of e.sections) {
+        const want = SCREEN_TABLES[s.title];
+        if (!want)
+            continue;
+        const ts = tables(s.text);
+        if (ts.length === 0 && !/^\s*None( known)?\.\s*$/.test(s.text))
+            problem(file, `${s.title} has neither a table nor None known.`);
+        for (const t of ts)
+            if (t.header.join("|") !== want.join("|"))
+                problem(file, `${s.title} table has the columns ${want.join(" | ")}`);
+    }
+    const cited = tableIds(e, Object.keys(SCREEN_TABLES));
+    const listed = new Set([...asList(meta.evidence), ...asList(meta.conflicting)]);
+    for (const x of cited)
+        if (!listed.has(x) && ["FND", "EXP", "SRC"].includes(kindOf(x)))
+            problem(file, `${x} is cited in a table but not in evidence or conflicting`);
+    for (const s of e.sections)
+        for (const t of tables(s.text)) {
+            for (const col of ["Effect", "Shows"]) {
+                const c = t.header.indexOf(col);
+                if (c < 0)
+                    continue;
+                for (const row of t.rows)
+                    for (const x of idsIn(row[c]))
+                        if (["RULE", "SCR"].includes(kindOf(x)) && !asList(meta.related).includes(x))
+                            problem(file, `${col} cell names ${x}; add it to related`, "ENTRY-TYPES-6");
+            }
+        }
+    for (const x of cited)
+        checkResolves(ctx, file, [x], "a table");
+}

package/dist/checks/validation.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from "../context.ts";
+import type { Parity } from "./parity.ts";
+/**
+ * With --record-validation, writes VALIDATION.md (or prints why it cannot and exits with 2). Then
+ * checks VALIDATION.md against the marked test files of the validated rows.
+ */
+export declare function checkValidation(ctx: Context, { validatedTests }: Parity): void;