@fieldia/core 0.10.0 → 0.12.0

package/src/lib/record/form.mjs

@@ -5,17 +5,29 @@ 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 { emptyValue, expressionContext, initialValues, isEmpty, lineKind, structuredCopy, } from './values.mjs';
+import { createMoments, createRunner } from './run.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
  * binding renders from `getState()` and calls these methods.
  */
 export function createForm(options) {
+    return innerForm(options, []).form;
+}
+const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+/** A saved form's answers, as the one value they are in the form round it. */
+const asValue = (values) => values;
+/** `within` are the pages round this one, outermost first: a page among them placed again would hold itself. */
+function innerForm(options, within) {
     const { page } = options;
     const scheduler = options.scheduler ?? hostScheduler;
     const messages = options.messages ?? MESSAGES.en;
@@ -27,14 +39,150 @@ export function createForm(options) {
         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);
-    let baseline = computed.apply({ ...initialValues(page.fields, today()), ...structuredCopy(options.values ?? {}) });
+    // 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())
+        if (node.kind === 'form')
+            parts.set(node.id, node.source);
+    /** Those given their page, with the inner form that holds their answers. */
+    const attached = new Map();
+    /** The page's fields, and each saved form's answers as a JSON value: what is loaded, told as changed and saved. */
+    const fields = { ...page.fields };
+    for (const part of parts.values())
+        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;
+    /** 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 = {
@@ -52,7 +200,9 @@ export function createForm(options) {
         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;
@@ -61,12 +211,26 @@ export function createForm(options) {
     let autosaveTimer = null;
     const pending = new Set();
     const listeners = new Set();
+    /** The app's listeners, by event. */
+    const events = new Map();
+    /** The moments the run going to a step or tab right now was set off by: the `show` that entry runs knows them, and does not set them off again. */
+    let entering = [];
+    /** Whether wizard steps entered are told: from once the form has opened and run its `open` steps. */
+    let showing = false;
+    /** 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) {
         const was = state.values;
+        const shown = state.errors;
         state = { ...state, ...patch };
+        // The problems found inside a saved form are shown on it, beside its own fields.
+        if (state.errors !== shown)
+            for (const part of attached.values())
+                part.inner.show(inside(state.errors, part.name));
         for (const listener of [...listeners])
             listener(state);
         // Choices that change with a value that just changed are asked for again.
@@ -74,6 +238,46 @@ export function createForm(options) {
             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);
+    }
+    function emit(event, payload) {
+        const heard = events.get(event);
+        if (heard)
+            for (const listener of [...heard])
+                listener(payload);
+    }
+    /** A field written: told to the app, and — a person's change — the page's `change` steps for it run. */
+    function changed(field, by) {
+        emit('change', { field, value: state.values[field], values: state.values, by });
+        const list = page.on?.change?.[field];
+        if (by === 'person' && list)
+            void track(moment(`on.change.${field}`, list, [], true));
+    }
+    /** A wizard step entered: told to the app, and its `show` steps run. */
+    function tellStep(chain) {
+        const step = state.step;
+        if (step === told || step === null)
+            return;
+        told = step;
+        emit('step', { step });
+        const list = page.on?.show?.[step];
+        if (list)
+            void track(moment(`on.show.${step}`, list, chain, true));
+    }
+    /** Do something while `chain` is the run's that does it, so a step or tab it enters knows. */
+    function inRun(chain, act) {
+        const was = entering;
+        entering = chain;
+        try {
+            act();
+        }
+        finally {
+            entering = was;
         }
     }
     const fromList = (name) => page.fields[name].optionsFrom;
@@ -87,6 +291,24 @@ export function createForm(options) {
         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];
@@ -99,32 +321,34 @@ export function createForm(options) {
         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;
     }
     const context = () => reading().context;
     function fieldDef(name) {
-        const def = page.fields[name];
+        const def = fields[name];
         if (!def)
             throw new Error(`The page has no field "${name}"`);
         return def;
     }
     function dirtyFields(values) {
-        return Object.keys(page.fields).filter((name) => JSON.stringify(values[name] ?? null) !== JSON.stringify(baseline[name] ?? null));
+        return Object.keys(fields).filter((name) => JSON.stringify(values[name] ?? null) !== JSON.stringify(baseline[name] ?? null));
     }
     function nodeState(id) {
         const node = index.get(id);
         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);
@@ -138,8 +362,8 @@ export function createForm(options) {
             required: node.required.evaluate(ctx, env) || def?.required === true,
         };
     }
