@fieldia/core 0.10.0 → 0.12.0

package/src/lib/format/references.mjs

@@ -1,6 +1,9 @@
+import { BUILT_IN_NAMES, USER_PARTS } from '../expression/built-ins.mjs';
 import { compileModifier } from '../expression/modifier.mjs';
 import { compileExpression } from '../expression/expression.mjs';
 import { dependencyOrder } from '../expression/order.mjs';
+import { valuesIn } from './words.mjs';
+import { BROWSER_HOTKEYS, hotkeyWords } from './hotkeys.mjs';
 const has = (record, key) => Object.prototype.hasOwnProperty.call(record, key);
 /** The kinds of field an expression can give a value to: the rest hold records, lines or files. */
 const EXPRESSIBLE = new Set(['char', 'text', 'html', 'integer', 'float', 'monetary', 'boolean', 'date', 'datetime', 'selection', 'json']);
@@ -13,16 +16,151 @@ const listed = (names) => {
 /** The second pass of every check: ids unique, every name defined, every condition readable. */
 export class ReferenceCheck {
     page;
+    line;
     issues = [];
     ids = new Map();
-    constructor(page) {
+    /** Where the answers of each saved form placed here go, by name: the path of the part that took it first. */
+    formNames = new Map();
+    /** The ids of the tabs and wizard steps a step can go to, and where each goTo and show names one. */
+    places = new Set();
+    goingTo = [];
+    constructor(page, line) {
         this.page = page;
+        this.line = line;
     }
     run() {
-        this.checkFields(this.page.fields, 'fields');
+        this.checkFields(this.page.fields, 'fields', this.line?.name, this.line?.parent);
         this.walkRoot(this.page.layout, 'layout');
+        if (this.page.on)
+            this.checkEvents(this.page.on, 'on');
+        this.checkGoingTo();
         return this.issues;
     }
+    /** Each step's goTo and show names a tab or a wizard step of this page. */
+    checkGoingTo() {
+        for (const { target, path } of this.goingTo) {
+            if (!this.places.has(target))
+                this.report(path, `no tab or wizard step "${target}" on this page`);
+        }
+    }
+    /** Where the page's own expressions read: its fields — on a line's form, the line's, with its record as parent. */
+    here() {
+        return this.line ? { fields: this.page.fields, lines: this.line.name, parent: this.line.parent } : { fields: this.page.fields };
+    }
+    /** A line's own form (`lineForm`), its parts checked against the line's fields, its record as parent. */
+    checkLineForm(node, def, path) {
+        const children = node.lineForm?.children;
+        if (!Array.isArray(children))
+            return this.report(`${path}.lineForm`, 'a line’s form holds its parts: { "children": [...] }');
+        const page = { ...this.page, fields: def.fields, layout: { type: 'sections', id: `${node.id}#line`, children }, on: undefined };
+        const inside = new ReferenceCheck(page, { name: node.field, parent: this.page.fields });
+        inside.walkChildren(children, `${path}.lineForm`);
+        inside.checkGoingTo();
+        this.issues.push(...inside.issues);
+    }
+    /** The form's moments: their steps checked, a change named by a field (or a saved form placed here, by its answers' name), a step or tab shown by its id. */
+    checkEvents(on, path) {
+        for (const moment of ['open', 'beforeSave', 'afterSave']) {
+            const steps = on[moment];
+            if (steps)
+                this.checkSteps(steps, `${path}.${moment}`);
+        }
+        for (const [field, steps] of Object.entries(on.change ?? {})) {
+            if (!this.formNames.has(field))
+                this.need(field, `${path}.change.${field}`);
+            this.checkSteps(steps, `${path}.change.${field}`);
+        }
+        for (const [target, steps] of Object.entries(on.show ?? {})) {
+            this.goingTo.push({ target, path: `${path}.show.${target}` });
+            this.checkSteps(steps, `${path}.show.${target}`);
+        }
+    }
+    /** A press: steps, an app action, or both — and its steps checked. */
+    checkPress(button, path) {
+        if (!button.steps && button.action === undefined)
+            this.report(path, 'a button needs steps, an action, or both');
+        const key = 'hotkey' in button ? button.hotkey : undefined;
+        if (typeof key === 'string' && BROWSER_HOTKEYS.includes(key.replace('shift+', '')))
+            this.report(`${path}.hotkey`, `${hotkeyWords(key)} is the browser’s own: pick another key`);
+        if (button.steps)
+            this.checkSteps(button.steps, `${path}.steps`);
+    }
+    /**
+     * Steps, each against this page: the fields it sets, empties, checks or adds
+     * a line to are this page's; its expressions read; a step it goes to is a
+     * tab or a wizard step here. The opened page's own fields are not known
+     * here: what it starts with is named freely, and what comes back is read
+     * as an expression.
+     */
+    checkSteps(steps, path) {
+        const scope = this.here();
+        steps.forEach((step, i) => {
+            const at = `${path}[${i}]`;
+            this.checkModifiers(step, at, ['when']);
+            switch (step.do) {
+                case 'set': {
+                    const def = this.need(step.field, `${at}.field`);
+                    if (def && !EXPRESSIBLE.has(def.type))
+                        this.report(`${at}.field`, `a ${def.type} cannot be set from an expression; ${EXPRESSIBLE_WORDS}`);
+                    this.checkExpression(step.value, `${at}.value`, scope);
+                    return;
+                }
+                case 'clear':
+                    this.need(step.field, `${at}.field`);
+                    return;
+                case 'addLine': {
+                    const def = this.need(step.field, `${at}.field`);
+                    if (def && def.type !== 'one2many')
+                        return this.report(`${at}.field`, `"${step.field}" is a ${def.type}; a line is added to a one2many`);
+                    for (const [name, value] of Object.entries(step.values ?? {})) {
+                        if (def?.type === 'one2many' && !has(def.fields, name))
+                            this.report(`${at}.values.${name}`, `"${name}" is not a field of the lines of "${step.field}"`);
+                        this.checkExpression(value, `${at}.values.${name}`, scope);
+                    }
+                    return;
+                }
+                case 'check':
+                    step.fields?.forEach((field, j) => this.need(field, `${at}.fields[${j}]`));
+                    return;
+                case 'goTo':
+                    this.goingTo.push({ target: step.target, path: `${at}.target` });
+                    return;
+                case 'open':
+                    if (step.page === this.page.id && step.as === 'page')
+                        this.report(`${at}.page`, 'a page cannot open itself in its own place');
+                    if (step.side !== undefined && step.as !== 'panel')
+                        this.report(`${at}.side`, `a side is where a panel comes from; this opens ${step.as === 'page' ? 'in its place' : 'in a dialog'}`);
+                    if (step.record !== undefined)
+                        this.checkExpression(step.record, `${at}.record`, scope);
+                    for (const [name, value] of Object.entries(step.values ?? {}))
+                        this.checkExpression(value, `${at}.values.${name}`, scope);
+                    // A list's records by this form's values: each valueFrom names one of its fields.
+                    step.filter?.forEach((item, j) => this.checkFilterItem(item, `${at}.filter[${j}]`, scope));
+                    for (const [name, value] of Object.entries(step.into ?? {})) {
+                        this.need(name, `${at}.into.${name}`);
+                        try {
+                            compileExpression(value);
+                        }
+                        catch (error) {
+                            this.report(`${at}.into.${name}`, `cannot read "${value}": ${error.message}`);
+                        }
+                    }
+                    if (step.then)
+                        this.checkSteps(step.then, `${at}.then`);
+                    return;
+                case 'openUrl':
+                    this.checkExpression(step.url, `${at}.url`, scope);
+                    return;
+                default:
+                    return;
+            }
+        });
+    }
+    /** Words that show fields' values: each `{name}` a field of this page. */
+    checkValuesIn(words, path) {
+        for (const name of valuesIn(words))
+            this.need(name, path);
+    }
     report(path, message) {
         this.issues.push({ path, message });
     }
@@ -40,28 +178,94 @@ export class ReferenceCheck {
         this.report(path, `no field "${name}"`);
         return undefined;
     }
+    /** A filter's conditions: groups nest, and each valueFrom inside them must name a field too. */
+    checkFilterItem(item, at, scope) {
+        if ('any' in item)
+            return item.any.forEach((inner, i) => this.checkFilterItem(inner, `${at}.any[${i}]`, scope));
+        if ('all' in item)
+            return item.all.forEach((inner, i) => this.checkFilterItem(inner, `${at}.all[${i}]`, scope));
+        if (item.valueFrom !== undefined)
+            this.checkValueFrom(item.valueFrom, `${at}.valueFrom`, scope);
+    }
+    /** A filter's `valueFrom`: a field where it is used, the record's `id`, a part of `user`, or on a line a field of its record. */
+    checkValueFrom(name, path, scope) {
+        const [root, part] = name.split('.');
+        if (part === undefined) {
+            if (has(scope.fields, name) || (name === 'id' && scope.lines === undefined))
+                return;
+            this.need(name, path, scope.fields);
+        }
+        else if (root === 'user') {
+            if (!USER_PARTS.includes(part))
+                this.report(path, `"${name}": the person has an id, name or roles`);
+        }
+        else if (root === 'context') {
+            // The app's values: any name it passes in.
+        }
+        else if (scope.lines === undefined) {
+            this.report(path, `"${name}": only a line's filter reads parent, the record it is on`);
+        }
+        else if (!has(scope.parent ?? this.page.fields, part) && part !== 'id') {
+            this.report(path, `"${name}": "${part}" is not a field of this page`);
+        }
+    }
     /** Every modifier on `owner` must read, and read only fields of this page (or of its line). */
-    checkModifiers(owner, path, keys = ['invisible'], scope = { fields: this.page.fields }) {
+    checkModifiers(owner, path, keys = ['invisible'], scope = this.here()) {
         for (const key of keys) {
             const value = owner[key];
             if (typeof value !== 'string')
                 continue;
-            let fields;
+            let compiled;
             try {
-                fields = compileModifier(value).fields;
+                compiled = compileModifier(value);
             }
             catch (error) {
                 this.report(`${path}.${key}`, `cannot read "${value}": ${error.message}`);
                 continue;
             }
-            this.checkReads(value, fields, `${path}.${key}`, scope);
+            this.checkReads(value, compiled, `${path}.${key}`, scope);
         }
     }
-    /** Each name an expression reads must be a field where it is worked out. */
-    checkReads(source, fields, path, scope) {
-        for (const name of fields) {
+    /**
+     * Each name an expression reads must be a field where it is worked out, or
+     * on a record what every expression there reads: its `id`, and `user` with
+     * the person's `id`, `name` or `roles`.
+     */
+    checkReads(source, reads, path, scope) {
+        // A count's or a sum's condition reads the fields of the lines it is on.
+        for (const where of reads.wheres) {
+            const lines = scope.fields[where.lines];
+            if (lines?.type !== 'one2many')
+                continue;
+            let fields;
+            try {
+                fields = compileModifier(where.condition).fields;
+            }
+            catch (error) {
+                this.report(path, `cannot read the condition "${where.condition}": ${error.message}`);
+                continue;
+            }
+            for (const name of fields)
+                if (!has(lines.fields, name))
+                    this.report(path, `"${where.condition}" reads "${name}", which is not a field of the lines of "${where.lines}"`);
+        }
+        for (const name of reads.fields) {
             if (has(scope.fields, name))
                 continue;
+            // A record's expressions read its id and the person; a line's, its own id, the person and the record it is on.
+            const builtIn = scope.lines === undefined ? BUILT_IN_NAMES.includes(name) : name === 'user' || name === 'parent' || name === 'id' || name === 'context';
+            if (builtIn) {
+                for (const read of reads.paths) {
+                    const [root, part] = read.split('.');
+                    if (root !== name || part === undefined)
+                        continue;
+                    if (name === 'user' && !USER_PARTS.includes(part))
+                        this.report(path, `"${source}" reads "${read}": the person has an id, name or roles`);
+                    if (name === 'parent' && !has(scope.parent ?? this.page.fields, part) && !BUILT_IN_NAMES.includes(part))
+                        this.report(path, `"${source}" reads "${read}": "${part}" is not a field of this page`);
+                }
+                continue;
+            }
             const where = scope.lines === undefined ? 'of this page' : `of the lines of "${scope.lines}"`;
             this.report(path, `"${source}" reads "${name}", which is not a field ${where}`);
         }
@@ -80,7 +284,7 @@ export class ReferenceCheck {
             this.report(path, `cannot read "${source}": ${error.message}`);
             return null;
         }
-        this.checkReads(source, compiled.fields, path, scope);
+        this.checkReads(source, compiled, path, scope);
         for (const sum of compiled.sums) {
             if (!has(scope.fields, sum.lines))
                 continue;
@@ -114,6 +318,7 @@ export class ReferenceCheck {
             }
             def.setWhen?.forEach((item, i) => {
                 this.checkModifiers(item, `${path}.setWhen[${i}]`, ['when'], scope);
+                item.on?.forEach((other, j) => this.need(other, `${path}.setWhen[${i}].on[${j}]`, fields));
                 this.checkExpression(item.value, `${path}.setWhen[${i}].value`, scope);
             });
         }
@@ -123,32 +328,36 @@ export class ReferenceCheck {
             this.report(`${base}.${cycle[0]}.compute`, message);
         }
     }
-    checkFields(fields, base, lines) {
-        this.checkWorkedOut(fields, base, { fields, lines });
+    checkFields(fields, base, lines, parent) {
+        const scope = { fields, lines, ...(parent ? { parent } : {}) };
+        this.checkWorkedOut(fields, base, scope);
         for (const [name, def] of Object.entries(fields)) {
             const path = `${base}.${name}`;
-            if (def.type === 'monetary' && def.currencyField !== undefined) {
-                const currency = this.need(def.currencyField, `${path}.currencyField`, fields);
-                if (currency && !['many2one', 'selection', 'char'].includes(currency.type)) {
-                    this.report(`${path}.currencyField`, `"${def.currencyField}" is a ${currency.type}; a currency field must be a many2one, selection or char`);
+            if (def.type === 'monetary' && def.currencyField !== undefined)
+                this.checkCurrency(def.currencyField, `${path}.currencyField`, fields, lines, parent);
+            // A first value worked out, and what a record made from a link starts with: read where this field is.
+            if (def.defaultFrom !== undefined)
+                this.checkExpression(def.defaultFrom, `${path}.defaultFrom`, scope);
+            if ((def.type === 'many2one' || def.type === 'many2many') && def.createValues) {
+                for (const [key, source] of Object.entries(def.createValues))
+                    this.checkExpression(source, `${path}.createValues.${key}`, scope);
+            }
+            // A new line's values: fields of its lines, read from the record.
+            if (def.type === 'one2many' && def.lineDefaults) {
+                for (const [key, source] of Object.entries(def.lineDefaults)) {
+                    if (!has(def.fields, key))
+                        this.report(`${path}.lineDefaults.${key}`, `"${key}" is not a field of the lines of "${name}"`);
+                    else
+                        this.checkExpression(source, `${path}.lineDefaults.${key}`, scope);
                 }
             }
             if ((def.type === 'many2one' || def.type === 'many2many') && def.filter) {
-                // Groups nest: each valueFrom inside them must name a field too.
-                const walk = (item, at) => {
-                    if ('any' in item)
-                        return item.any.forEach((inner, i) => walk(inner, `${at}.any[${i}]`));
-                    if ('all' in item)
-                        return item.all.forEach((inner, i) => walk(inner, `${at}.all[${i}]`));
-                    if (item.valueFrom !== undefined)
-                        this.need(item.valueFrom, `${at}.valueFrom`, fields);
-                };
-                def.filter.forEach((item, i) => {
-                    walk(item, `${path}.filter[${i}]`);
-                });
+                def.filter.forEach((item, i) => this.checkFilterItem(item, `${path}.filter[${i}]`, scope));
             }
             if (def.type === 'selection')
                 def.optionsFrom?.dependsOn?.forEach((other, i) => this.need(other, `${path}.optionsFrom.dependsOn[${i}]`, fields));
+            if (def.type === 'properties')
+                def.definitionsFrom?.dependsOn?.forEach((other, i) => this.need(other, `${path}.definitionsFrom.dependsOn[${i}]`, fields));
             if (def.type === 'properties' && def.definitions) {
                 const seen = new Set();
                 def.definitions.forEach((property, i) => {
@@ -161,8 +370,9 @@ export class ReferenceCheck {
                 });
             }
             if (def.type === 'one2many') {
-                this.checkFields(def.fields, `${path}.fields`, name);
-                if (def.lineKinds)
+                // Its lines read the record they are on — on a line, that line — as parent.
+                this.checkFields(def.fields, `${path}.fields`, name, fields);
+                if ('lineKinds' in def && def.lineKinds)
                     this.checkLineKinds(name, def.lineKinds, def.fields, `${path}.lineKinds`);
                 if (def.sequenceField !== undefined) {
                     const sequence = def.fields[def.sequenceField];
@@ -175,6 +385,21 @@ export class ReferenceCheck {
             }
         }
     }
+    /** A money field's currency: a field beside it, or on a line `parent.` and a field of the record — one that holds a currency. */
+    checkCurrency(name, path, fields, lines, parent = this.page.fields) {
+        let currency;
+        if (!name.startsWith('parent.'))
+            currency = this.need(name, path, fields);
+        else if (lines === undefined)
+            return this.report(path, `"${name}": only a line’s money reads parent, the record it is on`);
+        else if (!has(parent, name.slice('parent.'.length)))
+            return this.report(path, `"${name}": "${name.slice('parent.'.length)}" is not a field of this page`);
+        else
+            currency = parent[name.slice('parent.'.length)];
+        if (currency && !['many2one', 'selection', 'char'].includes(currency.type)) {
+            this.report(path, `"${name}" is a ${currency.type}; a currency field must be a many2one, selection or char`);
+        }
+    }
     checkLineKinds(field, kinds, lineFields, path) {
         const kindField = lineFields[kinds.field];
         if (!kindField)
@@ -196,10 +421,20 @@ export class ReferenceCheck {
             this.report(`${path}.text`, `"${kinds.text}" is a ${text.type}; a section's or note's text must be a char or text field`);
         }
     }
+    /** A page's own buttons at its foot: buttons as any. */
+    walkFooter(footer, path) {
+        footer?.forEach((button, i) => {
+            this.claim(button.id, `${path}.footer[${i}]`);
+            this.checkModifiers(button, `${path}.footer[${i}]`);
+            this.checkPress(button, `${path}.footer[${i}]`);
+        });
+    }
     walkRoot(root, path) {
         if (root.type === 'tabs')
             return this.walkNode(root, path);
         this.claim(root.id, path);
+        if (root.type === 'sheet' || root.type === 'sections')
+            this.walkFooter(root.footer, path);
         if (root.type === 'sheet')
             return this.walkSheet(root, path);
         if (root.type === 'sections')
@@ -208,6 +443,7 @@ export class ReferenceCheck {
             return this.walkList(root, path);
         root.children.forEach((step, i) => {
             const stepPath = `${path}.children[${i}]`;
+            this.places.add(step.id);
             this.claim(step.id, stepPath);
             this.checkModifiers(step, stepPath);
             this.walkChildren(step.children, stepPath);
@@ -240,14 +476,17 @@ export class ReferenceCheck {
             if (!named.has(id))
                 this.report(`${path}.defaultFilters[${i}]`, `no filter "${id}" in this list`);
         });
-        list.actions?.forEach((button, i) => this.claim(button.id, `${path}.actions[${i}]`));
+        list.actions?.forEach((button, i) => {
+            this.claim(button.id, `${path}.actions[${i}]`);
+            this.checkPress(button, `${path}.actions[${i}]`);
+        });
     }
     walkChildren(children, path) {
         children.forEach((child, i) => this.walkNode(child, `${path}.children[${i}]`));
     }
     walkNode(node, path) {
         this.claim(node.id, path);
-        this.checkModifiers(node, path, node.type === 'field' ? ['invisible', 'readonly', 'required'] : node.type === 'section' ? ['invisible', 'readonly'] : ['invisible']);
+        this.checkModifiers(node, path, node.type === 'field' ? ['invisible', 'readonly', 'required'] : node.type === 'section' || node.type === 'form' ? ['invisible', 'readonly'] : ['invisible']);
         switch (node.type) {
             case 'field':
                 return this.checkFieldNode(node, path);
@@ -256,16 +495,50 @@ export class ReferenceCheck {
                     this.report(path, 'a collapsible section needs a title to fold it by');
                 if (node.collapsed && !node.collapsible)
                     this.report(path, 'collapsed needs collapsible: true');
+                if (node.style === 'inline' && node.columns !== undefined)
+                    this.report(`${path}.columns`, 'parts on one line take no columns: each is as wide as it needs');
+                if (node.style === 'inline' && node.collapsible)
+                    this.report(`${path}.collapsible`, 'a line of parts does not fold: its title is its label');
+                if (node.style === 'inline') {
+                    node.children.forEach((child, i) => {
+                        if (!['field', 'text', 'button', 'spacer'].includes(child.type))
+                            this.report(`${path}.children[${i}]`, `a line of parts holds fields, words and buttons; a ${child.type} needs a row of its own`);
+                    });
+                }
                 return this.walkChildren(node.children, path);
             case 'tabs':
                 return this.walkTabs(node, path);
+            case 'form':
+                return this.checkFormNode(node, path);
+            case 'button':
+                return this.checkPress(node, path);
+            case 'text':
+                return this.checkValuesIn(node.text, `${path}.text`);
             default:
                 return;
         }
     }
+    /** A saved form placed here: never this page itself, and its answers under a name no field and no other copy has. */
+    checkFormNode(node, path) {
+        // The quick check reads no shapes: a part with no page or name to go by is said here.
+        if (typeof node.page !== 'string' || typeof node.name !== 'string')
+            return this.report(path, 'a saved form placed here needs the page’s id and a name for its answers');
+        if (node.page === this.page.id)
+            this.report(`${path}.page`, 'a page cannot be placed inside itself');
+        const first = this.formNames.get(node.name);
+        if (has(this.page.fields, node.name)) {
+            this.report(`${path}.name`, `"${node.name}" is a field of this page: the saved form’s answers need a name of their own`);
+        }
+        else if (first !== undefined) {
+            this.report(`${path}.name`, `the answers of the saved form at ${first} go under "${node.name}" already: give each copy a name of its own`);
+        }
+        else
+            this.formNames.set(node.name, path);
+    }
     walkTabs(node, path) {
         node.children.forEach((tab, i) => {
             const tabPath = `${path}.children[${i}]`;
+            this.places.add(tab.id);
             this.claim(tab.id, tabPath);
             this.checkModifiers(tab, tabPath);
             this.walkChildren(tab.children, tabPath);
@@ -278,10 +551,22 @@ export class ReferenceCheck {
                 this.need(sheet.title.subtitleField, `${path}.title.subtitleField`);
             if (sheet.title.avatarField !== undefined)
                 this.need(sheet.title.avatarField, `${path}.title.avatarField`);
+            sheet.title.placeholderWhen?.forEach((item, i) => this.checkModifiers(item, `${path}.title.placeholderWhen[${i}]`, ['when']));
         }
         if (sheet.statusbar) {
-            const { field, visibleStates } = sheet.statusbar;
+            const { field, visibleStates, durationsField, fold, saves, clickable } = sheet.statusbar;
+            const at = `${path}.statusbar`;
+            this.checkModifiers(sheet.statusbar, at);
+            if (durationsField !== undefined) {
+                const times = this.need(durationsField, `${at}.durationsField`);
+                if (times && times.type !== 'json')
+                    this.report(`${at}.durationsField`, `"${durationsField}" is a ${times.type}; time per step comes from a json field`);
+            }
+            if (saves && !clickable)
+                this.report(`${at}.saves`, 'a click saves only where a step can be clicked (clickable)');
             const def = this.need(field, `${path}.statusbar.field`);
+            if (fold && def && def.type !== 'many2one')
+                this.report(`${at}.fold`, 'steps fold by their record (a stage), so only a link’s steps fold; a choice keeps the steps it shows with visibleStates');
             if (def && def.type !== 'selection' && def.type !== 'many2one') {
                 this.report(`${path}.statusbar.field`, `"${field}" is a ${def.type}; a statusbar needs a selection or many2one`);
             }
@@ -297,28 +582,66 @@ export class ReferenceCheck {
         sheet.buttons?.forEach((button, i) => {
             this.claim(button.id, `${path}.buttons[${i}]`);
             this.checkModifiers(button, `${path}.buttons[${i}]`);
+            this.checkPress(button, `${path}.buttons[${i}]`);
         });
         sheet.statButtons?.forEach((stat, i) => {
             this.claim(stat.id, `${path}.statButtons[${i}]`);
             this.checkModifiers(stat, `${path}.statButtons[${i}]`);
-            if (stat.field !== undefined)
-                this.need(stat.field, `${path}.statButtons[${i}].field`);
+            this.checkPress(stat, `${path}.statButtons[${i}]`);
+            for (const key of ['field', 'unitField', 'labelField', 'secondField']) {
+                const name = stat[key];
+                if (name !== undefined)
+                    this.need(name, `${path}.statButtons[${i}].${key}`);
+            }
+            if (stat.secondLabel !== undefined && stat.secondField === undefined)
+                this.report(`${path}.statButtons[${i}].secondLabel`, 'words for a second value need its field (secondField)');
         });
-        if (sheet.ribbon) {
-            this.claim(sheet.ribbon.id, `${path}.ribbon`);
-            this.checkModifiers(sheet.ribbon, `${path}.ribbon`);
+        const ribbons = [...(sheet.ribbon ? [[sheet.ribbon, `${path}.ribbon`]] : []), ...(sheet.ribbons ?? []).map((ribbon, i) => [ribbon, `${path}.ribbons[${i}]`])];
+        for (const [ribbon, at] of ribbons) {
+            this.claim(ribbon.id, at);
+            this.checkModifiers(ribbon, at);
+            if (ribbon.labelField !== undefined)
+                this.need(ribbon.labelField, `${at}.labelField`);
         }
         sheet.badges?.forEach((badge, i) => {
             this.claim(badge.id, `${path}.badges[${i}]`);
             this.checkModifiers(badge, `${path}.badges[${i}]`);
         });
-        for (const place of ['above', 'below']) {
+        for (const place of ['above', 'before', 'after', 'below']) {
             sheet.title?.[place]?.forEach((node, i) => this.walkNode(node, `${path}.title.${place}[${i}]`));
         }
         sheet.alerts?.forEach((alert, i) => {
-            this.claim(alert.id, `${path}.alerts[${i}]`);
-            this.checkModifiers(alert, `${path}.alerts[${i}]`);
+            const at = `${path}.alerts[${i}]`;
+            this.claim(alert.id, at);
+            this.checkModifiers(alert, at);
+            this.checkValuesIn(alert.message, `${at}.message`);
+            if (alert.messageField !== undefined)
+                this.need(alert.messageField, `${at}.messageField`);
+            alert.buttons?.forEach((button, j) => {
+                this.claim(button.id, `${at}.buttons[${j}]`);
+                this.checkModifiers(button, `${at}.buttons[${j}]`);
+                this.checkPress(button, `${at}.buttons[${j}]`);
+            });
+        });
+        // The gear menu: buttons of the record, each doing something — its steps, an action, or a built-in — and named.
+        sheet.toolbar?.menu?.forEach((item, i) => {
+            const at = `${path}.toolbar.menu[${i}]`;
+            this.claim(item.id, at);
+            this.checkModifiers(item, at);
+            if (!item.steps && item.action === undefined && !item.builtin)
+                this.report(at, 'a menu item needs steps, an action, or a built-in');
+            if (item.label === undefined && !item.builtin)
+                this.report(`${at}.label`, 'a menu item needs words, unless it is a built-in');
+            if (item.steps)
+                this.checkSteps(item.steps, `${at}.steps`);
         });
+        const preview = sheet.attachmentPreview;
+        if (preview) {
+            this.checkModifiers(preview, `${path}.attachmentPreview`);
+            const def = preview.field !== undefined ? this.need(preview.field, `${path}.attachmentPreview.field`) : undefined;
+            if (def && def.type !== 'binary' && def.type !== 'image')
+                this.report(`${path}.attachmentPreview.field`, `"${preview.field}" is a ${def.type}; the preview shows a file (binary or image)`);
+        }
         this.walkChildren(sheet.children, path);
         if (sheet.sidePanel) {
             this.claim(sheet.sidePanel.id, `${path}.sidePanel`);
@@ -331,6 +654,13 @@ export class ReferenceCheck {
         node.validate?.forEach((rule, i) => {
             const at = `${path}.validate[${i}]`;
             this.checkModifiers(rule, at, ['when', 'holds']);
+            // No value twice in a column: a column of this table's lines.
+            if (rule.distinct !== undefined && def) {
+                if (def.type !== 'one2many')
+                    this.report(`${at}.distinct`, `distinct is for a table of lines; "${node.field}" is a ${def.type}`);
+                else if (!has(def.fields, rule.distinct))
+                    this.report(`${at}.distinct`, `"${rule.distinct}" is not a field of the lines of "${node.field}"`);
+            }
             if (rule.pattern === undefined)
                 return;
             try {
@@ -340,6 +670,10 @@ export class ReferenceCheck {
                 this.report(`${at}.pattern`, `"${rule.pattern}" is not a regular expression`);
             }
         });
+        // Its value's tones and bold, and the words its empty box shows: read on the record, as its other conditions are.
+        node.tones?.forEach((tone, i) => this.checkModifiers(tone, `${path}.tones[${i}]`, ['when']));
+        node.placeholderWhen?.forEach((item, i) => this.checkModifiers(item, `${path}.placeholderWhen[${i}]`, ['when']));
+        this.checkModifiers(node, path, ['bold']);
         if (def && node.totals) {
             if (def.type !== 'one2many') {
                 this.report(`${path}.totals`, `totals only apply to one2many fields; "${node.field}" is a ${def.type}`);
@@ -360,16 +694,79 @@ export class ReferenceCheck {
             if (key.endsWith('Field') && typeof value === 'string')
                 this.need(value, `${path}.options.${key}`);
         }
+        // The order lines load in: fields of its lines.
+        if (def && node.order) {
+            if (def.type !== 'one2many')
+                this.report(`${path}.order`, `order only applies to one2many fields; "${node.field}" is a ${def.type}`);
+            else
+                node.order.forEach((item, i) => !has(def.fields, item.field) && this.report(`${path}.order[${i}].field`, `"${item.field}" is not a field of the lines of "${node.field}"`));
+        }
+        // A line's own form: its parts read the line's fields, the record as parent.
+        if (def && node.lineForm) {
+            if (def.type !== 'one2many')
+                this.report(`${path}.lineForm`, `lineForm only applies to one2many fields; "${node.field}" is a ${def.type}`);
+            else
+                this.checkLineForm(node, def, path);
+        }
+        for (const key of ['lineOpens', 'cards', 'fit']) {
+            if (def && node[key] && def.type !== 'one2many')
+                this.report(`${path}.${key}`, `${key} only applies to one2many fields; "${node.field}" is a ${def.type}`);
+        }
         if (def && node.editMode && def.type !== 'one2many') {
             this.report(`${path}.editMode`, `editMode only applies to one2many fields; "${node.field}" is a ${def.type}`);
         }
+        // A table's own rules: a cell's read on its line (with parent), a column's `hidden` on the record.
+        if (def && node.lineDelete !== undefined && def.type !== 'one2many')
+            this.report(`${path}.lineDelete`, `lineDelete only applies to one2many fields; "${node.field}" is a ${def.type}`);
+        if (def && (node.cells || node.rowTones || node.rowBold !== undefined || node.rowButtons || node.lineDelete !== undefined)) {
+            if (def.type !== 'one2many') {
+                if (node.cells || node.rowTones || node.rowBold !== undefined || node.rowButtons)
+                    this.report(path, `cells, rowTones, rowBold and rowButtons only apply to one2many fields; "${node.field}" is a ${def.type}`);
+            }
+            else {
+                const line = { fields: def.fields, lines: node.field };
+                for (const [column, rules] of Object.entries(node.cells ?? {})) {
+                    if (!has(def.fields, column)) {
+                        this.report(`${path}.cells.${column}`, `"${column}" is not a field of the lines of "${node.field}"`);
+                        continue;
+                    }
+                    this.checkModifiers(rules, `${path}.cells.${column}`, ['invisible', 'readonly', 'required', 'bold'], line);
+                    this.checkModifiers(rules, `${path}.cells.${column}`, ['hidden']);
+                    rules.tones?.forEach((tone, i) => this.checkModifiers(tone, `${path}.cells.${column}.tones[${i}]`, ['when'], line));
+                    // Its widget's options that point at a field: one of the line's.
+                    for (const [key, value] of Object.entries(rules.options ?? {})) {
+                        if (key.endsWith('Field') && typeof value === 'string')
+                            this.need(value, `${path}.cells.${column}.options.${key}`, def.fields);
+                    }
+                }
+                node.rowTones?.forEach((tone, i) => this.checkModifiers(tone, `${path}.rowTones[${i}]`, ['when'], line));
+                this.checkModifiers(node, path, ['rowBold', 'lineDelete'], line);
+                node.rowButtons?.forEach((button, i) => {
+                    this.claim(button.id, `${path}.rowButtons[${i}]`);
+                    this.checkModifiers(button, `${path}.rowButtons[${i}]`, ['invisible'], line);
+                    this.checkPress(button, `${path}.rowButtons[${i}]`);
+                });
+            }
+        }
+        // Buttons for the chosen lines and in the control row: buttons of the record, as any.
+        for (const key of ['selectedButtons', 'controlButtons']) {
+            if (!node[key])
+                continue;
+            if (def && def.type !== 'one2many')
+                this.report(`${path}.${key}`, `${key} only apply to one2many fields; "${node.field}" is a ${def.type}`);
+            node[key].forEach((button, i) => {
+                this.claim(button.id, `${path}.${key}[${i}]`);
+                this.checkModifiers(button, `${path}.${key}[${i}]`);
+                this.checkPress(button, `${path}.${key}[${i}]`);
+            });
+        }
         if (def && node.optionalColumns) {
             if (def.type !== 'one2many') {
                 this.report(`${path}.optionalColumns`, `optional columns only apply to one2many fields; "${node.field}" is a ${def.type}`);
             }
             else {
                 // The columns the table shows: those named, or every line field but the structural ones.
-                const shown = node.columns ?? Object.keys(def.fields).filter((c) => c !== def.lineKinds?.field && c !== def.sequenceField);
+                const shown = node.columns ?? Object.keys(def.fields).filter((c) => c !== ('lineKinds' in def ? def.lineKinds?.field : undefined) && c !== def.sequenceField);
                 for (const column of Object.keys(node.optionalColumns)) {
                     if (!shown.includes(column))
                         this.report(`${path}.optionalColumns.${column}`, `"${column}" is not a column of "${node.field}"`);
@@ -383,9 +780,19 @@ export class ReferenceCheck {
                 if (!has(def.fields, column)) {
                     this.report(`${path}.columns[${i}]`, `"${column}" is not a field of the lines of "${node.field}"`);
                 }
+                else if (def.fields[column].type === 'one2many') {
+                    this.report(`${path}.columns[${i}]`, `"${column}" holds lines of its own: they are edited in the line's form (lineForm), not drawn in its row`);
+                }
+            });
+        }
+        else if (def.type === 'many2many') {
+            // A table of the records linked: its columns are fields of those records.
+            node.columns.forEach((column, i) => {
+                if (!def.fields || !has(def.fields, column))
+                    this.report(`${path}.columns[${i}]`, `"${column}" is not a field of the records of "${node.field}"`);
             });
         }
-        else if (def.type !== 'many2many') {
+        else {
             this.report(`${path}.columns`, `columns only apply to one2many and many2many fields; "${node.field}" is a ${def.type}`);
         }
     }