@fieldia/core 0.11.0 → 0.12.0

package/src/lib/record/form.mjs

@@ -5,12 +5,16 @@ import { checkInput } from './inputs.mjs';
 import { compileComputed } from './compute.mjs';
 import { compileSetWhen } from './set-when.mjs';
 import { checkRules, compileRules } from './rules.mjs';
-import { expressionEnv } from './env.mjs';
+import { expressionEnv, lineContext, recordContext } from './env.mjs';
+import { firstValues, readLooseMap, readValueMap } from './value-map.mjs';
+import { resolveFilter } from './filter.mjs';
+import { rolesAllow } from './roles.mjs';
+import { compileFieldTone, compileTable } from './cells.mjs';
 import { MESSAGES } from './messages.mjs';
 import { saveProblemOf } from './data-source.mjs';
 import { hostScheduler } from './scheduler.mjs';
 import { createMoments, createRunner } from './run.mjs';
-import { emptyValue, expressionContext, initialValues, isEmpty, lineKind, structuredCopy, } from './values.mjs';
+import { emptyValue, initialValues, isEmpty, lineKind, structuredCopy, } from './values.mjs';
 /**
  * The record state behind a page: values, what changed, what is visible and
  * required, errors, loading and saving. No DOM and no framework — every
@@ -35,13 +39,68 @@ function innerForm(options, within) {
         if (node.kind === 'field' && rules)
             nodeRules.set(node.id, compileRules(rules));
     }
+    /** Tables of lines with rules of their own, by their field node: each read once. */
+    const tables = new Map();
+    for (const node of index.values()) {
+        const source = node.source;
+        if (node.kind !== 'field' || page.fields[source.field]?.type !== 'one2many')
+            continue;
+        if (source.cells || source.rowTones || source.rowBold !== undefined || source.rowButtons || source.lineDelete !== undefined)
+            tables.set(node.id, { field: source.field, compiled: compileTable(source) });
+    }
+    /** Field nodes whose value takes a tone or bold, by id: each read once. */
+    const fieldTones = new Map();
+    for (const node of index.values()) {
+        const source = node.source;
+        if (node.kind === 'field' && (source.tones || source.bold !== undefined))
+            fieldTones.set(node.id, compileFieldTone(source));
+    }
+    /** The tables whose lines load in an order of their own fields, by the field: the first node to give one. */
+    const lineOrders = new Map();
+    for (const node of index.values()) {
+        const source = node.source;
+        if (node.kind === 'field' && source.order?.length && page.fields[source.field]?.type === 'one2many' && !lineOrders.has(source.field))
+            lineOrders.set(source.field, source.order);
+    }
+    /** Lines as they load, in their tables' orders — only `loaded` fields, when given: the same values when nothing moved. */
+    function ordered(values, loaded) {
+        let out = values;
+        for (const [field, by] of lineOrders) {
+            if (loaded && !loaded.includes(field))
+                continue;
+            const lines = values[field];
+            if (!Array.isArray(lines) || lines.length < 2)
+                continue;
+            const sorted = [...lines].sort((a, b) => compareLines(a.values, b.values, by));
+            if (sorted.some((line, i) => line !== lines[i]))
+                out = { ...out, [field]: sorted };
+        }
+        return out;
+    }
+    /** The words of each field's empty box chosen by conditions, by its node: read once. */
+    const placeholders = new Map();
+    const placeholderOf = (id, own) => {
+        if (own.placeholderWhen?.length)
+            placeholders.set(id, { fixed: own.placeholder, when: own.placeholderWhen.map((item) => ({ text: item.text, holds: compileModifier(item.when) })) });
+    };
+    for (const node of index.values())
+        if (node.kind === 'field' && 'type' in node.source)
+            placeholderOf(node.id, node.source);
+    if (page.layout.type === 'sheet' && page.layout.title)
+        placeholderOf('#title', page.layout.title);
     /** Whether any rule only warns: without one, there are never warnings to look for. */
     const warns = [...nodeRules.values()].some((rules) => rules.some((compiled) => compiled.rule.level === 'warning'));
     const steps = page.layout.type === 'wizard' ? page.layout.children.map((step) => step.id) : [];
     const draftKey = () => `fieldia:draft:${page.id}:${state.recordId ?? 'new'}`;
     const today = () => localDay(options.now?.() ?? new Date());
-    const computed = compileComputed(page, today);
-    const setWhen = compileSetWhen(page, today);
+    // The record's id and the person, as worked-out values read them: the id is the one asked for until the form has its state.
+    let started = false;
+    let editing = options.editing !== false;
+    /** The record a line's form is of, as its conditions read it: worked out once. */
+    const parentContext = options.parent ? recordContext(options.parent.values, options.parent.fields, { recordId: options.parent.id ?? null, user: options.user, context: options.context }) : undefined;
+    const about = () => ({ recordId: started ? state.recordId : (options.recordId ?? null), user: options.user, editing, context: options.context, parent: parentContext });
+    const computed = compileComputed(page, today, about);
+    const setWhen = compileSetWhen(page, today, about);
     /** The saved forms placed on the page, by the part's id: each one's answers sit under its name, as JSON. */
     const parts = new Map();
     for (const node of index.values())
