@fieldia/core 0.10.0 → 0.11.0

package/src/lib/record/form.mjs

@@ -9,6 +9,7 @@ import { expressionEnv } from './env.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';
 /**
  * The record state behind a page: values, what changed, what is visible and
@@ -16,6 +17,13 @@ import { emptyValue, expressionContext, initialValues, isEmpty, lineKind, struct
  * 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;
@@ -34,7 +42,20 @@ export function createForm(options) {
     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 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;
+    let baseline = computed.apply({ ...initialValues(fields, today()), ...structuredCopy(options.values ?? {}) });
     /** 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 = {
@@ -61,12 +82,25 @@ 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;
     /** 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.
@@ -75,6 +109,43 @@ export function createForm(options) {
                 if (fromList(name).dependsOn?.some((other) => was[other] !== state.values[other]))
                     loadChoices(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;
     function loadChoices(name) {
@@ -109,13 +180,13 @@ export function createForm(options) {
     }
     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);
@@ -138,8 +209,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 +228,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) {
@@ -229,8 +300,36 @@ export function createForm(options) {
                 }
             }
         }
+        // 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 +354,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 +446,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 +468,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 +508,98 @@ 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);
+            const values = syncParts(startFrom(result.values ? { ...state.values, ...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 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);
+        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) {
@@ -467,15 +656,35 @@ export function createForm(options) {
         }
         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 });
+            baseline = syncParts(startFrom({ ...initialValues(fields, today()), ...loaded }), 'start');
             set({ status: 'ready', values: structuredCopy(baseline), dirty: [], errors: {}, warnings: withValues(baseline, collectWarnings) });
             offerDraft();
+            void track(opening());
         }
         catch (error) {
             set({ status: 'error', error: error.message });
         }
     }
+    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,
+        reset: () => form.reset(),
+        goTo: goToStep,
+        showing: inRun,
+        host: options.host,
+        confirm: options.confirm,
+        onAction: options.onAction,
+        answered: (request, result) => emit('action', { request, result }),
+    });
+    const moment = createMoments((key, list, chain) => runTop(list, { id: key, chain }));
     const form = {
         page,
         getState: () => state,
@@ -484,11 +693,13 @@ 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,
         fieldReadonly: (name) => lockedField(fieldDef(name)),
         loadChoices,
@@ -513,24 +724,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 +736,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,12 +766,14 @@ export function createForm(options) {
             });
             writeValues({ ...state.values, [field]: renumbered });
             afterEdit(field);
+            changed(field, 'person');
         },
         removeLine(field, key) {
             lineField(field);
             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);
@@ -678,16 +879,36 @@ 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;
+                return { done: false, reason: 'cannot', message: `The button "${id}" is hidden` };
             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] } : {}),
-            })));
+            // 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);
+            })());
+        },
+        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;
+            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 +925,92 @@ 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;
 }
 /** A field no one types in: read-only by its definition, or worked out from others. */
 function lockedField(def) {
@@ -786,6 +1080,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 });
             }