@scientific-method/standard-checker 0.1.0 → 0.3.0

package/dist/checks/entries.js

@@ -0,0 +1,131 @@
+// The checks every entry gets: its ID, fields, sections, status and links. Each kind's own checks
+// are called from here, in the order the standard lists them.
+import { checkResolves, isSuperseded } from "../evidence.js";
+import { asList, kindOf } from "../ids.js";
+import { CLAIM_STATUSES, EVIDENCE_STATUSES, FIELD_RULES, FIELDS, KINDS, SECTIONS } from "../standard.js";
+import { checkClaim } from "./claims.js";
+import { checkExperiment, checkFinding } from "./evidence-entries.js";
+import { checkFormat } from "./formats.js";
+import { checkScreen } from "./screens.js";
+function checkIdForm(ctx, file, id) {
+    const { problem } = ctx;
+    const { areas } = ctx.spec;
+    const kind = kindOf(id);
+    if (!KINDS[kind]) {
+        problem(file, `${id} is not an ID of a known kind`, "IDENTIFIERS-1");
+        return;
+    }
+    if (kind === "BLD" || kind === "SRC") {
+        if (!/^(BLD|SRC)-[A-Z][A-Z0-9.-]*$/.test(id))
+            problem(file, `${id}: an alias starts with an upper-case letter and holds only upper-case letters, digits, dots and hyphens`, "IDENTIFIERS-4");
+        return;
+    }
+    const m = /^[A-Z]+-([A-Z][A-Z0-9]*)-(\d+)$/.exec(id);
+    if (!m) {
+        problem(file, `${id} does not have the form KIND-AREA-NNN`, "IDENTIFIERS-1");
+        return;
+    }
+    if (!areas.includes(m[1]))
+        problem(file, `${id}: area ${m[1]} is not in the area list`, "IDENTIFIERS-2");
+    if (m[2].length < 3 || (m[2].length > 3 && m[2].startsWith("0")))
+        problem(file, `${id}: the number is zero-padded to exactly three digits until it passes 999`, "IDENTIFIERS-3");
+}
+/**
+ * Checks every entry, kind by kind, and returns the names the formats' tables define, which the
+ * rule checks read.
+ */
+export function checkEntries(ctx) {
+    const { problem } = ctx;
+    const { entries } = ctx.spec;
+    const names = {
+        enumNames: new Map(), // name -> format IDs
+        fieldNames: new Map(), // format ID -> Set of names
+        layouts: new Map(), // format ID -> layout Name -> Type
+    };
+    for (const [id, e] of entries) {
+        const { file, meta, kind } = e;
+        checkIdForm(ctx, file, id);
+        for (const f of FIELDS[kind].required)
+            if (!(f in meta))
+                problem(file, `front matter lacks ${f}`, FIELD_RULES[f]);
+        if (!Array.isArray(meta.superseded_by))
+            problem(file, "superseded_by must be a list", FIELD_RULES.superseded_by);
+        const expectedSections = SECTIONS[kind];
+        const got = e.sections.map((s) => s.title);
+        if (got.join("|") !== expectedSections.join("|"))
+            problem(file, `sections must be ${expectedSections.join(", ")} in that order; found ${got.join(", ") || "none"}`, "ENTRY-TYPES-1");
+        for (const s of e.sections)
+            if (s.text.trim() === "")
+                problem(file, `section ${s.title} is empty; write None known. or None.`, "ENTRY-TYPES-2");
+        const superseded = asList(meta.superseded_by);
+        const status = meta.status;
+        if (KINDS[kind].statuses === "claim" && !CLAIM_STATUSES.includes(status))
+            problem(file, `status ${status} is not one of ${CLAIM_STATUSES.join(", ")}`, "STATUS-1");
+        if (KINDS[kind].statuses === "evidence" && !EVIDENCE_STATUSES.includes(status))
+            problem(file, `status ${status} is not one of ${EVIDENCE_STATUSES.join(", ")}`, "STATUS-21");
+        const isSup = status === "superseded" || ((kind === "BLD" || kind === "SRC") && superseded.length > 0);
+        if (status === "superseded" && superseded.length === 0)
+            problem(file, "a superseded entry names what replaced or disproved it in superseded_by", "IDENTIFIERS-7");
+        if (status && status !== "superseded" && superseded.length > 0)
+            problem(file, "superseded_by must be empty unless the status is superseded", "ENTRY-TYPES-4");
+        checkResolves(ctx, file, superseded, "superseded_by");
+        for (const s of superseded) {
+            const k = kindOf(s);
+            const ok = ["FND", "EXP"].includes(kind)
+                ? ["FND", "EXP"].includes(k)
+                : kind === "BLD"
+                    ? k === "BLD"
+                    : kind === "SRC"
+                        ? k === "SRC"
+                        : kind === "BUG"
+                            ? true
+                            : k !== "SRC" && k !== "BLD";
+            if (!ok)
+                problem(file, `superseded_by may not name ${s}`, "IDENTIFIERS-7");
+        }
+        if (kind !== "BLD" && kind !== "SRC") {
+            const builds = asList(meta.builds);
+            if (builds.length === 0)
+                problem(file, "builds must list at least one build");
+            checkResolves(ctx, file, builds, "builds");
+            for (const b of builds)
+                if (entries.has(b) && kindOf(b) !== "BLD")
+                    problem(file, `builds lists ${b}, which is not a build`);
+        }
+        // Links that must not point at superseded entries
+        if (!isSup) {
+            const linkFields = ["builds", "evidence", "conflicting", "related"];
+            for (const f of linkFields)
+                for (const t of asList(meta[f]))
+                    if (entries.has(t) && isSuperseded(entries, t))
+                        problem(file, `${f} cites ${t}, which is superseded`, "STATUS-17");
+            for (const loc of asList(meta.locations))
+                if (loc && entries.has(loc.build) && isSuperseded(entries, loc.build))
+                    problem(file, `a location names ${loc.build}, which is superseded`, "STATUS-17");
+        }
+        if (["FND", "EXP"].includes(kind)) {
+            const rep = asList(meta.reproduced_by);
+            if (status === "reproduced" && rep.every((p) => p === meta.recorded_by))
+                problem(file, "a reproduced entry names someone other than recorded_by in reproduced_by", "STATUS-21");
+            if (status !== "reproduced" && rep.length > 0)
+                problem(file, "reproduced_by must be empty unless the status is reproduced", "STATUS-21");
+            if (typeof meta.recorded_by !== "string" || !meta.recorded_by)
+                problem(file, "recorded_by must be a GitHub username");
+        }
+        if (kind === "FND")
+            checkFinding(ctx, e);
+        if (kind === "EXP")
+            checkExperiment(ctx, id, e, isSup);
+        if (KINDS[kind].statuses === "claim")
+            checkClaim(ctx, id, e);
+        if (kind === "BLD" && ![16, 32].includes(meta.int_width))
+            problem(file, "int_width must be 16 or 32");
+        if (kind === "SRC" && meta.xxh3 !== null && !/^[0-9a-f]{32}$/.test(String(meta.xxh3)))
+            problem(file, "xxh3 must be null or 32 lower-case hex digits");
+        if (kind === "FMT")
+            checkFormat(ctx, e, names);
+        if (kind === "SCR")
+            checkScreen(ctx, e);
+    }
+    return names;
+}