-    /** Field nodes inside `root` (or the whole page), visible right now. */
-    function visibleFieldNodes(root) {
+    /** Field nodes — or saved forms placed on the page — inside `root` (or the whole page), visible right now. */
+    function visibleFieldNodes(root, kind = 'field') {
         const inside = (node) => {
             if (!root)
                 return true;
@@ -157,7 +381,7 @@ export function createForm(options) {
                     return true;
             return false;
         };
-        return [...index.values()].filter((node) => node.kind === 'field' && inside(node) && !skipped(node) && !nodeState(node.id).invisible);
+        return [...index.values()].filter((node) => node.kind === kind && inside(node) && !skipped(node) && !nodeState(node.id).invisible);
     }
     /** What a field node's answer rules say of its value now: the first error and the first warning. */
     function ruleCheck(node) {
@@ -219,18 +443,51 @@ export function createForm(options) {
                 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;
                     }
                 }
             }
         }
+        // A saved form placed here answers for its fields by its own page's rules.
+        for (const node of visibleFieldNodes(root, 'form')) {
+            const part = attached.get(node.id);
+            if (part)
+                for (const [key, message] of Object.entries(part.inner.errorsNow()))
+                    errors[`${part.name}.${key}`] = message;
+        }
         return errors;
     }
+    /**
+     * Answers changed from outside a saved form — loaded, put back, set — handed
+     * to it, and what it holds after taken back: its defaults and worked-out
+     * values filled in. A new starting point (`start`) is handed to each.
+     */
+    function syncParts(values, how) {
+        let out = values;
+        for (const part of attached.values()) {
+            if (how !== 'start' && out[part.name] === part.inner.form.getState().values)
+                continue;
+            syncing = true;
+            try {
+                part.inner.take(isRecord(out[part.name]) ? out[part.name] : {}, how);
+            }
+            finally {
+                syncing = false;
+            }
+            out = { ...out, [part.name]: asValue(part.inner.form.getState().values) };
+        }
+        return out;
+    }
     /**
      * Values as they settle after a change: worked out, then set where a
      * condition started to hold, then worked out again from what was set — a
@@ -255,7 +512,7 @@ export function createForm(options) {
     }
     /** Write values someone or something changed. `fresh` values are a starting point instead (a restored draft). */
     function writeValues(written, extra = {}, fresh = false) {
-        const values = fresh ? startFrom(written) : settle(written);
+        const values = syncParts(fresh ? startFrom(written) : settle(written), fresh ? 'fresh' : 'edit');
         const errors = Object.keys(state.errors).length ? revalidateShown(values) : state.errors;
         set({ values, dirty: dirtyFields(values), errors, warnings: withValues(values, collectWarnings), ...extra });
     }