@@ -55,7 +114,75 @@ function innerForm(options, within) {
         fields[part.name] = { type: 'json', label: part.title || part.name };
     /** True while answers are handed to an inner form: what it says back then is no change of its own. */
     let syncing = false;
-    let baseline = computed.apply({ ...initialValues(fields, today()), ...structuredCopy(options.values ?? {}) });
+    /** A new record's values: each field's default, then those worked out from `defaultFrom`, then what the form is given. */
+    /** What the record starts with: each field's default, a new one's worked-out first values, and — as the form opens — what it was given. */
+    function startingValues(isNew = options.recordId == null, given = true) {
+        const values = initialValues(fields, today());
+        if (isNew) {
+            const about = { recordId: null, user: options.user, context: options.context, parent: parentContext };
+            Object.assign(values, firstValues(page.fields, mapScope(values, page.fields, recordContext(values, page.fields, about), expressionEnv(values, page.fields, today))));
+        }
+        return given ? ordered({ ...values, ...structuredCopy(options.values ?? {}) }) : values;
+    }
+    /** The name this form knows a record by, from a link to the same model it holds. */
+    function knownLabel(relation, id) {
+        const values = (started ? state.values : {});
+        for (const [name, def] of Object.entries(page.fields)) {
+            if ((def.type !== 'many2one' && def.type !== 'many2many') || def.relation !== relation)
+                continue;
+            const held = values[name];
+            const found = (Array.isArray(held) ? held : held ? [held] : []).find((record) => record?.id === id);
+            if (found)
+                return found.label;
+        }
+        return undefined;
+    }
+    function mapScope(values, scopeFields, context, env, parent) {
+        return { values, fields: scopeFields, context, env, ...(parent ? { parent } : {}), ...(options.user ? { user: options.user } : {}), labelOf: knownLabel };
+    }
+    /** Where a value map on the record is read. */
+    function recordScope() {
+        const { context, env } = reading();
+        return mapScope(state.values, page.fields, context, env);
+    }
+    /** Where a value map on one line is read: the line, with its record as `parent`. */
+    function lineScope(field, values) {
+        const def = lineField(field);
+        const lineFields = def.fields;
+        return mapScope(values, lineFields, lineContext(values, lineFields, reading().context), { today }, { values: state.values, fields: page.fields });
+    }
+    function tableOf(nodeId) {
+        const table = tables.get(nodeId);
+        if (table)
+            return table;
+        const node = index.get(nodeId);
+        if (node?.kind !== 'field' || page.fields[node.field]?.type !== 'one2many')
+            throw new Error(`"${nodeId}" is not a table of lines`);
+        return null;
+    }
+    /** A line of a table as its rules have it now; none, plain. */
+    function lineStateOf(nodeId, key) {
+        const table = tableOf(nodeId);
+        if (!table)
+            return { tone: null, bold: false, cells: {}, buttons: {}, deletable: true };
+        const line = (state.values[table.field] ?? []).find((l) => l.key === key);
+        if (!line)
+            throw new Error(`"${table.field}" has no line "${key}"`);
+        const def = lineField(table.field);
+        return table.compiled.line(lineContext(line.values, def.fields, reading().context, line.id ?? null), { today }, userRoles);
+    }
+    function createValuesOf(field, line) {
+        if (!line) {
+            const def = fieldDef(field);
+            return def.type === 'many2one' || def.type === 'many2many' ? (def.createValues ? readLooseMap(def.createValues, recordScope()) : {}) : {};
+        }
+        const found = (state.values[line.lines] ?? []).find((l) => l.key === line.key);
+        const sub = lineField(line.lines).fields[field];
+        if (!found || !sub || (sub.type !== 'many2one' && sub.type !== 'many2many') || !sub.createValues)
+            return {};
+        return readLooseMap(sub.createValues, lineScope(line.lines, found.values));
+    }
+    let baseline = computed.apply(startingValues());
     /** The setWhen conditions holding for the values as they last settled: one starts to hold only against these. */
     let holding = setWhen.holding(baseline);
     let state = {
@@ -73,7 +200,9 @@ function innerForm(options, within) {
         skipped: [],
         saveProblem: null,
         choices: {},
+        definitions: {},
     };
+    started = true;
     /** Field errors a refused save brought, each kept until its field changes from the value it was refused with. */
     let serverErrors = {};
     let lineKeys = 0;
@@ -91,6 +220,7 @@ function innerForm(options, within) {
     /** The wizard step last told as entered. */
     let told = null;
     let contextCache = null;
+    const userRoles = [...(options.user?.roles ?? [])];
     /** The latest load of each field's choices: an answer to an older one is let go. */
     const choiceLoads = {};
     function set(patch) {
@@ -108,6 +238,9 @@ function innerForm(options, within) {
             for (const name in state.choices)
                 if (fromList(name).dependsOn?.some((other) => was[other] !== state.values[other]))
                     loadChoices(name);
+            for (const name in state.definitions)
+                if (fromRecord(name).dependsOn?.some((other) => was[other] !== state.values[other]))
+                    loadDefinitions(name);
         }
         if (showing && state.step !== told)
             tellStep(entering);
@@ -158,6 +291,24 @@ function innerForm(options, within) {
         const source = options.dataSource;
         void track((source?.options ? source.options({ list, values: structuredCopy(state.values) }) : Promise.reject(new Error(`No list "${list}"`))).then((loaded) => put({ options: loaded }), (error) => put({ options: shown, error: error.message ?? String(error) })));
     }
+    const fromRecord = (name) => page.fields[name].definitionsFrom;
+    const definitionLoads = {};
+    function loadDefinitions(name) {
+        const { list } = fromRecord(name);
+        const load = (definitionLoads[name] = (definitionLoads[name] ?? 0) + 1);
+        const put = (definitions) => load === definitionLoads[name] && set({ definitions: { ...state.definitions, [name]: definitions } });
+        // What was shown stays while the next ones load.
+        const shown = state.definitions[name]?.definitions ?? null;
+        put({ definitions: shown, loading: true });
+        const source = options.dataSource;
+        void track((source?.definitions ? source.definitions({ list, values: structuredCopy(state.values) }) : Promise.reject(new Error(`No definitions "${list}"`))).then((loaded) => put({ definitions: loaded }), (error) => put({ definitions: shown, error: error.message ?? String(error) })));
+    }
+    async function addDefinition(name, definition) {
+        const { list } = fromRecord(name);
+        const definitions = [...(state.definitions[name]?.definitions ?? []), definition];
+        set({ definitions: { ...state.definitions, [name]: { definitions } } });
+        await track(options.dataSource?.saveDefinitions?.({ list, values: structuredCopy(state.values), definitions }) ?? Promise.resolve());
+    }
     /** A field as its value is checked: a list's choices are those loaded, and until they are, any choice may be one. */
     function checked(name) {
         const def = page.fields[name];
@@ -170,11 +321,12 @@ function innerForm(options, within) {
         promise.then(done, done);
         return promise;
     }
-    /** The values as expressions read them, and what else they read: the lines' rows, today. */
+    /** The values as expressions read them, and what else they read: the record's id, the person, the lines' rows, today. */
     function reading() {
-        if (contextCache?.values !== state.values) {
+        if (contextCache?.values !== state.values || contextCache.recordId !== state.recordId || contextCache.editing !== editing) {
             const values = state.values;
-            contextCache = { values, context: expressionContext(values, page.fields), env: expressionEnv(values, page.fields, today) };
+            const context = recordContext(values, page.fields, about());
+            contextCache = { values, recordId: state.recordId, editing, context, env: expressionEnv(values, page.fields, today) };
         }
         return contextCache;
     }
@@ -193,9 +345,10 @@ function innerForm(options, within) {
         if (!node)
             throw new Error(`The page has no element "${id}"`);
         const { context: ctx, env } = reading();
-        let invisible = node.invisible.evaluate(ctx, env);
+        const hidden = (at) => (at ? !rolesAllow(at.roles, userRoles) || at.invisible.evaluate(ctx, env) : false);
+        let invisible = hidden(node);
         for (let parent = node.parent; !invisible && parent; parent = index.get(parent)?.parent ?? null) {
-            invisible = index.get(parent)?.invisible.evaluate(ctx, env) ?? false;
+            invisible = hidden(index.get(parent));
         }
         // A section read-only right now makes everything inside it read-only too.
         let readonly = node.readonly.evaluate(ctx, env);
@@ -290,10 +443,15 @@ function innerForm(options, within) {
                 for (const line of state.values[name] ?? []) {
                     // A section or note answers only for its text, never for what an item needs.
                     const kind = lineKind(def, line.values);
+                    // The table's own rules: a cell its line hides asks nothing, one it requires asks for a value.
+                    const ruled = tables.has(node.id) ? lineStateOf(node.id, line.key).cells : {};
                     for (const [sub, subDef] of Object.entries(def.fields)) {
                         if (kind && sub !== def.lineKinds?.text)
                             continue;
-                        const lineMessage = checkValue(subDef, line.values[sub], subDef.required === true, messages, today());
+                        const cell = ruled[sub];
+                        if (cell?.invisible || (tables.has(node.id) && tables.get(node.id).compiled.hidden(sub, reading().context, reading().env, userRoles)))
+                            continue;
+                        const lineMessage = checkValue(subDef, line.values[sub], subDef.required === true || cell?.required === true, messages, today());
                         if (lineMessage)
                             errors[`${name}.${line.key}.${sub}`] = lineMessage;
                     }
@@ -526,7 +684,8 @@ function innerForm(options, within) {
                 values: structuredCopy(state.values),
             });
             forgetDraft();
-            const values = syncParts(startFrom(result.values ? { ...state.values, ...result.values } : state.values), 'start');
+            // Lines the save brings back load again, in their tables' orders, as Flectra's reload after a save.
+            const values = syncParts(startFrom(result.values ? ordered({ ...state.values, ...result.values }, Object.keys(result.values)) : state.values), 'start');
             baseline = structuredCopy(values);
             set({ status: 'saved', recordId: result.id, values, dirty: [], warnings: withValues(values, collectWarnings) });
             emit('save', { recordId: state.recordId, values: state.values });
@@ -562,9 +721,18 @@ function innerForm(options, within) {
     }
     function addLine(field, values, by) {
         const def = lineField(field);
-        const key = `new-${++lineKeys}`;
         const current = state.values[field] ?? [];
-        const line = { key, values: { ...initialValues(def.fields, today()), ...structuredCopy(values) } };
+        // A key no line holds: lines given (a line's own lines, back from its form) may hold new-… keys already.
+        let key = `new-${++lineKeys}`;
+        while (current.some((line) => line.key === key))
+            key = `new-${++lineKeys}`;
+        // Each line field's default, then what is worked out from its defaultFrom, then the record's lineDefaults, then what the line is given.
+        const lineFields = def.fields;
+        const start = initialValues(lineFields, today());
+        Object.assign(start, firstValues(lineFields, lineScope(field, start)));
+        if (def.lineDefaults)
+            Object.assign(start, readValueMap(def.lineDefaults, lineFields, recordScope()));
+        const line = { key, values: { ...start, ...structuredCopy(values) } };
         // A new line comes last, so it is numbered after the last.
         if (def.sequenceField && line.values[def.sequenceField] == null) {
             const numbers = current.map((l) => l.values[def.sequenceField]).filter((n) => typeof n === 'number');
@@ -607,30 +775,26 @@ function innerForm(options, within) {
             return null;
         return def.type === 'many2one' || def.type === 'many2many' ? def.relation : null;
     }
-    async function runCreate(def, name, typed) {
+    async function runCreate(def, name, typed, values = {}) {
         const model = creatable(def);
         const source = options.dataSource;
         if (!model || !source?.create)
             throw new Error(`"${name}" cannot make records: its data source has no create, or it is not a link`);
-        return track(source.create({ model, name: typed.trim() }));
+        return track(source.create({ model, name: typed.trim(), ...(Object.keys(values).length ? { values } : {}) }));
     }
-    async function runSearch(def, name, ctx, query, limit, model) {
-        if (def.type !== 'many2one' && def.type !== 'many2many' && def.type !== 'reference') {
-            throw new Error(`"${name}" is not a many2one, many2many or reference`);
+    async function runSearch(def, name, ctx, query, limit, model, ids) {
+        if (def.type !== 'many2one' && def.type !== 'many2many' && def.type !== 'reference' && def.type !== 'json') {
+            throw new Error(`"${name}" is not a many2one, many2many, reference or json`);
         }
-        if (def.type === 'reference' && !model)
+        if ((def.type === 'reference' || def.type === 'json') && !model)
             throw new Error(`Searching "${name}" needs a model`);
         const source = options.dataSource;
         if (!source?.search)
             return [];
         // Every valueFrom, in groups too, becomes the value it names before the search goes out.
-        const resolve = (item) => 'any' in item
-            ? { any: item.any.map(resolve) }
-            : 'all' in item
-                ? { all: item.all.map(resolve) }
-                : { field: item.field, op: item.op, value: (item.valueFrom !== undefined ? ctx[item.valueFrom] ?? null : item.value ?? null) };
-        const filter = def.type === 'reference' ? undefined : def.filter?.map(resolve);
-        const relation = def.type === 'reference' ? model : def.relation;
+        const own = def.type === 'reference' || def.type === 'json' || !def.filter ? undefined : resolveFilter(def.filter, ctx);
+        const filter = ids ? [...(own ?? []), { field: 'id', op: 'in', value: ids }] : own;
+        const relation = def.type === 'reference' || def.type === 'json' ? model : def.relation;
         return track(source.search({ model: relation, query, ...(filter ? { filter } : {}), limit }));
     }
     function lineField(field) {
@@ -646,7 +810,8 @@ function innerForm(options, within) {
     function optionalStep(id) {
         return index.get(id)?.source?.optional === true;
     }
-    async function load() {
+    /** Load the record; `again`, as a step's reload: no draft offered, no `open` steps run a second time. */
+    async function load(again = false) {
         const source = options.dataSource;
         if (state.recordId == null || page.data.kind !== 'record')
             return;
@@ -654,18 +819,65 @@ function innerForm(options, within) {
             set({ status: 'error', error: 'This page has no data source to load from' });
             return;
         }
+        // Only the latest load is taken: a pager pressed twice shows the record it ended on.
+        const seq = ++loads;
         set({ status: 'loading', error: null });
         try {
             const loaded = await source.load({ model: page.data.model, id: state.recordId, fields });
-            baseline = syncParts(startFrom({ ...initialValues(fields, today()), ...loaded }), 'start');
+            if (seq !== loads)
+                return;
+            // Lines load in their tables' orders; where a person moves them after, they stay.
+            baseline = syncParts(startFrom(ordered({ ...initialValues(fields, today()), ...loaded })), 'start');
             set({ status: 'ready', values: structuredCopy(baseline), dirty: [], errors: {}, warnings: withValues(baseline, collectWarnings) });
+            if (again)
+                return;
             offerDraft();
             void track(opening());
         }
         catch (error) {
-            set({ status: 'error', error: error.message });
+            if (seq === loads)
+                set({ status: 'error', error: error.message });
         }
     }
+    let loads = 0;
+    /** Another record in this form's place, or a new one: what was there let go, the new one loaded and opened. */
+    async function openRecord(id) {
+        if (draftTimer !== null)
+            scheduler.clearTimeout(draftTimer);
+        if (autosaveTimer !== null)
+            scheduler.clearTimeout(autosaveTimer);
+        draftTimer = autosaveTimer = null;
+        serverErrors = {};
+        told = null;
+        showing = false;
+        const fresh = { dirty: [], errors: {}, warning: null, warningField: null, error: null, draft: null, step: steps[0] ?? null, skipped: [], saveProblem: null };
+        if (id != null) {
+            set({ ...fresh, recordId: id, status: 'idle' });
+            return load();
+        }
+        loads++;
+        baseline = startFrom(startingValues(true, false));
+        const values = syncParts(structuredCopy(baseline), 'start');
+        set({ ...fresh, recordId: null, status: 'ready', values, warnings: withValues(values, collectWarnings) });
+        offerDraft();
+        await opening();
+    }
+    /** The record a record step asks the data source about. */
+    const record = () => ({ model: page.data.model, id: state.recordId, fields });
+    async function post(message) {
+        if (options.host?.post) {
+            try {
+                return (await options.host.post(message)) !== false;
+            }
+            catch {
+                return false;
+            }
+        }
+        if (!events.get('post')?.size)
+            return false;
+        emit('post', { recordId: state.recordId, message });
+        return true;
+    }
     const runner = createRunner({
         fields,
         values: () => state.values,
@@ -676,6 +888,12 @@ function innerForm(options, within) {
         addLine: (field, values) => void addLine(field, values, 'step'),
         check,
         save: saving,
+        async reload() {
+            if (state.recordId == null)
+                return { reason: 'cannot', message: 'The record is not saved yet: there is nothing to load again' };
+            await load(true);
+            return state.status === 'error' ? { reason: 'cannot', message: state.error ?? 'The record could not be loaded again' } : null;
+        },
         reset: () => form.reset(),
         goTo: goToStep,
         showing: inRun,
@@ -683,8 +901,50 @@ function innerForm(options, within) {
         confirm: options.confirm,
         onAction: options.onAction,
         answered: (request, result) => emit('action', { request, result }),
+        changed: () => state.dirty.length > 0,
+        ...(options.dataSource?.archive && page.data.kind === 'record' ? { archive: (archive) => track((options.dataSource?.archive)({ ...record(), archive })) } : {}),
+        ...(options.dataSource?.copy && page.data.kind === 'record' ? { copy: async () => (await track((options.dataSource?.copy)(record()))).id } : {}),
+        ...(options.dataSource?.delete && page.data.kind === 'record' ? { remove: () => track((options.dataSource?.delete)(record())) } : {}),
+        async showRecord(id) {
+            await openRecord(id);
+            return state.status === 'error' ? { reason: 'cannot', message: state.error ?? 'The record could not be loaded' } : null;
+        },
+        told(event, id) {
+            if ('archived' in event)
+                emit('archive', { recordId: id, archived: event.archived });
+            else if ('copied' in event)
+                emit('duplicate', { from: id, recordId: event.copied });
+            else {
+                emit('delete', { recordId: id });
+                // Nobody moved the form on: it starts a new record in the deleted one's place.
+                if (state.recordId === id)
+                    void track(openRecord(null));
+            }
+        },
+        post,
+        wordsOf: (field) => wordsOfValue(fieldDef(field), state.values[field]),
     });
     const moment = createMoments((key, list, chain) => runTop(list, { id: key, chain }));
+    /** A press of a button: its confirmation first, then its steps and its app action as a final call, in `scope`. */
+    function press(source, scope) {
+        const list = [...(source.steps ?? [])];
+        if (source.action !== undefined)
+            list.push({ do: 'call', action: source.action, ...('params' in source && source.params ? { params: source.params } : {}) });
+        // A built-in item of the gear menu with nothing of its own: its step, asked about first when it archives or deletes.
+        const builtin = 'builtin' in source && !list.length ? source.builtin : undefined;
+        if (builtin)
+            list.push({ do: builtin });
+        const asked = builtin === 'archive' ? messages.archiveConfirm : builtin === 'delete' ? messages.deleteConfirm : undefined;
+        const confirm = 'confirm' in source && source.confirm !== undefined ? source.confirm : asked;
+        return track((async () => {
+            if (confirm && !(await runner.ask(confirm))) {
+                const result = { done: false, reason: 'no', message: confirm };
+                emit('run', { id: scope.id, steps: list, result });
+                return result;
+            }
+            return runTop(list, scope);
+        })());
+    }
     const form = {
         page,
         getState: () => state,
@@ -701,8 +961,19 @@ function innerForm(options, within) {
         },
         setValues: (values) => write(values, 'app'),
         node: nodeState,
+        openRecord: (id) => track(openRecord(id)),
+        post,
+        setEditing(next) {
+            if (next === editing)
+                return;
+            editing = next;
+            // Nothing of the record changed; what shows of it may have.
+            set({});
+        },
         fieldReadonly: (name) => lockedField(fieldDef(name)),
         loadChoices,
+        loadDefinitions,
+        addDefinition,
         problem(name) {
             fieldDef(name);
             // Only a field someone can see is asked anything, and required wherever it is shown so.
@@ -770,13 +1041,21 @@ function innerForm(options, within) {
         },
         removeLine(field, key) {
             lineField(field);
+            // A table that keeps this line (its lineDelete does not hold on it) refuses, wherever the call comes from.
+            for (const [nodeId, table] of tables) {
+                if (table.field !== field || (index.get(nodeId)?.source).lineDelete === undefined)
+                    continue;
+                if ((state.values[field] ?? []).some((line) => line.key === key) && !lineStateOf(nodeId, key).deletable) {
+                    throw new Error(`The line "${key}" of "${field}" cannot be deleted now: its table's lineDelete does not hold on it`);
+                }
+            }
             const lines = (state.values[field] ?? []).filter((line) => line.key !== key);
             writeValues({ ...state.values, [field]: lines });
             afterEdit(field);
             changed(field, 'person');
         },
         async search(field, query, limit = 8, options = {}) {
-            return runSearch(fieldDef(field), field, context(), query, limit, options.model);
+            return runSearch(fieldDef(field), field, context(), query, limit, options.model, options.ids);
         },
         async previewLine(field, key, values) {
             lineField(field);
@@ -784,16 +1063,16 @@ function innerForm(options, within) {
             const line = lines.find((l) => l.key === key);
             if (!line)
                 throw new Error(`"${field}" has no line "${key}"`);
-            const merged = computed.line(field, { ...line.values, ...values });
+            const merged = computed.line(field, { ...line.values, ...values }, state.values);
             const source = options.dataSource;
             if (!source?.onchange || page.data.kind !== 'record')
                 return merged;
             const changed = lines.map((l) => (l.key === key ? { ...l, values: merged } : l));
             const result = await source.onchange({ model: page.data.model, id: state.recordId, changed: field, values: structuredCopy({ ...state.values, [field]: changed }) });
             const after = (result.values?.[field] ?? []).find((l) => l.key === key);
-            return after ? computed.line(field, { ...merged, ...after.values }) : merged;
+            return after ? computed.line(field, { ...merged, ...after.values }, state.values) : merged;
         },
-        async searchLine(field, key, subfield, query, limit = 8) {
+        async searchLine(field, key, subfield, query, limit = 8, options = {}) {
             const def = lineField(field);
             const sub = def.fields[subfield];
             if (!sub)
@@ -801,12 +1080,13 @@ function innerForm(options, within) {
             const line = (state.values[field] ?? []).find((l) => l.key === key);
             if (!line)
                 throw new Error(`"${field}" has no line "${key}"`);
-            return runSearch(sub, subfield, expressionContext(line.values, def.fields), query, limit);
+            return runSearch(sub, subfield, lineContext(line.values, def.fields, context(), line.id ?? null), query, limit, options.model, options.ids);
         },
         canCreate: (field) => creatable(page.fields[field]) !== null,
-        quickCreate: (field, typed) => runCreate(page.fields[field], field, typed),
+        quickCreate: (field, typed) => runCreate(page.fields[field], field, typed, page.fields[field] ? createValuesOf(field) : {}),
         canCreateLine: (field, subfield) => creatable(lineField(field).fields[subfield]) !== null,
-        quickCreateLine: (field, subfield, typed) => runCreate(lineField(field).fields[subfield], subfield, typed),
+        quickCreateLine: (field, subfield, typed, key) => runCreate(lineField(field).fields[subfield], subfield, typed, key ? createValuesOf(subfield, { lines: field, key }) : {}),
+        createValues: (field, line) => createValuesOf(field, line),
         steps: () => steps.filter((id) => !nodeState(id).invisible),
         next() {
             if (!state.step)
@@ -880,21 +1160,85 @@ function innerForm(options, within) {
                 throw new Error(`The page has no button "${id}"`);
             if (nodeState(id).invisible)
                 return { done: false, reason: 'cannot', message: `The button "${id}" is hidden` };
-            const source = node.source;
-            // Its steps, then its app action as a final call.
-            const list = [...(source.steps ?? [])];
-            if (source.action !== undefined)
-                list.push({ do: 'call', action: source.action, ...('params' in source && source.params ? { params: source.params } : {}) });
-            const scope = { id, chain: [], ...(chosen ? { recordIds: [...chosen.recordIds] } : {}) };
-            const confirm = 'confirm' in source ? source.confirm : undefined;
-            return track((async () => {
-                if (confirm && !(await runner.ask(confirm))) {
-                    const result = { done: false, reason: 'no', message: confirm };
-                    emit('run', { id, steps: list, result });
-                    return result;
-                }
-                return runTop(list, scope);
-            })());
+            // A button for a table's chosen lines runs with them: runLinesAction.
+            if (node.parent && index.get(node.parent)?.source?.selectedButtons?.some((b) => b.id === id)) {
+                return { done: false, reason: 'cannot', message: `The button "${id}" runs with the lines chosen in its table` };
+            }
+            return press(node.source, { id, chain: [], ...(chosen ? { recordIds: [...chosen.recordIds] } : {}) });
+        },
+        async linkedValues(field, ids, columns) {
+            const def = fieldDef(field);
+            if (def.type !== 'many2many')
+                throw new Error(`"${field}" is not a many2many`);
+            const source = options.dataSource;
+            if (!source?.list || !ids.length)
+                return [];
+            const found = await source.list({ model: def.relation, fields: [...columns], filter: [{ field: 'id', op: 'in', value: [...ids] }], sort: [], offset: 0, limit: ids.length });
+            const byId = new Map(found.records.map((record) => [String(record.id), record]));
+            return ids.flatMap((id) => {
+                const record = byId.get(String(id));
+                return record ? [{ id: record.id, values: record.values }] : [];
+            });
+        },
+        fieldTone(nodeId) {
+            const compiled = fieldTones.get(nodeId);
+            if (compiled) {
+                const { context: ctx, env } = reading();
+                return compiled(ctx, env);
+            }
+            if (index.get(nodeId)?.kind !== 'field')
+                throw new Error(`"${nodeId}" is not a field on this page`);
+            return { tone: null, bold: false };
+        },
+        placeholder(nodeId) {
+            const own = placeholders.get(nodeId);
+            if (!own) {
+                const node = index.get(nodeId);
+                if (node?.kind !== 'field')
+                    throw new Error(`"${nodeId}" is not a field on this page`);
+                const source = node.source;
+                return nodeId === '#title' && page.layout.type === 'sheet' ? page.layout.title?.placeholder : source.placeholder;
+            }
+            const { context: ctx, env } = reading();
+            return own.when.find((item) => item.holds.evaluate(ctx, env))?.text ?? own.fixed;
+        },
+        lineState: (nodeId, key) => lineStateOf(nodeId, key),
+        columnHidden(nodeId, column) {
+            const table = tableOf(nodeId);
+            const { context, env } = reading();
+            return table ? table.compiled.hidden(column, context, env, userRoles) : false;
+        },
+        async runRowAction(nodeId, buttonId, key) {
+            const table = tableOf(nodeId);
+            const button = table?.compiled.buttons.find((b) => b.id === buttonId);
+            if (!table || !button)
+                throw new Error(`The table "${nodeId}" has no button "${buttonId}"`);
+            if (!lineStateOf(nodeId, key).buttons[buttonId])
+                return { done: false, reason: 'cannot', message: `The button "${buttonId}" is hidden on this line` };
+            const line = (state.values[table.field] ?? []).find((l) => l.key === key);
+            return press(button, { id: buttonId, chain: [], line: { field: table.field, key, values: structuredCopy(line.values) } });
+        },
+        async runLinesAction(nodeId, buttonId, keys) {
+            const node = index.get(nodeId);
+            const source = node?.source;
+            const button = source?.selectedButtons?.find((b) => b.id === buttonId);
+            if (!node || !source || !button)
+                throw new Error(`The table "${nodeId}" has no button "${buttonId}" for its chosen lines`);
+            const all = state.values[source.field] ?? [];
+            const chosen = keys.map((key) => all.find((line) => line.key === key) ?? null);
+            const missing = keys.find((_, i) => !chosen[i]);
+            if (missing !== undefined)
+                throw new Error(`"${source.field}" has no line "${missing}"`);
+            if (nodeState(buttonId).invisible)
+                return { done: false, reason: 'cannot', message: `The button "${buttonId}" is hidden` };
+            if (!keys.length)
+                return { done: false, reason: 'cannot', message: `The button "${buttonId}" runs with lines chosen: none is` };
+            const lines = chosen;
+            return press(button, {
+                id: buttonId,
+                chain: [],
+                lines: { field: source.field, keys: [...keys], ids: lines.flatMap((line) => (line.id === undefined ? [] : [line.id])), values: lines.map((line) => structuredCopy(line.values)) },
+            });
         },
         run: (list, context = {}) => track(runTop(list, { id: context.id ?? 'run', chain: [], ...(context.recordIds ? { recordIds: [...context.recordIds] } : {}) })),
         shown(tab) {
@@ -1012,6 +1356,29 @@ function inside(errors, name) {
             found[key.slice(name.length + 1)] = message;
     return found;
 }
+/** One value against another in a table's order: empty and false first, a link by its name, words as people sort them. */
+function compareValues(a, b) {
+    const empty = (v) => v === null || v === undefined || v === false || v === '';
+    if (empty(a) || empty(b))
+        return empty(a) === empty(b) ? 0 : empty(a) ? -1 : 1;
+    const plain = (v) => (v !== null && typeof v === 'object' && !Array.isArray(v) && 'label' in v ? String(v.label) : v);
+    const x = plain(a);
+    const y = plain(b);
+    if (typeof x === 'number' && typeof y === 'number')
+        return x - y;
+    if (typeof x === 'boolean' && typeof y === 'boolean')
+        return Number(x) - Number(y);
+    return String(x).localeCompare(String(y));
+}
+/** Two lines in a table's order: by the first field, then the next. */
+function compareLines(a, b, by) {
+    for (const item of by) {
+        const found = compareValues(a[item.field], b[item.field]);
+        if (found)
+            return item.desc ? -found : found;
+    }
+    return 0;
+}
 /** A field no one types in: read-only by its definition, or worked out from others. */
 function lockedField(def) {
     return def.readonly === true || def.compute !== undefined;
@@ -1050,11 +1417,13 @@ function linkOps(before, now) {
 function indexLayout(root) {
     const index = new Map();
     const add = (source, parent, kind, modifiers) => {
+        const roles = source.roles;
         index.set(source.id, {
             id: source.id,
             parent,
             kind,
             field: modifiers.field,
+            ...(roles?.length ? { roles } : {}),
             invisible: compileModifier(modifiers.invisible),
             readonly: compileModifier(modifiers.readonly),
             required: compileModifier(modifiers.required),
@@ -1065,6 +1434,9 @@ function indexLayout(root) {
         for (const node of nodes) {
             if (node.type === 'field') {
                 add(node, parent, 'field', { invisible: node.invisible, readonly: node.readonly, required: node.required, field: node.field });
+                // A table's buttons for its chosen lines and in its control row: buttons of the record, inside the table.
+                for (const button of [...(node.selectedButtons ?? []), ...(node.controlButtons ?? [])])
+                    add(button, node.id, 'button', { invisible: button.invisible });
             }
             else if (node.type === 'button') {
                 add(node, parent, 'button', { invisible: node.invisible });
@@ -1102,6 +1474,8 @@ function indexLayout(root) {
     }
     else if (root.type === 'sections') {
         walk(root.children, root.id);
+        for (const button of root.footer ?? [])
+            add(button, root.id, 'button', { invisible: button.invisible });
     }
     else if (root.type === 'list') {
         // A list holds no fields of its own record: only the buttons for what is selected.
@@ -1118,23 +1492,54 @@ function indexLayout(root) {
         shown('#title', root.title?.field);
         shown('#subtitle', root.title?.subtitleField);
         shown('#avatar', root.title?.avatarField);
-        shown('#statusbar', root.statusbar?.field);
-        for (const button of root.buttons ?? [])
+        // The statusbar shows and hides by its own condition and roles.
+        if (root.statusbar)
+            add({ id: '#statusbar', ...(root.statusbar.roles ? { roles: root.statusbar.roles } : {}) }, root.id, 'field', { field: root.statusbar.field, invisible: root.statusbar.invisible });
+        for (const button of [...(root.buttons ?? []), ...(root.footer ?? [])])
             add(button, root.id, 'button', { invisible: button.invisible });
         for (const stat of root.statButtons ?? [])
             add(stat, root.id, 'stat', { invisible: stat.invisible });
-        if (root.ribbon)
-            add(root.ribbon, root.id, 'other', { invisible: root.ribbon.invisible });
-        for (const alert of root.alerts ?? [])
+        for (const ribbon of [...(root.ribbon ? [root.ribbon] : []), ...(root.ribbons ?? [])])
+            add(ribbon, root.id, 'other', { invisible: ribbon.invisible });
+        for (const alert of root.alerts ?? []) {
             add(alert, root.id, 'other', { invisible: alert.invisible });
+            // An alert's buttons are hidden with it.
+            for (const button of alert.buttons ?? [])
+                add(button, alert.id, 'button', { invisible: button.invisible });
+        }
         for (const badge of root.badges ?? [])
             add(badge, root.id, 'other', { invisible: badge.invisible });
-        // Fields over and under the title are field nodes like any other.
-        walk([...(root.title?.above ?? []), ...(root.title?.below ?? [])], root.id);
+        // Fields over and under the title, and on its line, are field nodes like any other.
+        walk([...(root.title?.above ?? []), ...(root.title?.before ?? []), ...(root.title?.after ?? []), ...(root.title?.below ?? [])], root.id);
         walk(root.children, root.id);
         if (root.sidePanel)
             add(root.sidePanel, root.id, 'other', { invisible: root.sidePanel.invisible });
+        // The gear menu's items are buttons of the record; Archive shows while it is active, Unarchive while it is not.
+        for (const item of root.toolbar?.menu ?? []) {
+            add(item, root.id, 'button', { invisible: item.invisible });
+            if (item.builtin === 'archive' || item.builtin === 'unarchive') {
+                const own = index.get(item.id);
+                const mine = own.invisible;
+                const archived = item.builtin === 'unarchive';
+                own.invisible = { ...mine, evaluate: (context, env) => (context['active'] === false) !== archived || mine.evaluate(context, env) };
+            }
+        }
+        if (root.attachmentPreview)
+            add({ id: '#preview', ...root.attachmentPreview }, root.id, 'other', { invisible: root.attachmentPreview.invisible });
     }
     return index;
 }
+/** A field's value as words in a posted message: a link's name, a choice's label, a yes or no, a number or a date as written. */
+function wordsOfValue(def, value) {
+    if (def.type === 'boolean')
+        return value === true ? 'Yes' : 'No';
+    if (value === null || value === undefined || value === false)
+        return '';
+    if (def.type === 'selection')
+        return def.options.find((option) => option.value === value)?.label ?? String(value);
+    if (def.type === 'html')
+        return String(value).replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
+    const one = (item) => (item && typeof item === 'object' && 'label' in item ? String(item.label) : item && typeof item === 'object' && 'name' in item ? String(item.name) : String(item));
+    return Array.isArray(value) ? value.map(one).join(', ') : one(value);
+}
 //# sourceMappingURL=form.mjs.map