package/dist/checks/evidence-entries.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from "../context.ts";
+import type { Entry } from "../types.ts";
+/** Checks a finding's method, environment and locations. */
+export declare function checkFinding(ctx: Context, e: Entry): void;
+/** Checks an experiment's builds, fixture, starting state and recording. live is false once it is superseded. */
+export declare function checkExperiment(ctx: Context, id: string, e: Entry, isSup: boolean): void;

package/dist/checks/evidence-entries.js

@@ -0,0 +1,167 @@
+// The checks of findings and experiments: a finding's locations, and an experiment's fixture,
+// starting state and recording.
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { isSuperseded } from "../evidence.js";
+import { asList } from "../ids.js";
+import { checkAddress, checkOffset } from "../locations.js";
+import { locationRule } from "../standard.js";
+/** Checks a finding's method, environment and locations. */
+export function checkFinding(ctx, e) {
+    const { problem } = ctx;
+    const { buildFiles, codeRanges } = ctx.spec;
+    const { file, meta } = e;
+    if (!["static", "dynamic"].includes(meta.method))
+        problem(file, "method must be static or dynamic");
+    if (meta.method === "static" && meta.environment !== null)
+        problem(file, "a static finding has environment: null");
+    if (meta.method === "dynamic" && (meta.environment === null || meta.environment === ""))
+        problem(file, "a dynamic finding gives its environment");
+    const locations = asList(meta.locations);
+    const builds = asList(meta.builds);
+    if (meta.method === "static")
+        for (const b of builds)
+            if (!locations.some((l) => l && l.build === b))
+                problem(file, `a static finding has at least one location in ${b}`);
+    for (const loc of locations) {
+        if (!loc || typeof loc !== "object") {
+            problem(file, "a location must be a map of build, file and address or offset");
+            continue;
+        }
+        if (!builds.includes(loc.build))
+            problem(file, `location build ${loc.build} is not in builds`);
+        const files = buildFiles.get(loc.build) ?? [];
+        const bf = files.find((f) => f.path === loc.file);
+        if (!bf) {
+            problem(file, `location file ${loc.file} is not in the files of ${loc.build}`);
+            continue;
+        }
+        const format = bf.unpacked?.format ?? bf.format;
+        // kind tells code from data within an executable; a data file holds no code to tell apart.
+        if (loc.kind !== undefined && !locationRule(format)?.address)
+            problem(file, `location kind ${loc.kind} in ${loc.file}: a ${format} file is not an executable, so its locations give no kind`);
+        else if (loc.kind !== undefined && loc.kind !== "code" && loc.kind !== "file-data")
+            problem(file, `location kind ${loc.kind} in ${loc.file}: kind must be code or file-data when given`);
+        const fileData = loc.kind === "file-data";
+        if (fileData && "address" in loc)
+            problem(file, `a file-data location in ${loc.file} gives a file offset, not an address`);
+        // A file-data location in a packed file may name bytes that exist only once it is unpacked,
+        // such as the relocation table an unpacker writes, by an offset into the unpacked form.
+        const intoUnpacked = loc.unpacked === true;
+        if ("unpacked" in loc && !intoUnpacked)
+            problem(file, `a location in ${loc.file} gives unpacked: true or leaves it out`);
+        else if (intoUnpacked && !fileData)
+            problem(file, `a location in ${loc.file} gives unpacked: true only with kind: file-data`);
+        else if (intoUnpacked && !bf.packer)
+            problem(file, `a location in ${loc.file} gives unpacked: true, but ${loc.file} is not packed`);
+        if ("address" in loc && "offset" in loc)
+            problem(file, "a location gives address or offset, not both");
+        if ("address" in loc) {
+            if (!fileData)
+                checkAddress(problem, file, loc.address, format);
+        }
+        else if ("offset" in loc) {
+            // Explicit file-data offsets name shipped container metadata or data, never code.
+            // Other offsets name bytes of the shipped file: data, CD audio, or MZ overlay code
+            // outside the load image. The finding must establish the overlay mapping. Like an
+            // address, an offset is judged by the unpacked format, so a packed MZ stub around LE
+            // or PE code cannot use offsets for code the loader maps.
+            const rule = locationRule(format);
+            if (!fileData && rule && !rule.offset)
+                problem(file, `location in ${loc.file} gives an offset; a ${format} executable is located by address (only MZ overlay code uses offsets)`);
+            const range = intoUnpacked && bf.packer
+                ? checkOffset(problem, file, loc.offset, { path: bf.path, size: Number(bf.unpacked?.size) }, "unpacked form of")
+                : checkOffset(problem, file, loc.offset, bf);
+            // An offset into an executable locates overlay code, so it lies wholly inside one row of
+            // the build's Code ranges. Adjacent rows are not joined: a range that crosses from one
+            // into the next, such as into another bank, fails.
+            if (!fileData && range && rule?.offset && rule.address && codeRanges.has(loc.build)) {
+                const inside = codeRanges
+                    .get(loc.build)
+                    .some((r) => r.file === loc.file && r.start <= range[0] && range[1] <= r.end);
+                if (!inside)
+                    problem(file, `offset ${loc.offset} in ${loc.file} does not lie wholly inside one of the rows the Code ranges section of ${loc.build} gives for that file`);
+            }
+        }
+        else
+            problem(file, "a location gives an address or an offset");
+    }
+}
+// A run's draws from the generator, in order. Each is named by the rule it was made under, which
+// the rebuild cites too, and never by the address of the call in the original's code. A live
+// experiment's draws cite living rules, as its other links do.
+const DRAW_KEYS = ["rule", "bound", "result"];
+function checkDraws(ctx, fixture, draws, live) {
+    const { problem } = ctx;
+    const { entries } = ctx.spec;
+    if (draws === undefined)
+        return;
+    if (!Array.isArray(draws))
+        return problem(fixture, "draws is a list");
+    draws.forEach((draw, i) => {
+        if (draw === null || typeof draw !== "object" || Array.isArray(draw))
+            return problem(fixture, `draw ${i} is an object with rule, bound and result`);
+        const extra = Object.keys(draw).filter((k) => !DRAW_KEYS.includes(k));
+        if (extra.length)
+            problem(fixture, `draw ${i} has ${extra.join(", ")}; a draw gives only rule, bound and result`);
+        if (entries.get(draw.rule)?.kind !== "RULE")
+            problem(fixture, `draw ${i} names ${draw.rule}, which is not a rule entry`);
+        else if (live && isSuperseded(entries, draw.rule))
+            problem(fixture, `draw ${i} names ${draw.rule}, which is superseded`, "STATUS-17");
+        if (!Number.isInteger(draw.bound) || !Number.isInteger(draw.result))
+            problem(fixture, `draw ${i} gives bound and result as integers`);
+    });
+}
+/** Checks an experiment's builds, fixture, starting state and recording. live is false once it is superseded. */
+export function checkExperiment(ctx, id, e, isSup) {
+    const { problem } = ctx;
+    const { buildFiles, glossary } = ctx.spec;
+    const { specDir } = ctx.config;
+    const { file, meta } = e;
+    const builds = asList(meta.builds);
+    if (builds.length !== 1)
+        problem(file, "an experiment lists exactly one build", "ENTRY-TYPES-7");
+    const fixture = meta.fixture && join(specDir, "experiments", meta.fixture);
+    if (!fixture || !existsSync(fixture))
+        problem(file, `fixture ${meta.fixture} does not exist`);
+    else {
+        try {
+            const fx = JSON.parse(readFileSync(fixture, "utf8"));
+            if (fx.experiment !== id)
+                problem(fixture, `experiment must be ${id}`);
+            if (!["new-game", "emulated-call"].includes(meta.starting_state) &&
+                !(fx.starting_state && fx.starting_state.xxh3))
+                problem(fixture, "gives the hash of the save its runs started from");
+            if (typeof meta.starting_state === "string" &&
+                meta.starting_state.endsWith(".patch.json") &&
+                !fx.starting_state?.base_xxh3)
+                problem(fixture, "a patch fixture gives the base save's hash as well");
+            for (const run of asList(fx.runs)) {
+                for (const ev of asList(run?.events))
+                    if (!glossary.has(ev?.event))
+                        problem(fixture, `event ${ev?.event} has no glossary entry`);
+                checkDraws(ctx, fixture, run?.draws, !isSup);
+            }
+            if (typeof meta.recording === "string" && meta.recording !== "" && !fx.recording_xxh3)
+                problem(fixture, "an experiment with a recording gives the recording's hash in recording_xxh3");
+        }
+        catch (err) {
+            problem(fixture, `is not valid JSON: ${err.message}`);
+        }
+    }
+    if (typeof meta.starting_state === "string" &&
+        meta.starting_state.startsWith("saves/") &&
+        !existsSync(join(specDir, "experiments", meta.starting_state)))
+        problem(file, `starting_state ${meta.starting_state} does not exist`);
+    // A recording is committed in recordings/, kept with the captures, or one of the build's files.
+    if (typeof meta.recording === "string" && meta.recording !== "") {
+        const rec = meta.recording;
+        if (rec.startsWith("recordings/")) {
+            if (!existsSync(join(specDir, "experiments", rec)))
+                problem(file, `recording ${rec} does not exist`);
+        }
+        else if (!rec.startsWith("captures/") &&
+            !builds.some((b) => (buildFiles.get(b) ?? []).some((f) => f.path === rec)))
+            problem(file, `recording ${rec} is neither in recordings/ or captures/ nor a file of ${builds.join(", ")}`);
+    }
+}