@@ -347,10 +604,10 @@ export function createForm(options) {
         // included; a stored one sends only what changed since it was loaded.
         const creating = state.recordId === null || state.recordId === undefined;
         const names = creating
-            ? Object.keys(page.fields).filter((name) => state.dirty.includes(name) || !isEmpty(page.fields[name], state.values[name]))
+            ? Object.keys(fields).filter((name) => state.dirty.includes(name) || !isEmpty(fields[name], state.values[name]))
             : state.dirty;
         for (const name of names) {
-            const def = page.fields[name];
+            const def = fields[name];
             const now = state.values[name];
             const before = creating ? emptyValue(def) : baseline[name];
             if (def.type === 'one2many')
@@ -369,13 +626,38 @@ export function createForm(options) {
             const name = node.field;
             shown[name] = structuredCopy(state.values[name]);
         }
+        // And each saved form shown, by its page: one not found shows nothing to answer.
+        for (const node of visibleFieldNodes(undefined, 'form')) {
+            const part = attached.get(node.id);
+            if (part)
+                shown[part.name] = structuredCopy(state.values[part.name]);
+        }
         return shown;
     }
-    async function save() {
+    async function save(chain = []) {
+        return (await saving(chain)) === null;
+    }
+    /**
+     * Save, or send: null once done, or why not. The page's `beforeSave` steps
+     * run first — before its own check, so they may fill in what it asks for —
+     * and a stop keeps it unsaved; `afterSave` runs once it is saved.
+     */
+    async function saving(chain) {
+        if (page.on?.beforeSave) {
+            const before = await moment('on.beforeSave', page.on.beforeSave, chain, false);
+            if (!before.done) {
+                // A check's problems, or an inner save's, are shown already; any other stop is this save's problem.
+                if (before.reason !== 'check' && before.reason !== 'save') {
+                    const problem = { kind: 'stopped', reason: before.reason, message: before.message ?? '' };
+                    set({ status: 'error', error: problem.message || null, saveProblem: problem });
+                }
+                return { reason: 'save', ...(before.message !== undefined ? { message: before.message } : {}) };
+            }
+        }
         const errors = collectErrors();
         if (Object.keys(errors).length) {
             set({ errors });
-            return false;
+            return { reason: 'save', message: Object.values(errors)[0] };
         }
         const source = options.dataSource;
         serverErrors = {};
@@ -384,33 +666,108 @@ export function createForm(options) {
             if (page.data.kind === 'responses') {
                 if (!source?.submit)
                     throw new Error('This page has no data source to send its answers to');
-                await source.submit({ pageId: page.id, values: shownValues() });
+                const sent = shownValues();
+                await source.submit({ pageId: page.id, values: sent });
                 forgetDraft();
                 set({ status: 'saved' });
-                return true;
+                emit('send', { values: sent });
+                void track(moment('on.afterSave', page.on?.afterSave, chain, false));
+                return null;
             }
             if (!source?.save)
                 throw new Error('This page has no data source to save to');
             const result = await source.save({
                 model: page.data.model,
                 id: state.recordId,
-                fields: page.fields,
+                fields,
                 changes: changes(),
                 values: structuredCopy(state.values),
             });
             forgetDraft();
-            const values = startFrom(result.values ? { ...state.values, ...result.values } : state.values);
+            // 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) });
-            return true;
+            emit('save', { recordId: state.recordId, values: state.values });
+            void track(moment('on.afterSave', page.on?.afterSave, chain, false));
+            return null;
         }
         catch (error) {
             const problem = saveProblemOf(error);
             const fields = problem.kind === 'fields' ? problem.fields ?? {} : {};
             serverErrors = Object.fromEntries(Object.entries(fields).map(([name, message]) => [name, { message, value: JSON.stringify(state.values[name] ?? null) }]));
             set({ status: 'error', error: problem.message, saveProblem: problem, errors: { ...fields } });
-            return false;
+            return { reason: 'save', message: problem.message };
+        }
+    }
+    /** The form has its values: told to the app, its `open` steps run, then the wizard step it shows is told. */
+    async function opening() {
+        emit('open', { recordId: state.recordId, values: state.values });
+        await moment('on.open', page.on?.open, [], true);
+        showing = true;
+        tellStep([]);
+    }
+    /** Write fields — a step's or the app's — worked out once, and tell each. */
+    function write(written, by) {
+        const names = Object.keys(written);
+        names.forEach(fieldDef);
+        if (!names.length)
+            return;
+        writeValues({ ...state.values, ...structuredCopy(written) });
+        for (const name of names)
+            afterEdit(name);
+        for (const name of names)
+            changed(name, by);
+    }
+    function addLine(field, values, by) {
+        const def = lineField(field);
+        const current = state.values[field] ?? [];
+        // 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');
+            line.values[def.sequenceField] = numbers.length ? Math.max(...numbers) + 1 : 1;
         }
+        const lines = [...current, line];
+        writeValues({ ...state.values, [field]: lines });
+        afterEdit(field);
+        changed(field, by);
+        return key;
+    }
+    /** Check the form, or only these fields, showing what is found as sending does. */
+    function check(names) {
+        names?.forEach(fieldDef);
+        const all = collectErrors();
+        const found = names ? Object.fromEntries(Object.entries(all).filter(([key]) => names.some((name) => key === name || key.startsWith(`${name}.`)))) : all;
+        set({ errors: found });
+        const first = Object.values(found)[0];
+        return first === undefined ? null : { reason: 'check', message: first };
+    }
+    /** Go to a wizard's step for a run; undefined when the target is no step of it, but a tab. */
+    function goToStep(target, chain) {
+        if (!steps.includes(target))
+            return undefined;
+        if (!form.steps().includes(target))
+            return { reason: 'cannot', message: `The step "${target}" does not apply now` };
+        let went = false;
+        inRun(chain, () => (went = form.goTo(target)));
+        return went ? null : { reason: 'check', message: Object.values(state.errors)[0] };
+    }
+    /** Run steps from the top — a button's, a moment's, the app's — and tell how it ended. */
+    async function runTop(list, scope) {
+        const result = await runner.runSteps(list, scope);
+        emit('run', { id: scope.id, steps: list, result });
+        return result;
     }
     /** The model a link field's new record belongs to, or null when it cannot make one. */
     function creatable(def) {
@@ -418,30 +775,26 @@ export function createForm(options) {
             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) {
@@ -457,7 +810,8 @@ export function createForm(options) {
     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;
@@ -465,16 +819,131 @@ export function createForm(options) {
             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: page.fields });
-            baseline = startFrom({ ...initialValues(page.fields, today()), ...loaded });
+            const loaded = await source.load({ model: page.data.model, id: state.recordId, fields });
+            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,
+        recordId: () => state.recordId,
+        reading,
+        today,
+        write: (values) => write(values, 'step'),
+        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,
+        host: options.host,
+        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,
@@ -484,14 +953,27 @@ export function createForm(options) {
             return () => listeners.delete(listener);
         },
         load: () => track(load()),
-        setValue(name, value) {
+        setValue(name, value, how) {
             fieldDef(name);
             writeValues({ ...state.values, [name]: structuredCopy(value) });
             afterEdit(name);
+            changed(name, how?.by ?? 'person');
         },
+        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.
@@ -513,24 +995,11 @@ export function createForm(options) {
             forgetDraft();
             serverErrors = {};
             holding = setWhen.holding(baseline);
-            set({ values: structuredCopy(baseline), dirty: [], errors: {}, warnings: withValues(baseline, collectWarnings), warning: null, warningField: null, draft: null, step: steps[0] ?? null, skipped: [], saveProblem: null });
+            const values = syncParts(structuredCopy(baseline), 'start');
+            set({ values, dirty: [], errors: {}, warnings: withValues(values, collectWarnings), warning: null, warningField: null, draft: null, step: steps[0] ?? null, skipped: [], saveProblem: null });
         },
         changes,
-        addLine(field, values = {}) {
-            const def = lineField(field);
-            const key = `new-${++lineKeys}`;
-            const current = state.values[field] ?? [];
-            const line = { key, values: { ...initialValues(def.fields, today()), ...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');
-                line.values[def.sequenceField] = numbers.length ? Math.max(...numbers) + 1 : 1;
-            }
-            const lines = [...current, line];
-            writeValues({ ...state.values, [field]: lines });
-            afterEdit(field);
-            return key;
-        },
+        addLine: (field, values = {}) => addLine(field, values, 'person'),
         updateLine(field, key, name, value) {
             const def = lineField(field);
             if (!def.fields[name])
@@ -538,6 +1007,7 @@ export function createForm(options) {
             const lines = (state.values[field] ?? []).map((line) => line.key === key ? { ...line, values: { ...line.values, [name]: structuredCopy(value) } } : line);
             writeValues({ ...state.values, [field]: lines });
             afterEdit(field);
+            changed(field, 'person');
         },
         moveLine(field, key, to) {
             const def = lineField(field);
@@ -567,15 +1037,25 @@ export function createForm(options) {
             });
             writeValues({ ...state.values, [field]: renumbered });
             afterEdit(field);
+            changed(field, 'person');
         },
         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);
@@ -583,16 +1063,16 @@ export function createForm(options) {
             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)
@@ -600,12 +1080,13 @@ export function createForm(options) {
             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)
@@ -678,16 +1159,100 @@ export function createForm(options) {
             if (!node || (node.kind !== 'button' && node.kind !== 'stat'))
                 throw new Error(`The page has no button "${id}"`);
             if (nodeState(id).invisible)
+                return { done: false, reason: 'cannot', message: `The button "${id}" is hidden` };
+            // 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) {
+            // A wizard's steps are told by the form itself, as they are entered.
+            if (steps.includes(tab))
                 return;
-            const source = node.source;
-            await track(Promise.resolve(options.onAction?.({
-                id,
-                action: source.action,
-                ...('params' in source && source.params ? { params: source.params } : {}),
-                recordId: state.recordId,
-                values: structuredCopy(state.values),
-                ...(chosen ? { recordIds: [...chosen.recordIds] } : {}),
-            })));
+            void track(moment(`on.show.${tab}`, page.on?.show?.[tab], entering, true));
+        },
+        on(event, listener) {
+            let heard = events.get(event);
+            if (!heard)
+                events.set(event, (heard = new Set()));
+            heard.add(listener);
+            return () => void heard.delete(listener);
         },
         restoreDraft() {
             const raw = options.drafts?.store.getItem(draftKey());
@@ -704,19 +1269,115 @@ export function createForm(options) {
             while (pending.size)
                 await Promise.allSettled([...pending]);
         },
+        embed(id, inner) {
+            const known = attached.get(id);
+            if (known)
+                return known.inner.form;
+            const part = parts.get(id);
+            if (!part)
+                throw new Error(`"${id}" is not a saved form placed on this page`);
+            const chain = [...within, page.id];
+            if (chain.includes(inner.id))
+                throw new Error(`a page cannot be placed inside itself: ${[...chain.slice(chain.indexOf(inner.id)), inner.id].join(' → ')}`);
+            const given = state.values[part.name];
+            // A record of no model of its own: its links search and its lists load, but it never loads, saves, sends or recalculates alone.
+            const made = innerForm({
+                page: { ...inner, data: { kind: 'responses' } },
+                dataSource: options.dataSource,
+                values: isRecord(given) ? given : {},
+                onAction: options.onAction,
+                host: options.host,
+                confirm: options.confirm,
+                scheduler,
+                messages,
+                now: options.now,
+            }, chain);
+            attached.set(id, { name: part.name, inner: made });
+            // A change inside it is told as a change of its answers here, whoever made it.
+            made.form.on('change', ({ by }) => {
+                if (!syncing)
+                    changed(part.name, by);
+            });
+            // A change made inside it is a change of this form's: shown, kept in a draft, saved.
+            made.form.subscribe((inside) => {
+                if (syncing || inside.values === state.values[part.name])
+                    return;
+                writeValues({ ...state.values, [part.name]: asValue(inside.values) });
+                afterEdit(part.name);
+            });
+            // What it starts with, its defaults and worked-out values filled in, is this form's starting point too — unless changed already.
+            const start = asValue(made.form.getState().values);
+            if (!state.dirty.includes(part.name))
+                baseline = { ...baseline, [part.name]: start };
+            const values = { ...state.values, [part.name]: start };
+            set({ values, dirty: dirtyFields(values) });
+            return made.form;
+        },
+        embedded: (id) => attached.get(id)?.inner.form ?? null,
         dispose() {
             if (draftTimer !== null)
                 scheduler.clearTimeout(draftTimer);
             if (autosaveTimer !== null)
                 scheduler.clearTimeout(autosaveTimer);
             listeners.clear();
+            events.clear();
+            for (const part of attached.values())
+                part.inner.form.dispose();
         },
     };
     // A record's starting values may already break a warning rule; nothing listens yet.
     state = { ...state, warnings: collectWarnings() };
     if (state.recordId == null)
         offerDraft();
-    return form;
+    // A new form has its values now: it opens once whoever made it has had the chance to listen.
+    if (state.recordId == null)
+        void track(Promise.resolve().then(opening));
+    return {
+        form,
+        take(values, how) {
+            if (how !== 'start')
+                return writeValues({ ...initialValues(page.fields, today()), ...values }, {}, how === 'fresh');
+            baseline = startFrom({ ...initialValues(page.fields, today()), ...structuredCopy(values) });
+            const start = syncParts(structuredCopy(baseline), 'start');
+            set({ values: start, dirty: [], errors: {}, warnings: withValues(start, collectWarnings), warning: null, warningField: null });
+        },
+        errorsNow: () => collectErrors(),
+        show(errors) {
+            if (JSON.stringify(errors) !== JSON.stringify(state.errors))
+                set({ errors });
+        },
+    };
+}
+/** The problems found inside a saved form, by its own fields' names. */
+function inside(errors, name) {
+    const found = {};
+    for (const [key, message] of Object.entries(errors))
+        if (key.startsWith(`${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) {
@@ -756,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),
@@ -771,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 });
@@ -786,6 +1452,9 @@ function indexLayout(root) {
                 add(node, parent, 'other', { invisible: node.invisible, readonly: node.readonly });
                 walk(node.children, node.id);
             }
+            else if (node.type === 'form') {
+                add(node, parent, 'form', { invisible: node.invisible, readonly: node.readonly });
+            }
             else {
                 add(node, parent, 'other', { invisible: node.invisible });
             }
@@ -805,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.
@@ -821,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