package/dist/checks/fields.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from "../context.ts";
+import type { FormatNames } from "./formats.ts";
+/** Checks the field names of every live rule's procedure. Runs after checkRules, which sets Entry.code. */
+export declare function checkFieldNames(ctx: Context, { layouts }: FormatNames): void;

package/dist/checks/fields.js

@@ -0,0 +1,314 @@
+// Field names in procedures: every name after a dot, on a structure whose type is known, is a Name in
+// the layout of that structure's format.
+//
+// A type is known only where it is written in the notation's type form: `FMT-DATA-005`, a pointer to
+// one (`PTR32<FMT-DATA-005>`) or a list of either (`FMT-DATA-005[]`). The checker reads it from the
+// places the standard's Notation lists:
+//
+// - a `let` with a type, `let x = new FMT-...`, or a `let` whose value has a known type: another
+//   name or field, `copy` of one, a function whose `define` gives its result type, or a rule's
+//   `call` whose Outputs open with "Returns" and a type;
+// - the rule's Parameters section, as `name: type`, and the parameters of a `define`;
+// - for a name that is not a local, its glossary entry, as `name: type`, or a location in the form
+//   "field `x` of FMT-..." whose layout row has a type;
+// - a `for each` loop variable takes the element type of the list it visits.
+//
+// A field takes the type in its layout row, so a chain such as `world.occupancy.cell_count` is
+// followed row by row. An index into a list gives its element, and an index on a pointer gives the
+// structure it points at; an index on anything else, or a field of a list, ends what is known. A
+// format's mention in prose gives no type, since prose names formats for many reasons. A name whose
+// type is not written in one of these forms, or that two declarations give different types, stays
+// unchecked. A declaration that writes no type, such as a parameter the Parameters section describes
+// in prose or an untyped parameter of a define, gives none and so differs from no other.
+import { asList } from "../ids.js";
+import { parameterNames, withoutCommentsAndStrings } from "./rules.js";
+const sameType = (a, b) => !!a && !!b && a.format.join(" ") === b.format.join(" ") && a.pointer === b.pointer && a.list === b.list;
+const FMT_ID = String.raw `FMT-[A-Z][A-Z0-9]*-\d{3,}`;
+// A type in the notation that holds a structure: a format ID, a pointer to one, or a list of either.
+const STRUCTURE_TYPE = String.raw `(?:[A-Z][A-Z0-9]*<)?${FMT_ID}>?(?:\[[^\]\n]*\])?`;
+const WHOLE_TYPE = new RegExp(String.raw `^([A-Z][A-Z0-9]*<)?(${FMT_ID})(>)?(\[[^\]\n]*\])?$`);
+// `name: type`, with the backticks around the whole or around each part.
+const TYPED_NAME = new RegExp(String.raw `\x60([a-z_][a-z0-9_]*)\x60?\s*:\s*\x60?(${STRUCTURE_TYPE})(?![\w-])`, "g");
+// Where the glossary says the game keeps a value: a field of a structure.
+const LOCATION = new RegExp(String.raw `\bfield\s+\x60([A-Za-z_][A-Za-z0-9_]*)\x60\s+of\s+(${FMT_ID})|\x60([A-Za-z_][A-Za-z0-9_]*)\x60\s+field\s+of\s+(${FMT_ID})`, "g");
+const RETURNS = new RegExp(String.raw `^Returns\s+(?:an?\s+)?\x60?(${STRUCTURE_TYPE})\x60?(?=[\s,.;]|$)`);
+const LOWER = /[a-z_][a-z0-9_]*/y;
+const FIELD = /[A-Za-z_][A-Za-z0-9_]*/y;
+// Whether the bracket that opens at text[open] closes at the end of text.
+function closesAtEnd(text, open) {
+    let depth = 0;
+    for (let k = open; k < text.length; k++) {
+        if (text[k] === "(")
+            depth++;
+        else if (text[k] === ")" && --depth === 0)
+            return k === text.length - 1;
+    }
+    return false;
+}
+// Reads a chain that starts at i, or returns null when text[i] does not start a lower-case name.
+function readChain(text, i) {
+    LOWER.lastIndex = i;
+    const m = LOWER.exec(text);
+    if (!m)
+        return null;
+    const steps = [];
+    const upTo = [];
+    let j = i + m[0].length;
+    for (;;) {
+        let k = j;
+        while (text[k] === " ")
+            k++;
+        if (text[k] === "[") {
+            let depth = 0;
+            for (; k < text.length; k++) {
+                if (text[k] === "[")
+                    depth++;
+                else if (text[k] === "]" && --depth === 0)
+                    break;
+            }
+            if (k >= text.length)
+                break;
+            j = k + 1;
+            steps.push(null);
+            upTo.push(text.slice(i, j));
+            continue;
+        }
+        if (text[j] !== ".")
+            break;
+        FIELD.lastIndex = j + 1;
+        const f = FIELD.exec(text);
+        if (!f)
+            break;
+        j += 1 + f[0].length;
+        steps.push(f[0]);
+        upTo.push(text.slice(i, j));
+    }
+    return { base: m[0], steps, upTo, end: j };
+}
+/** Checks the field names of every live rule's procedure. Runs after checkRules, which sets Entry.code. */
+export function checkFieldNames(ctx, { layouts }) {
+    const { problem } = ctx;
+    const { entries, glossary } = ctx.spec;
+    // A format ID and the entries it is split with, which define the same fields.
+    const formatOf = (id) => {
+        const e = entries.get(id);
+        if (!e || e.kind !== "FMT")
+            return null;
+        return [id, ...asList(e.meta.split_with).filter((x) => entries.get(x)?.kind === "FMT")].sort();
+    };
+    // The type a type written in the notation gives, or null for a type that holds no structure.
+    const typeOf = (text) => {
+        const m = WHOLE_TYPE.exec((text ?? "").replaceAll("`", "").trim());
+        if (!m || !m[1] !== !m[3])
+            return null;
+        const format = formatOf(m[2]);
+        return format ? { format, pointer: !!m[1], list: !!m[4] } : null;
+    };
+    // The types text gives names in the form `name: type`; a name given two types has none.
+    const typedNames = (text) => {
+        const found = new Map();
+        for (const m of text.matchAll(TYPED_NAME)) {
+            const type = typeOf(m[2]);
+            found.set(m[1], found.has(m[1]) && !sameType(found.get(m[1]), type) ? null : type);
+        }
+        return found;
+    };
+    // The layout rows of a format, or null when one of its entries has a malformed layout table. A
+    // field whose entries give it different types has no type.
+    const formatRows = new Map();
+    const plain = (type) => type.replaceAll("`", "").trim();
+    const rowsOf = (format) => {
+        const key = format.join(" ");
+        if (formatRows.has(key))
+            return formatRows.get(key);
+        let rows = new Map();
+        for (const id of format) {
+            const layout = layouts.get(id);
+            if (!layout) {
+                rows = null;
+                break;
+            }
+            for (const [name, type] of layout)
+                rows.set(name, rows.has(name) && plain(rows.get(name)) !== plain(type) ? "" : type);
+        }
+        formatRows.set(key, rows);
+        return rows;
+    };
+    const termTypes = new Map();
+    const termType = (term) => {
+        if (termTypes.has(term))
+            return termTypes.get(term);
+        const text = glossary.get(term) ?? "";
+        const typed = typedNames(text);
+        let type = null;
+        if (typed.has(term))
+            type = typed.get(term);
+        else {
+            const locations = [...text.matchAll(LOCATION)];
+            if (locations.length === 1) {
+                const format = formatOf(locations[0][2] ?? locations[0][4]);
+                type = format ? typeOf(rowsOf(format)?.get(locations[0][1] ?? locations[0][3])) : null;
+            }
+        }
+        termTypes.set(term, type);
+        return type;
+    };
+    // The type of the value a rule returns, from the opening of its Outputs section.
+    const returnType = (id) => {
+        const outputs = entries
+            .get(id)
+            ?.sections.find((s) => s.title === "Outputs")
+            ?.text.trim() ?? "";
+        const m = RETURNS.exec(outputs);
+        return m ? typeOf(m[1]) : null;
+    };
+    const live = [...entries.values()].filter((e) => e.kind === "RULE" && e.meta.status !== "superseded" && e.code);
+    // Functions whose define gives a structure as the result: define name(...) -> FMT-...
+    const functionTypes = new Map();
+    for (const e of live)
+        for (const m of withoutCommentsAndStrings(e.code).matchAll(/\bdefine\s+([a-z_][a-z0-9_]*)\s*\([^)]*\)\s*->\s*([^:\n]+):/g)) {
+            const type = typeOf(m[2]);
+            // The entries of a split rule define the same function; if they disagree, its type is unknown.
+            const disagrees = functionTypes.has(m[1]) && !sameType(functionTypes.get(m[1]), type);
+            functionTypes.set(m[1], disagrees ? null : type);
+        }
+    for (const e of live)
+        checkRule(e);
+    function checkRule(e) {
+        const lines = withoutCommentsAndStrings(e.code).split("\n");
+        const params = e.sections.find((s) => s.title === "Parameters")?.text ?? "";
+        const declarations = [];
+        const declare = (name, type) => declarations.push({ name, type });
+        const fixed = (type, source) => () => type === undefined ? undefined : type ? { ...type, source } : null;
+        const typedParams = typedNames(params);
+        for (const name of parameterNames(params))
+            declare(name, fixed(typedParams.has(name) ? typedParams.get(name) : undefined, "the Parameters section"));
+        for (const line of lines) {
+            const d = /\bdefine\s+[a-z_][a-z0-9_]*\s*\(([^)]*)\)/.exec(line);
+            if (d)
+                for (const p of d[1].split(",")) {
+                    const [name, type] = p.split(":");
+                    if (/^[a-z_][a-z0-9_]*$/.test(name.trim()))
+                        declare(name.trim(), fixed(type === undefined ? undefined : typeOf(type), "its define"));
+                }
+            const l = /^\s*let\s+([a-z_][a-z0-9_]*)\s*(?::\s*([^=]+?))?\s*=\s*(.+?)\s*$/.exec(line);
+            if (l) {
+                const [, name, type, value] = l;
+                if (type)
+                    declare(name, fixed(typeOf(type), "its let"));
+                else
+                    declare(name, (known) => valueType(value, known, "its let"));
+            }
+            const f = /^\s*for\s+(?:each\s+)?([a-z_][a-z0-9_]*)\s+in\s+(.+?)\s*:\s*$/.exec(line);
+            if (f)
+                declare(f[1], (known) => {
+                    const list = f[2].includes("..") ? null : valueType(f[2], known, "the list its loop visits");
+                    return list?.list ? { ...list, list: false } : null;
+                });
+        }
+        const locals = new Set(declarations.map((d) => d.name));
+        // A let can take its type from another local, so the types are worked out again until they
+        // stop changing.
+        let types = new Map();
+        const known = (name) => {
+            if (locals.has(name))
+                return types.get(name) ?? null;
+            const type = termType(name);
+            return type ? { ...type, source: `the glossary entry for ${name}` } : null;
+        };
+        const settledAs = (a, b) => a.size === b.size && [...a].every(([name, t]) => sameType(t, b.get(name) ?? null));
+        for (let pass = 0; pass <= declarations.length; pass++) {
+            const found = new Map();
+            for (const d of declarations) {
+                const t = d.type(known);
+                if (t === undefined)
+                    continue;
+                found.set(d.name, found.has(d.name) && !sameType(found.get(d.name), t) ? null : t);
+            }
+            const next = new Map();
+            for (const [name, t] of found)
+                if (t)
+                    next.set(name, t);
+            const settled = settledAs(next, types);
+            types = next;
+            if (settled)
+                break;
+        }
+        for (const line of lines)
+            for (let i = 0; i < line.length; i++) {
+                if (/[\w.]/.test(line[i - 1] ?? ""))
+                    continue;
+                const chain = readChain(line, i);
+                if (!chain)
+                    continue;
+                // Names inside the chain's indexes start chains of their own.
+                i += chain.base.length - 1;
+                if (chain.steps.some((s) => s !== null))
+                    follow(chain, known, (message) => problem(e.file, message));
+            }
+    }
+    // The type of the value of a let, or of the list a for each loop visits, or null when it has none.
+    function valueType(value, known, source) {
+        const v = value.trim();
+        const made = new RegExp(String.raw `^new\s+(${FMT_ID})$`).exec(v);
+        if (made) {
+            const format = formatOf(made[1]);
+            return format ? { format, pointer: false, list: false, source } : null;
+        }
+        // A call is the whole value only when the bracket after its name closes at the end, so
+        // make(a) + other(b) is not a call of make.
+        const called = /^call\s+(RULE-[A-Z][A-Z0-9]*-\d{3,})\s*\(/.exec(v);
+        if (called && closesAtEnd(v, called[0].length - 1)) {
+            const type = returnType(called[1]);
+            return type ? { ...type, source: `the Outputs of ${called[1]}` } : null;
+        }
+        const copied = /^copy\s*\(/.exec(v);
+        if (copied && closesAtEnd(v, copied[0].length - 1))
+            return valueType(v.slice(copied[0].length, -1), known, source);
+        const fn = /^([a-z_][a-z0-9_]*)\s*\(/.exec(v);
+        if (fn && closesAtEnd(v, fn[0].length - 1)) {
+            const type = functionTypes.get(fn[1]);
+            return type ? { ...type, source: `the define of ${fn[1]}` } : null;
+        }
+        const chain = readChain(v, 0);
+        if (!chain || chain.end !== v.length)
+            return null;
+        const t = follow(chain, known);
+        return t ? { ...t, source } : null;
+    }
+    // Follows a chain access by access and returns the type it ends with. With report, a field missing
+    // from its structure's layout is reported.
+    function follow(chain, known, report) {
+        const base = known(chain.base);
+        if (!base)
+            return null;
+        let type = base;
+        for (const [n, field] of chain.steps.entries()) {
+            if (field === null) {
+                // list[i] is an element, and p[i] is the structure p + i points at.
+                if (type.list)
+                    type = { ...type, list: false };
+                else if (type.pointer)
+                    type = { ...type, pointer: false };
+                else
+                    return null;
+                continue;
+            }
+            if (type.list)
+                return null;
+            const rows = rowsOf(type.format);
+            if (!rows)
+                return null;
+            const cell = rows.get(field);
+            if (cell === undefined) {
+                report?.(`${chain.upTo[n]} names ${field}, which is not in the layout of ${type.format.join(" or ")} (${chain.base} has its type from ${base.source})`);
+                return null;
+            }
+            const next = typeOf(cell);
+            if (!next)
+                return null;
+            type = next;
+        }
+        return { ...type, source: base.source };
+    }
+}

package/dist/checks/formats.d.ts

@@ -0,0 +1,19 @@
+import type { Context } from "../context.ts";
+import type { Entry } from "../types.ts";
+/** The names the formats' tables define. */
+export interface FormatNames {
+    /** Enumeration name -> the formats that define it, once per row. */
+    enumNames: Map<string, string[]>;
+    /** Format ID -> the names of its layout and enumeration rows. */
+    fieldNames: Map<string, Set<string>>;
+    /**
+     * Format ID -> the Name of each layout row -> its Type cell, for a format whose layout tables all
+     * have the right columns and whose rows all have one cell per column. A format without a Layout
+     * table has an empty map.
+     */
+    layouts: Map<string, Map<string, string>>;
+}
+/** The IDs cited in the last column of the tables of an entry's sections (of every section when sectionTitles is left out). */
+export declare function tableIds(e: Entry, sectionTitles?: string[]): Set<string>;
+/** Checks a format entry, adding the names its tables define to formatNames. */
+export declare function checkFormat(ctx: Context, e: Entry, formatNames: FormatNames): void;