@fieldia/core 0.26.1 → 0.28.0

package/src/lib/record/form.mjs

@@ -1,6 +1,10 @@
+import { changesOptions, hasOptionRules, optionRulesPart, optionsField, optionsList } from '../format/choice-options.mjs';
+import { fillValues } from '../format/words.mjs';
 import { upgradePage } from '../format/upgrade.mjs';
 import { zonedPage } from '../format/zoned.mjs';
 import { compileModifier } from '../expression/modifier.mjs';
+import { callsPartFunctions, functionsPart } from '../expression/functions.mjs';
+import { functionTable } from '../expression/app-functions.mjs';
 import { dayIn, ownZone } from './zones.mjs';
 import { checkProperties, checkValue } from './check.mjs';
 import { checkInput } from './inputs.mjs';
@@ -14,10 +18,14 @@ import { rolesAllow } from './roles.mjs';
 import { compileFieldTone, compileTable } from './cells.mjs';
 import { fillMessage, MESSAGES } from './messages.mjs';
 import { recordSentence } from './record-words.mjs';
+import { askKey, cellOf, listedColumns, notOffered } from './line-choices.mjs';
 import { loadedRecordOf, saveProblemOf, } from './data-source.mjs';
+import { formLimitsPart, hasLimits } from './taking.mjs';
+import { draftRead, resumeStep } from './drafts.mjs';
 import { waitingOn, workedOutFrom } from './waits.mjs';
 import { createUploads, fileBytesIn, uploadGoing, withoutFileBytes } from './uploads.mjs';
 import { hostScheduler } from './scheduler.mjs';
+import { signedBy } from './signed.mjs';
 import { createMoments, createRunner } from './run.mjs';
 import { emptyValue, initialValues, isEmpty, lineKind, structuredCopy, } from './values.mjs';
 /**
@@ -77,16 +85,53 @@ function innerForm(options, within, place, outer) {
     const page = zonedPage(options.page);
     const scheduler = options.scheduler ?? hostScheduler;
     // A field's label small inside a message's sentence where the page asks (`lowerLabels`).
-    const messages = page.lowerLabels ? { ...(options.messages ?? MESSAGES.en), lowerLabels: true } : (options.messages ?? MESSAGES.en);
+    // …and a day written in the page's order where it says one (`look.dateOrder`): "can't be after Oct 20, 2026".
+    const dateOrder = page.look?.dateOrder;
+    const messages = page.lowerLabels || dateOrder ? { ...(options.messages ?? MESSAGES.en), lowerLabels: page.lowerLabels, dateOrder } : (options.messages ?? MESSAGES.en);
     /** One of the form's sentences in the words the page names its records by (`records`), else as the language says it plainly. */
     const named = (noun, plain) => recordSentence(page.records, noun, plain, messages.locale);
-    const index = indexLayout(page.layout);
+    /** The app's functions the page's expressions call: a name none may call is refused now. */
+    const table = functionTable(options.functions);
+    /**
+     * The answers of the app's functions that ask, for the record shown (`ExpressionEnv.answer`), by function and
+     * values: each asked once, `asking` until it comes. Another record shown, they start again: an answer for the last
+     * one is laid on none.
+     */
+    let answers = new Map();
+    /** Those on their way: a save waits for them. */
+    const asking = new Set();
+    /** Everything the form waits on (`track`): there before the form's first values are worked out, which may ask. */
+    const pending = new Set();
+    function answer(key, asked) {
+        const kept = answers.get(key);
+        if (kept !== undefined || !asked)
+            return kept;
+        const map = answers;
+        map.set(key, 'asking');
+        const land = (found) => {
+            asking.delete(going);
+            if (map !== answers || disposed)
+                return;
+            map.set(key, found);
+            answered();
+        };
+        const going = Promise.resolve(asked).then((value) => land({ value: value === undefined ? null : value }), (error) => land({ value: null, failed: error instanceof Error ? error.message : String(error) }));
+        asking.add(going);
+        track(going);
+        return 'asking';
+    }
+    /**
+     * What every expression of the form is handed of the app's — and, on a page calling Fieldia's functions whose bodies
+     * come in the functions part before it has come, the answers they wait for it with, as an app's function that asks.
+     */
+    const app = table ? { functions: table, answer } : !functionsPart.loaded && callsPartFunctions(page) ? { answer } : {};
+    const index = indexLayout(page.layout, table);
     /** Each field node's answer rules, read once. */
     const nodeRules = new Map();
     for (const node of index.values()) {
         const rules = node.source.validate;
         if (node.kind === 'field' && rules)
-            nodeRules.set(node.id, compileRules(rules));
+            nodeRules.set(node.id, compileRules(rules, table));
     }
     /** Tables of lines with rules of their own, by their field node: each read once. */
     const tables = new Map();
@@ -95,14 +140,14 @@ function innerForm(options, within, place, outer) {
         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) });
+            tables.set(node.id, { field: source.field, compiled: compileTable(source, table) });
     }
     /** 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));
+            fieldTones.set(node.id, compileFieldTone(source, table));
     }
     /** 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();
@@ -130,7 +175,7 @@ function innerForm(options, within, place, outer) {
     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) })) });
+            placeholders.set(id, { fixed: own.placeholder, when: own.placeholderWhen.map((item) => ({ text: item.text, holds: compileModifier(item.when, table) })) });
     };
     for (const node of index.values())
         if (node.kind === 'field' && 'type' in node.source)
@@ -140,9 +185,11 @@ function innerForm(options, within, place, outer) {
     /** 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 storeKey = () => `fieldia:draft:${page.id}:${state.recordId ?? 'new'}`;
     /** Today, on the clock of the page's time zone (the browser's own when it names none). */
     const today = () => dayIn(options.now?.() ?? new Date(), page.timeZone);
+    /** Whether a field's own words — a label, a choice's — show a value: found once, so a page with none checks as before. */
+    const worded = /\{[A-Za-z_]\w*(\|[^{}]*)?\}/.test(JSON.stringify(page.fields));
     const clock = () => (options.now?.() ?? new Date()).getTime();
     /** What a page's bot check saw — its hidden box filled, the captcha's token — and when the page was shown or started again. */
     let bot = { honeypot: false, captcha: null, since: clock() };
@@ -162,10 +209,10 @@ function innerForm(options, within, place, outer) {
     /** Whether the record is being edited now: not while a view locks it, nor when its source lets the person only read it. */
     const editingNow = () => editing && !(started && state.can?.edit === false);
     const about = () => ({ recordId: started ? state.recordId : (options.recordId ?? null), user: options.user, editing: editingNow(), context: options.context, parent: parentContext });
-    const computed = compileComputed(page, today, about);
+    const computed = compileComputed(page, today, about, app);
     /** Each value worked out from others — by the page, or by the app as the lines change — and what it waits for. */
-    const workedOut = workedOutFrom(page, !!options.dataSource?.onchange && page.data.kind === 'record', !!options.parent);
-    const setWhen = compileSetWhen(page, today, about);
+    const workedOut = workedOutFrom(page, !!options.dataSource?.onchange && page.data.kind === 'record', !!options.parent, table);
+    const setWhen = compileSetWhen(page, today, about, app);
     /** 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())
@@ -217,7 +264,7 @@ function innerForm(options, within, place, outer) {
         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))));
+            Object.assign(values, firstValues(page.fields, mapScope(values, page.fields, recordContext(values, page.fields, about), expressionEnv(values, page.fields, today, app))));
         }
         return given ? ordered({ ...values, ...structuredCopy(options.values ?? {}) }) : values;
     }
@@ -246,7 +293,7 @@ function innerForm(options, within, place, outer) {
     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 });
+        return mapScope(values, lineFields, lineContext(values, lineFields, reading().context), { ...app, today }, { values: state.values, fields: page.fields });
     }
     function tableOf(nodeId) {
         const table = tables.get(nodeId);
@@ -266,7 +313,7 @@ function innerForm(options, within, place, outer) {
         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);
+        return table.compiled.line(lineContext(line.values, def.fields, reading().context, line.id ?? null), { ...app, today }, userRoles);
     }
     function createValuesOf(field, line) {
         if (!line) {
@@ -279,7 +326,9 @@ function innerForm(options, within, place, outer) {
             return {};
         return readLooseMap(sub.createValues, lineScope(line.lines, found.values));
     }
-    let baseline = computed.apply(startingValues());
+    /** The values worked out from an app's function that asks with no answer yet, as the values shown last settled. */
+    let askedNow = new Map();
+    let baseline = computed.apply(startingValues(), askedNow);
     /** 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 = {
@@ -306,6 +355,12 @@ function innerForm(options, within, place, outer) {
         unsent: [],
         leaving: false,
         unread: {},
+        sent: null,
+        asked: Object.fromEntries(askedNow),
+        takenOut: {},
+        // Worked out once the form has its state, as the limits part comes (`limitsCode`).
+        limits: null,
+        resume: null,
     };
     started = true;
     /**
@@ -478,7 +533,6 @@ function innerForm(options, within, place, outer) {
     let onchangeSeq = 0;
     let draftTimer = null;
     let autosaveTimer = null;
-    const pending = new Set();
     const listeners = new Set();
     /** The app's listeners, by event. */
     const events = new Map();
@@ -492,10 +546,30 @@ function innerForm(options, within, place, outer) {
     const userRoles = [...(options.user?.roles ?? [])];
     /** The latest load of each field's choices: an answer to an older one is let go. */
     const choiceLoads = {};
+    /** The tables' columns whose choices are the app's: none on most pages, and then nothing below is followed. */
+    const listed = listedColumns(page.fields);
+    /** Whether the values set now are a change someone made (`writeValues`), after which a line's choice no longer offered is cleared. */
+    let edit = false;
     function set(patch) {
         const was = state.values;
+        const choicesWas = state.choices;
         const shown = state.errors;
+        const edited = edit;
+        edit = false;
+        const stepWas = state.step;
         state = { ...state, ...patch };
+        // A line's choices go with their line.
+        if (state.values !== was)
+            state = { ...state, choices: choicesNow(state.choices) };
+        // What was said taken out is said while it is true: an option offered again, or picked again, is said no more.
+        if ((state.values !== was || state.choices !== choicesWas) && Object.keys(state.takenOut).length) {
+            const takenOut = takenOutTrue();
+            if (takenOut !== state.takenOut)
+                state = { ...state, takenOut };
+        }
+        // What waits for an app's answer, as the values shown last settled.
+        if (patch.values !== undefined && patch.asked === undefined && !sameAsked(state.asked, askedNow))
+            state = { ...state, asked: Object.fromEntries(askedNow) };
         // The person's changes the last save did not send, worked out again from the values as they are now, and from the
         // text they left that does not read.
         if (patch.unsent === undefined && (patch.values !== undefined || patch.unread !== undefined)) {
@@ -511,15 +585,21 @@ function innerForm(options, within, place, outer) {
             listener(state);
         // Choices that change with a value that just changed are asked for again.
         if (state.values !== was) {
+            // After someone's change, a choice its new choices do not offer is taken out and said, as a line's is.
             for (const name in state.choices)
-                if (fromList(name).dependsOn?.some((other) => was[other] !== state.values[other]))
-                    loadChoices(name);
+                if (!name.includes('.') && fromList(name)?.dependsOn?.some((other) => was[other] !== state.values[other]))
+                    loadChoices(name, edited);
             for (const name in state.definitions)
                 if (fromRecord(name).dependsOn?.some((other) => was[other] !== state.values[other]))
                     loadDefinitions(name);
+            if (listed.length)
+                followLines(was, edited);
         }
         if (showing && state.step !== told)
             tellStep(entering);
+        // A wizard's step entered with answers typed is kept in the draft, so it opens there again.
+        if (state.step !== stepWas && showing && state.dirty.length)
+            scheduleDraft();
     }
     function emit(event, payload) {
         const heard = events.get(event);
@@ -542,6 +622,9 @@ function innerForm(options, within, place, outer) {
     /** Another record is shown: nothing of the last one's is the person's work any more, and its files on their way stop. */
     function newGeneration() {
         generation++;
+        // Another record's lines ask the source anew.
+        lineAsks = new Map();
+        answers = new Map();
         personal.clear();
         personalLines.clear();
         filed.clear();
@@ -666,16 +749,129 @@ function innerForm(options, within, place, outer) {
             entering = was;
         }
     }
-    const fromList = (name) => page.fields[name].optionsFrom;
-    function loadChoices(name) {
-        const { list } = fromList(name);
+    /** The app's list a choice's options come from; none for one whose options are its own or carried. */
+    const fromList = (name) => optionsList(page.fields[name]?.optionsFrom);
+    // ---- a table line's choices from the app's lists (line-choices.ts) ----------------------------------------------
+    /** A line's choices asked of the source, by what they are asked by (`askKey`), for the record shown: lines alike share one. */
+    let lineAsks = new Map();
+    /** What each line cell's choices were last asked by. */
+    const askedBy = new Map();
+    const listedAt = (table, column) => listed.find((one) => one.table === table && one.column === column);
+    const lineAt = (table, key) => (state.values[table] ?? []).find((line) => line.key === key);
+    /** A line's choices from the source: asked once for every line whose columns they change with hold the same values. */
+    function askLine(one, values) {
+        const key = askKey(one, values, state.values);
+        const asks = lineAsks;
+        let ask = asks.get(key);
+        if (ask)
+            return ask;
+        const source = options.dataSource;
+        const request = { list: one.list, values: structuredCopy(values), parent: structuredCopy(state.values) };
+        ask = source?.options ? source.options(request) : Promise.reject(new Error(`No list "${one.list}"`));
+        asks.set(key, ask);
+        // One that failed is asked again next time.
+        ask.catch(() => asks.get(key) === ask && asks.delete(key));
+        return ask;
+    }
+    /** The choices as the values are now: a line's go with their line. */
+    function choicesNow(choices) {
+        let kept = null;
+        for (const path of Object.keys(choices)) {
+            if (valueAt(state.values, path) !== gone)
+                continue;
+            kept ??= { ...choices };
+            delete kept[path];
+            askedBy.delete(path);
+        }
+        return kept ?? choices;
+    }
+    /**
+     * Values changed: each line's choices loaded are asked again where what they change with changed on their line (a
+     * record shown with the same line, Discard, a draft); after a change someone made (`edited`), judged too — and so is a
+     * line holding a choice whose choices nobody asked for yet, so none is kept that its columns no longer offer.
+     */
+    function followLines(was, edited) {
+        // Choices that change with nothing are asked once.
+        for (const one of listed.filter((column) => column.own.length || column.parent.length)) {
+            for (const line of state.values[one.table] ?? []) {
+                const path = `${one.table}.${line.key}.${one.column}`;
+                const by = askKey(one, line.values, state.values);
+                const old = !(path in state.choices) && edited && !isEmpty(one.def, line.values[one.column]) && (was[one.table] ?? []).find((l) => l.key === line.key);
+                if (path in state.choices ? by !== askedBy.get(path) : old && by !== askKey(one, old.values, was))
+                    loadChoices(path, edited);
+            }
+        }
+    }
+    /**
+     * Load a field's choices, or a line cell's by its path (`table.key.column`). `judge`, after a change someone made of
+     * what they change with: a choice they no longer offer is taken out and said, on the record they were asked for,
+     * while a line still asks by the same.
+     */
+    function loadChoices(name, judge = false) {
+        const cell = cellOf(name);
+        const one = cell && listedAt(cell.table, cell.column);
+        const line = cell && lineAt(cell.table, cell.key);
+        if (cell && (!one || !line))
+            throw new Error(`"${name}" is no line's choice from the app's lists`);
+        const from = one ?? fromList(name);
+        if (!from)
+            throw new Error(`"${name}" takes no choices from the app's lists`);
+        const { list } = from;
         const load = (choiceLoads[name] = (choiceLoads[name] ?? 0) + 1);
-        const put = (choices) => load === choiceLoads[name] && set({ choices: { ...state.choices, [name]: choices } });
+        const by = one && line ? askKey(one, line.values, state.values) : '';
+        if (cell)
+            askedBy.set(name, by);
+        // A line's answer lands while its line is there.
+        const put = (choices) => load === choiceLoads[name] && (!cell || name in state.choices) && set({ choices: { ...state.choices, [name]: choices } });
         // What was shown stays while the next ones load, so the list does not flash empty.
         const shown = state.choices[name]?.options ?? null;
-        put({ options: shown, loading: true });
+        const loading = { options: shown, loading: true };
+        // A line's cell asks first as it is drawn, inside its table's drawing: told with the next change, never drawn again
+        // inside it. Asked again, as a column they change with changes, it says it is loading at once.
+        if (cell && !(name in state.choices))
+            state = { ...state, choices: { ...state.choices, [name]: loading } };
+        else
+            set({ choices: { ...state.choices, [name]: loading } });
         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 onRecord = shownNow();
+        const ask = one && line
+            ? askLine(one, line.values)
+            : source?.options
+                ? // A line's own form (a dialog) asks as its line does: the record it is on as parent.
+                    source.options({ list, values: structuredCopy(state.values), ...(options.parent ? { parent: structuredCopy(options.parent.values) } : {}) })
+                : Promise.reject(new Error(`No list "${list}"`));
+        void track(ask.then((loaded) => {
+            if (load !== choiceLoads[name])
+                return;
+            const now = cell && lineAt(cell.table, cell.key);
+            const held = !cell ? state.values[name] : now && askKey(one, now.values, state.values) === by ? now.values[cell.column] : null;
+            const lost = judge && onRecord() ? notOffered(one?.def ?? page.fields[name], held, loaded) : [];
+            // Taken out and said: the words stay until its value changes again.
+            if (lost.length)
+                clearChoices(cell ? cell.table : name, cell, lost, namedChoices(lost, shown, loaded));
+            put({ options: loaded });
+            // Options of the app's list with places, never counted yet: how many took each is asked.
+            if (!cell && loaded.some((option) => option.seats !== undefined) && (!limitsKit || limitsKit.uncounted(name)))
+                void track(limitsCode().then((kit) => kit?.ask()));
+        }, (error) => put({ options: shown, error: error.message ?? String(error) })));
+    }
+    /** Choices by their labels, as the choices shown before or now name them. */
+    const namedChoices = (lost, shown, loaded) => lost.map((value) => [...(shown ?? []), ...loaded].find((option) => option.value === value)?.label ?? String(value));
+    /**
+     * A choice — a field's, or a line's (`key`) column — less what its choices no longer offer, worked out from someone's
+     * change, and said as every choice taken out is (`FormState.takenOut`): their claim stays.
+     */
+    function clearChoices(field, line, lost, labels) {
+        const without = (value) => (Array.isArray(value) ? value.filter((v) => !lost.includes(v)) : null);
+        const values = state.values;
+        const written = line
+            ? (values[field] ?? []).map((l) => (l.key === line.key ? { ...l, values: { ...l.values, [line.column]: without(l.values[line.column]) } } : l))
+            : without(values[field]);
+        const path = line ? `${field}.${line.key}.${line.column}` : field;
+        takenOutOf.set(path, lost.map((value, i) => ({ value, label: labels[i] })));
+        writeValues({ ...values, [field]: written }, {}, false, { [path]: takenOutWords(labels) });
+        afterEdit(field);
+        changed(field, 'step', { keep: true });
     }
     const fromRecord = (name) => page.fields[name].definitionsFrom;
     const definitionLoads = {};
@@ -695,8 +891,23 @@ function innerForm(options, within, place, outer) {
         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. */
+    /**
+     * A field as its value is checked: a list's choices are those loaded, and until they are, any choice may be one; its
+     * label and its choices' words with their `{field}`s filled in, as the page shows them.
+     */
     function checked(name) {
+        const def = checkedAsLoaded(name);
+        return worded ? shownWords(def) : def;
+    }
+    /** A field whose words show values — its label, its choices' — with them filled in now, else as it is. */
+    function shownWords(def) {
+        const options = def.type === 'selection' && def.options.some((option) => option.label.includes('{')) ? def.options.map((option) => ({ ...option, label: wordsNow(option.label) })) : null;
+        if (!def.label.includes('{') && !options)
+            return def;
+        return { ...def, label: wordsNow(def.label), ...(options ? { options } : {}) };
+    }
+    /** A field as its value is checked, its choices those loaded from the app's list. */
+    function checkedAsLoaded(name) {
         const def = page.fields[name];
         const loaded = state.choices[name]?.options;
         if (def.type === 'properties' && def.definitionsFrom) {
@@ -704,7 +915,105 @@ function innerForm(options, within, place, outer) {
             const definitions = state.definitions[name]?.definitions;
             return definitions ? { ...def, definitions } : def;
         }
-        return def.type === 'selection' && def.optionsFrom && loaded ? { ...def, options: loaded, optionsFrom: undefined } : def;
+        // Carried from an earlier question: any of its options, and its own after them, is one of this one's.
+        if (def.type === 'selection' && optionsField(def.optionsFrom))
+            return { ...def, options: everyOption(name), optionsFrom: undefined };
+        return def.type === 'selection' && optionsList(def.optionsFrom) && loaded ? { ...def, options: loaded, optionsFrom: undefined } : def;
+    }
+    /** Every option a choice may hold, whatever its conditions: its own, its list's once loaded, or those of the question it carries them from and its own. */
+    function everyOption(name, seen = []) {
+        const def = page.fields[name];
+        if (def?.type !== 'selection')
+            return [];
+        const carried = optionsField(def.optionsFrom);
+        if (carried && !seen.includes(carried.field))
+            return [...everyOption(carried.field, [...seen, name]).filter((o) => !o.exclusive), ...def.options];
+        return [...((fromList(name) && state.choices[name]?.options) || def.options)];
+    }
+    // ---- options by condition, and carried from an earlier question (the options part: option-rules.ts) -----------
+    /** The options' rules made for this form from the options part, once it came: none before, nor on a page with none. */
+    let optionKit = null;
+    /**
+     * The options' rules, made from their part as it comes — at once where it has come — or null on a page with none, or
+     * where the part could not come. Values written before they came are judged as they come: a chosen option the values
+     * no longer offer, since the form was made, is taken out and said.
+     */
+    function optionsCode() {
+        if (optionKit || !hasOptionRules(page))
+            return Promise.resolve(optionKit);
+        if (optionRulesPart.loaded)
+            return Promise.resolve(optionsMade(optionRulesPart.loaded));
+        const from = state.values;
+        return optionRulesPart.load().then((part) => {
+            const kit = optionsMade(part);
+            if (kit && !disposed && state.values !== from)
+                writeValues(state.values, {}, false, {}, from);
+            return kit;
+        }, () => null);
+    }
+    function optionsMade(part) {
+        optionKit ??= part.optionRules({ page, table, app, state: () => state, today, about, reading, settle, words: (labels) => takenOutWords(labels) });
+        return optionKit;
+    }
+    if (hasOptionRules(page))
+        void track(optionsCode());
+    /** A table line's choice's options as they are offered on that line: its list's once loaded, or its own, by their conditions once they came. */
+    function lineOffered(lines, line, column, record) {
+        if (optionKit)
+            return optionKit.lineOffered(lines, line, column, record);
+        const sub = page.fields[lines].fields[column];
+        return [...((optionsList(sub.optionsFrom) && state.choices[`${lines}.${line.key}.${column}`]?.options) || sub.options)];
+    }
+    /** Options in words, as a sentence joins them: "Garden and Pool". */
+    function listedLabels(labels) {
+        try {
+            return new Intl.ListFormat(messages.locale, { type: 'conjunction' }).format(labels);
+        }
+        catch {
+            return labels.join(', ');
+        }
+    }
+    /**
+     * What is said of options taken out of an answer, by their labels — an answer they show (`{branch}`) as it reads now:
+     * "Garden is no longer offered, so it was taken out".
+     */
+    const takenOutWords = (labels) => fillMessage(messages, labels.length > 1 ? messages.notOfferedNowMany : messages.notOfferedNow, { name: listedLabels(labels.map((label) => (label.includes('{') ? wordsNow(label) : label))) });
+    /** The options each note of `takenOut` names, by its path: a note goes once none of them is still out. */
+    const takenOutOf = new Map();
+    /**
+     * The notes of options taken out (`FormState.takenOut`) that are still true for the values and the choices now: one
+     * whose options are all offered again — the type that offers them picked again, the treatment ticked again above, the
+     * app's list asked again offering it — or picked again goes; one with some still out names those. A list being asked
+     * again says nothing yet. The same notes, when none changed.
+     */
+    function takenOutTrue() {
+        let kept = null;
+        for (const path of Object.keys(state.takenOut)) {
+            const options = takenOutOf.get(path);
+            const held = valueAt(state.values, path);
+            if (!options || held === gone || state.choices[path]?.loading)
+                continue;
+            const offered = form.offered(path);
+            if (!offered)
+                continue;
+            const chosen = [held].flat();
+            const left = options.filter((option) => !chosen.includes(option.value) && !offered.some((one) => one.value === option.value));
+            if (left.length === options.length)
+                continue;
+            kept ??= { ...state.takenOut };
+            if (left.length) {
+                takenOutOf.set(path, left);
+                kept[path] = takenOutWords(left.map((option) => option.label));
+            }
+            else
+                delete kept[path];
+        }
+        return kept ?? state.takenOut;
+    }
+    /** A line's field as its value is checked: its choices from the app's list, those loaded for its line. */
+    function checkedLine(path, def) {
+        const loaded = def.type === 'selection' && optionsList(def.optionsFrom) ? state.choices[path]?.options : null;
+        return loaded ? { ...def, options: loaded, optionsFrom: undefined } : def;
     }
     /** A properties field's problems, each at its property's path (`field.property`), as its row shows them. */
     function propertyProblems(name) {
@@ -723,12 +1032,57 @@ function innerForm(options, within, place, outer) {
         promise.then(done, done);
         return promise;
     }
+    /**
+     * Words with each `{field}` showing the value `values` hold (the form's now, unless given), as the app's viewer
+     * writes it (`valueWords`), else plainly; `other` answers a name first (an ending's `{id}`). A name that is no field
+     * shows nothing.
+     */
+    function wordsNow(text, values = state.values, other) {
+        if (!text.includes('{'))
+            return text;
+        return fillValues(text, (name) => {
+            const own = other?.(name);
+            if (own !== undefined)
+                return own;
+            const def = page.fields[name];
+            if (!def)
+                return '';
+            return options.valueWords ? options.valueWords(def, values[name], values) : wordsOfValue(def, values[name]);
+        });
+    }
+    /**
+     * Each ending's condition, read once — with Fieldia's functions and the app's own, as every condition of the page —
+     * null for the default (no `when`), and one that does not read never holds.
+     */
+    const endingConditions = (page.endings ?? []).map((ending) => {
+        if (ending.when === undefined)
+            return null;
+        try {
+            return compileModifier(ending.when, table);
+        }
+        catch {
+            return compileModifier(false);
+        }
+    });
+    /** The ending for the response sent: the first whose condition holds on it — its answers, what the source added, its id — else the default. */
+    function endingNow() {
+        const sent = state.sent;
+        const endings = page.endings;
+        if (!sent || !endings?.length)
+            return null;
+        const values = sent.values;
+        const context = recordContext(values, page.fields, { ...about(), recordId: sent.id });
+        // An app's function that asks its server is asked as any condition asks it: it holds once answered.
+        const env = expressionEnv(values, page.fields, today, app);
+        const at = endingConditions.findIndex((condition) => !condition || condition.evaluate(context, env));
+        return at === -1 ? null : endings[at];
+    }
     /** 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 || contextCache.recordId !== state.recordId || contextCache.editing !== editingNow()) {
             const values = state.values;
             const context = recordContext(values, page.fields, about());
-            contextCache = { values, recordId: state.recordId, editing: editingNow(), context, env: expressionEnv(values, page.fields, today) };
+            contextCache = { values, recordId: state.recordId, editing: editingNow(), context, env: expressionEnv(values, page.fields, today, app) };
         }
         return contextCache;
     }
@@ -766,6 +1120,10 @@ function innerForm(options, within, place, outer) {
             if ((node.kind === 'field' || node.kind === 'form') && (can.edit === false || (node.field !== undefined && can.readonlyFields?.includes(node.field) === true)))
                 readonly = true;
         }
+        // An answer a signature kept signed: locked until the signature is taken away and signed again.
+        const answer = answerOf(node);
+        if (answer !== undefined && signedNow().has(answer))
+            readonly = true;
         return {
             invisible,
             readonly: readonly || (def !== undefined && lockedField(def)),
@@ -773,6 +1131,17 @@ function innerForm(options, within, place, outer) {
             ...(node.pressed ? { pressed: node.pressed.evaluate(ctx, env) } : {}),
         };
     }
+    /** The answer a field node shows, by its field — or a saved form placed on the page, by the name its answers are kept under. */
+    function answerOf(node) {
+        return node.kind === 'field' ? node.field : node.kind === 'form' ? node.source.name : undefined;
+    }
+    /** The answers signatures signed, as the values hold them now: worked out once for each change of the values. */
+    let signedCache = null;
+    function signedNow() {
+        if (signedCache?.values !== state.values)
+            signedCache = { values: state.values, answers: signedBy(page, state.values) };
+        return signedCache.answers;
+    }
     /** Field nodes — or saved forms placed on the page — inside `root` (or the whole page), visible right now; `field`'s alone, when named. */
     function visibleFieldNodes(root, kind = 'field', field) {
         const inside = (node) => {
@@ -801,7 +1170,7 @@ function innerForm(options, within, place, outer) {
             return {};
         const name = node.field;
         const def = page.fields[name];
-        const label = node.source.label ?? def.label;
+        const label = wordsNow(node.source.label ?? def.label);
         const { context: ctx, env } = reading();
         return checkRules(def, label, state.values[name], rules, { context: ctx, env, now: options.now?.() ?? new Date(), messages });
     }
@@ -814,10 +1183,35 @@ function innerForm(options, within, place, outer) {
     /** The widget a field is shown with where it keeps its value its own way (a per cent): the first of its nodes'. */
     const shownWidget = (shown) => shown.map((node) => node.source.widget).find((widget) => widget === 'percentage');
     /** A field node's error now: its field's own rules first, then its answer rules. */
+    /** A path's field's label: a field's, or a line's cell's (`field.lineKey.subfield`). */
+    function labelOfPath(path) {
+        const parts = path.split('.');
+        const def = page.fields[parts[0]];
+        if (parts.length >= 3 && def?.type === 'one2many')
+            return def.fields[parts[parts.length - 1]]?.label ?? path;
+        return def?.label ?? path;
+    }
     function nodeError(node) {
         const name = node.field;
         return unticked(node) ?? checkInput(page.fields[name], node.source, state.values[name], messages) ?? checkValue(checked(name), state.values[name], nodeState(node.id).required, messages, today(), node.source.widget) ?? ruleCheck(node).error;
     }
+    /** What a check would refuse now (`collectErrors`), for the state it was found for. */
+    let refusals = null;
+    /**
+     * Whether the form refuses the answer at a path — a field's, or a table line's cell (`field.lineKey.subfield`) — as a
+     * check would now: one it shows that holds a value its rules do not take (under its least, past today, a pattern not
+     * met, an answer rule's error). An empty answer is none, required or not: there is nothing worked out from it to wait.
+     */
+    function refusedAt(path) {
+        if (refusals?.state !== state)
+            refusals = { state, errors: collectErrors() };
+        if (!refusals.errors[path])
+            return false;
+        const parts = path.split('.');
+        const def = page.fields[parts[0]];
+        const held = valueAt(state.values, path);
+        return held !== gone && !isEmpty((parts.length > 2 && def?.type === 'one2many' ? def.fields[parts[parts.length - 1]] : def), held);
+    }
     /** Warnings for the visible fields of the page, without publishing them. */
     function collectWarnings() {
         const warnings = {};
@@ -862,7 +1256,7 @@ function innerForm(options, within, place, outer) {
             return undefined;
         const at = (v) => (def.type === 'datetime' ? Date.parse(v) : Date.parse(v.slice(0, 10)));
         if (at(value) < at(start))
-            return fillMessage(messages, messages.endBeforeStart, { end: def.label, start: page.fields[node.field].label });
+            return fillMessage(messages, messages.endBeforeStart, { end: wordsNow(def.label), start: wordsNow(page.fields[node.field].label) });
         return undefined;
     }
     /** Errors for the visible fields under `root`, without publishing them. */
@@ -900,7 +1294,7 @@ function innerForm(options, within, place, outer) {
                         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(), node.source.cells?.[sub]?.widget);
+                        const lineMessage = checkValue(checkedLine(`${name}.${line.key}.${sub}`, subDef), line.values[sub], subDef.required === true || cell?.required === true, messages, today(), node.source.cells?.[sub]?.widget);
                         if (lineMessage)
                             errors[`${name}.${line.key}.${sub}`] = lineMessage;
                     }
@@ -911,6 +1305,16 @@ function innerForm(options, within, place, outer) {
         for (const [path, unread] of Object.entries(state.unread))
             if (seen.has(path.split('.')[0]))
                 errors[path] = unread.message;
+        // A value an app's function is asked for answers for its field: still asked, or why it did not come.
+        for (const [path, found] of Object.entries(state.asked)) {
+            if (!seen.has(path.split('.')[0]) || errors[path])
+                continue;
+            const label = labelOfPath(path);
+            errors[path] = found.failed === undefined ? fillMessage(messages, messages.stillWorkedOut, { label }) : fillMessage(messages, messages.notWorkedOut, { label, problem: found.failed });
+        }
+        // A choice held whose places filled up since it was picked: never sent, said under it.
+        if (limitsKit)
+            Object.assign(errors, limitsKit.fullErrors(seen, errors));
         // 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);
@@ -935,6 +1339,13 @@ function innerForm(options, within, place, outer) {
         const line = (values[field] ?? []).find((l) => l.key === key);
         return line ? line.values[sub] : gone;
     }
+    /** A value — a field's, or a table line's by its cell's path — the same in both: a line that is gone, none. */
+    function sameAt(a, b, path) {
+        if (!path.includes('.'))
+            return a[path] === b[path];
+        const now = valueAt(a, path);
+        return now !== gone && JSON.stringify(now ?? null) === JSON.stringify(valueAt(b, path) ?? null);
+    }
     /** Unread text whose field has since been written another way — a value typed that reads, the app's — is let go. */
     function unreadKept(values) {
         let kept = null;
@@ -975,7 +1386,7 @@ function innerForm(options, within, place, outer) {
         const value = valueAt(state.values, path);
         if (!sub || value === gone || isEmpty(sub, value))
             return undefined;
-        return checkValue(sub, value, false, messages, today());
+        return checkValue(checkedLine(path, sub), value, false, messages, today());
     }
     /**
      * Answers changed from outside a saved form — loaded, put back, set — handed
@@ -1004,25 +1415,77 @@ function innerForm(options, within, place, outer) {
      * few rounds at most, so rules that set each other cannot run forever.
      */
     function settle(written) {
-        let values = computed.apply(written);
+        let asked = new Map();
+        let values = computed.apply(written, asked);
         for (let round = 0; round < 8; round++) {
             const result = setWhen.apply(values, holding);
             holding = result.holding;
             if (result.values === values)
                 break;
-            values = computed.apply(result.values);
+            asked = new Map();
+            values = computed.apply(result.values, asked);
         }
+        askedNow = asked;
         return values;
     }
     /** Values to start again from, as loaded or restored: conditions holding in them hold already, and set nothing. */
     function startFrom(values) {
-        const worked = computed.apply(values);
+        const asked = new Map();
+        const worked = computed.apply(values, asked);
+        askedNow = asked;
         holding = setWhen.holding(worked);
         return worked;
     }
-    /** Write values someone or something changed. `fresh` values are a starting point instead (a restored draft). */
-    function writeValues(written, extra = {}, fresh = false) {
-        const values = syncParts(fresh ? startFrom(written) : settle(written), fresh ? 'fresh' : 'edit');
+    /**
+     * An app's function answered: the values worked out again with its answer, and the record as loaded with them, so
+     * an answer is never a change of the person's. Values no one has changed start again from it — no rule starts to
+     * hold on what only came late — and changed ones settle as any change does.
+     */
+    function answered() {
+        baseline = computed.apply(baseline);
+        if (state.dirty.length)
+            return writeValues(state.values);
+        const values = startFrom(state.values);
+        set({ values, dirty: dirtyFields(values) });
+    }
+    /** Every answer on its way, and those that come of them, waited for: what a save does before it checks. */
+    async function asksSettled() {
+        while (asking.size)
+            await Promise.all([...asking]);
+    }
+    /** Answers that failed asked again — a save's try — and waited for. */
+    async function askAgain() {
+        let failed = false;
+        for (const [key, found] of answers) {
+            if (found === 'asking' || found.failed === undefined)
+                continue;
+            answers.delete(key);
+            failed = true;
+        }
+        if (failed)
+            writeValues(state.values);
+        await asksSettled();
+    }
+    /**
+     * Write values someone or something changed. `fresh` values are a starting point instead (a restored draft). `said`:
+     * options taken out of an answer by the write, by path, with their words (`FormState.takenOut`); `from`, the values
+     * those the write no longer offers were offered in (the form's now, unless said).
+     */
+    function writeValues(written, extra = {}, fresh = false, said = {}, from = state.values) {
+        let settled = fresh ? startFrom(written) : settle(written);
+        // A choice written again says no more what was taken out of it — a line's, nor once its line is gone; options a
+        // change no longer offers are taken out now.
+        let takenOut = fresh ? {} : { ...Object.fromEntries(Object.entries(state.takenOut).filter(([path]) => sameAt(written, state.values, path))), ...said };
+        const out = fresh || !optionKit ? null : optionKit.takeOut(from, settled);
+        if (out) {
+            settled = out.values;
+            takenOut = { ...takenOut, ...out.said };
+            for (const [path, gone] of Object.entries(out.gone))
+                takenOutOf.set(path, gone);
+        }
+        if (Object.keys(takenOut).length || Object.keys(state.takenOut).length)
+            extra = { takenOut, ...extra };
+        const values = syncParts(settled, fresh ? 'fresh' : 'edit');
         // Text left unread in a box goes once its field is written another way, and its words with it.
         const unread = unreadKept(values);
         const before = state;
@@ -1048,6 +1511,8 @@ function innerForm(options, within, place, outer) {
         }
         if (Object.keys(words).length)
             errors = { ...errors, ...words };
+        // A change someone made: a line's choice its columns no longer offer is cleared (followLines); a draft restored is none.
+        edit = !fresh;
         set({ values, dirty: dirtyFields(values), errors, warnings: withValues(values, collectWarnings), unread, ...extra });
     }
     /** Once errors are on screen, keep them current as the person fixes things. */
@@ -1070,24 +1535,84 @@ function innerForm(options, within, place, outer) {
                 kept[key] ??= unstoredNow[key];
         return kept;
     }
+    /**
+     * Whether drafts are kept on the app's server: its source keeps them, and the page offers "Continue later" (or the
+     * form continues one by its key). A page without either keeps its drafts where it always did.
+     */
+    const onServer = () => !!options.dataSource?.saveDraft && !!options.dataSource.loadDraft && (page.continueLater === true || !!options.resume);
+    /** Whether drafts are kept: the app gave a store, or they are kept on the server. */
+    const draftsOn = () => !!options.drafts || onServer();
+    /** The key of the draft kept on the server for the record shown; null until the source gave one. */
+    let serverKey = null;
+    /** Counted each time the draft is let go (sent, discarded, another record shown): a keeping answered after is dropped. */
+    let draftEpoch = 0;
+    /** The draft kept on the server last asked to be kept: the next waits for it, so it carries the key it gave. */
+    let draftGoing = Promise.resolve();
+    /** How many drafts are on their way to the server. */
+    let keeping = 0;
+    /** The draft found as the form opened, offered to restore (`state.draft`). */
+    let found = null;
+    /** The key the form was given to continue from (`resume`), until it is opened. */
+    let resumeKey = outer ? undefined : options.resume;
     function scheduleDraft() {
-        const drafts = options.drafts;
-        if (!drafts)
+        if (!draftsOn())
             return;
         if (draftTimer !== null)
             scheduler.clearTimeout(draftTimer);
         draftTimer = scheduler.setTimeout(() => {
             draftTimer = null;
-            // Where files are stored apart, never a file's bytes: they would fill the browser's store (uploads.ts). Without, kept as always.
-            // A store that is full anyway keeps no draft.
-            const values = options.dataSource?.upload ? draftOf(state.values) : state.values;
-            try {
-                drafts.store.setItem(draftKey(), JSON.stringify({ savedAt: new Date().toISOString(), values }));
-            }
-            catch {
-                // The draft is a convenience: the form goes on without it.
-            }
-        }, drafts.delayMs ?? 400);
+            // On the server, a failure is kept in the browser's store instead, where there is one: the form goes on.
+            void track(keepDraft(false).catch(() => keepHere(draftNow())));
+        }, options.drafts?.delayMs ?? (onServer() ? 1500 : 400));
+    }
+    /** The draft of what is typed now: the answers, the wizard's step and the steps passed over, text that does not read. */
+    function draftNow() {
+        // Where files are stored apart, never a file's bytes: they would fill the browser's store (uploads.ts). Without, kept as always.
+        const values = options.dataSource?.upload ? draftOf(state.values) : structuredCopy(state.values);
+        return {
+            values,
+            ...(steps.length ? { step: state.step, skipped: [...state.skipped] } : {}),
+            ...(Object.keys(state.unread).length ? { unread: structuredCopy(state.unread) } : {}),
+            answered: Object.keys(fields).filter((name) => state.dirty.includes(name)),
+            savedAt: new Date(clock()).toISOString(),
+        };
+    }
+    /** A draft in the browser's store, where the app gave one: a store that is full keeps none. */
+    function keepHere(kept) {
+        try {
+            options.drafts?.store.setItem(storeKey(), JSON.stringify(kept));
+        }
+        catch {
+            // The draft is a convenience: the form goes on without it.
+        }
+    }
+    /**
+     * Keep what is typed now: on the server where the source keeps drafts — one at a time, each carrying the key the last
+     * was given; its key in the browser's store — else in the browser's store. The server's answer, or null.
+     */
+    function keepDraft(later) {
+        const draft = draftNow();
+        const source = options.dataSource;
+        if (!onServer() || !source?.saveDraft) {
+            keepHere(draft);
+            return Promise.resolve(null);
+        }
+        const shown = shownNow();
+        const epoch = draftEpoch;
+        keeping++;
+        const going = draftGoing.then(() => source.saveDraft({ pageId: page.id, model: page.data.kind === 'record' ? page.data.model : '', recordId: state.recordId, key: epoch === draftEpoch ? serverKey : null, draft, ...(later ? { later } : {}) }));
+        draftGoing = going.then(() => void keeping--, () => void keeping--);
+        return going.then((saved) => {
+            // Kept for a record no longer shown, or for answers sent or let go meanwhile: the source has it; nothing is laid here.
+            if (!shown() || epoch !== draftEpoch)
+                return saved;
+            serverKey = saved.key;
+            if (state.resume?.key !== saved.key || state.resume.missing)
+                set({ resume: { key: saved.key } });
+            keepHere({ savedAt: draft.savedAt, key: saved.key });
+            emit('draft', { key: saved.key, savedAt: draft.savedAt, later, saved });
+            return saved;
+        });
     }
     /** The values with a draft's over them: a field it left out — a file's bytes — as the record holds it, in a saved form placed here too. */
     function withDraft(kept) {
@@ -1099,32 +1624,144 @@ function innerForm(options, within, place, outer) {
         }
         return values;
     }
+    /** A draft laid on the form: its answers as a starting point, its wizard step (or the nearest before it that applies), its text that does not read. */
+    function applyDraft(draft) {
+        found = null;
+        writeValues(withDraft(draft.values ?? {}), { draft: null }, true);
+        const known = (draft.skipped ?? []).filter((id) => steps.includes(id));
+        // Text typed that did not read stays as typed, said as it was, where its field is still on the page.
+        const unread = Object.fromEntries(Object.entries(draft.unread ?? {}).filter(([path]) => !!page.fields[path.split('.')[0]] && typeof draft.unread?.[path]?.text === 'string'));
+        const patch = {
+            ...(steps.length ? { skipped: known, step: resumeStep(steps, form.steps(), draft.step) } : {}),
+            ...(Object.keys(unread).length ? { unread: { ...state.unread, ...unread } } : {}),
+            // Its boxes were left with it: why each does not read is said at once, as it was where it was typed.
+            ...(Object.keys(unread).length ? { errors: { ...state.errors, ...Object.fromEntries(Object.entries(unread).map(([path, kept]) => [path, kept.message])) } } : {}),
+        };
+        if (Object.keys(patch).length)
+            set(patch);
+    }
     function forgetDraft() {
         if (draftTimer !== null)
             scheduler.clearTimeout(draftTimer);
         draftTimer = null;
-        options.drafts?.store.removeItem(draftKey());
+        found = null;
+        draftEpoch++;
+        serverKey = null;
+        if (state.resume)
+            set({ resume: null });
+        options.drafts?.store.removeItem(storeKey());
+    }
+    /** A draft found: laid at once (`restore: "auto"`, or a draft continued from its key over nothing typed), else offered. */
+    function offer(draft, auto = options.drafts?.restore === 'auto') {
+        // What the person typed while it was asked for is theirs: the draft is offered, never laid over it.
+        if (auto && !state.dirty.length && !Object.keys(state.unread).length)
+            return applyDraft(draft);
+        found = draft;
+        set({ draft: { savedAt: draft.savedAt } });
     }
+    /**
+     * The draft kept for the record shown, offered as it opens: the one the form was given to continue from (`resume`),
+     * else the browser's store's — on the server by its key, or in the store. A draft asked of the server is laid only
+     * on the record it was asked for.
+     */
     function offerDraft() {
-        const drafts = options.drafts;
-        if (!drafts)
+        const source = options.dataSource;
+        const given = resumeKey;
+        resumeKey = undefined;
+        const kept = given ? null : draftRead(options.drafts?.store.getItem(storeKey()) ?? null);
+        if (!given && !kept)
             return;
-        const raw = drafts.store.getItem(draftKey());
-        if (!raw)
+        if (kept && !('key' in kept))
+            return offer(kept);
+        const key = given ?? kept.key;
+        if (!source?.loadDraft || !onServer())
             return;
-        let draft;
-        try {
-            draft = JSON.parse(raw);
-        }
-        catch {
-            drafts.store.removeItem(draftKey());
-            return;
-        }
-        if (drafts.restore === 'auto')
-            writeValues(withDraft(draft.values), { draft: null }, true);
-        else
-            set({ draft: { savedAt: draft.savedAt } });
+        const shown = shownNow();
+        if (given)
+            set({ status: 'loading' });
+        return track(source.loadDraft({ pageId: page.id, key }).then((draft) => {
+            if (!shown())
+                return;
+            if (given)
+                set({ status: 'ready' });
+            if (!draft) {
+                // Sent, or gone: the form starts empty, and says so where it was asked to continue it.
+                options.drafts?.store.removeItem(storeKey());
+                if (given)
+                    set({ resume: { key, missing: true } });
+                return;
+            }
+            serverKey = key;
+            set({ resume: { key } });
+            offer(draft, given ? true : undefined);
+        }, (error) => {
+            if (shown() && given)
+                set({ status: 'error', error: error?.message ?? String(error) });
+        }));
+    }
+    // ---- when the page takes answers, and each choice's places (the limits part: form-limits.ts) --------------------
+    /** The limits made for this form from the limits part, once it came: none before, nor on a page with neither limits nor places. */
+    let limitsKit = null;
+    /** Whether the record shown was loaded once: its counts are asked then, its own choices not counted against it. */
+    let loadedOnce = false;
+    /** Whether the form keeps limits: a page with them or with places of its own, or a list's choices that came with places. */
+    const keepsLimits = () => !outer && (hasLimits(page) || Object.values(state.choices).some((choices) => choices.options?.some((option) => option.seats !== undefined)));
+    /**
+     * The limits, made from their part as it comes — at once where it has come — shown, and asked of the source as the
+     * form opens (or once its record is loaded); null where the form keeps none, or the part could not come: the source's
+     * submit decides then.
+     */
+    function limitsCode() {
+        if (limitsKit || !keepsLimits())
+            return Promise.resolve(limitsKit);
+        if (formLimitsPart.loaded)
+            return Promise.resolve(limitsMade(formLimitsPart.loaded));
+        return formLimitsPart.load().then(limitsMade, () => null);
+    }
+    function limitsMade(part) {
+        if (limitsKit || disposed)
+            return limitsKit;
+        const kit = part.formLimits({
+            page,
+            dataSource: options.dataSource,
+            user: options.user,
+            messages,
+            scheduler,
+            state: () => state,
+            set,
+            clock,
+            started: () => started,
+            shownNow,
+            generation: () => generation,
+            replaced: () => named(messages.recordReplacedNoun, messages.recordReplaced),
+            listened: () => listeners.size > 0,
+            disposed: () => disposed,
+            refuse(name, message) {
+                // Said until the field changes from what it holds, as a refused save's words are.
+                serverErrors[name] = { message, value: JSON.stringify(state.values[name] ?? null) };
+                set({ errors: { ...state.errors, [name]: message } });
+            },
+        });
+        limitsKit = kit;
+        kit.show();
+        if (kit.asks() && (state.recordId == null || loadedOnce))
+            void track(kit.ask());
+        return kit;
+    }
+    /** Ask the source's `limits` again and show what it tells; without the limits part, nothing to ask. */
+    const askLimits = () => (limitsKit ? limitsKit.ask() : Promise.resolve());
+    /** Whether the form asks the source for counts. */
+    const asksLimits = () => !!limitsKit?.asks();
+    /**
+     * Whether the page takes these answers now, asked of the source again just before they go — the limits part waited
+     * for where the form keeps limits: why not, as a save's problem, or null.
+     */
+    async function stillTaking(asked) {
+        const kit = await limitsCode();
+        return kit ? kit.stillTaking(asked) : null;
     }
+    /** A choice of a full option, picked by the person, refused under its field: the field keeps what it held. */
+    const refusedFull = (name, value) => !!limitsKit?.refusedFull(name, value);
     function scheduleAutosave() {
         const autosave = options.autosave;
         // A record the person may not change is never saved unasked: it would only be refused.
@@ -1265,6 +1902,20 @@ function innerForm(options, within, place, outer) {
             await waiting;
         if (asked !== generation)
             return elsewhere();
+        // Options by condition waited for where they have not come: what is saved never holds one they would take out.
+        if (!optionKit && hasOptionRules(page)) {
+            await optionsCode();
+            if (asked !== generation)
+                return elsewhere();
+        }
+        // Values the app's functions are asked for are waited for — those that failed asked again — so what is saved is worked out.
+        if (asking.size || Object.values(state.asked).some((found) => found.failed !== undefined)) {
+            set({ status: 'saving', error: null, saveProblem: null });
+            await askAgain();
+            if (asked !== generation)
+                return elsewhere();
+            set({ status: 'ready' });
+        }
         // Files still on their way are waited for first — a saved form's placed here too: the state says how many, so the page can say why it waits.
         if (filesGoing()) {
             set({ status: 'saving', error: null, saveProblem: null });
@@ -1286,6 +1937,10 @@ function innerForm(options, within, place, outer) {
                 return { reason: 'save', ...(before.message !== undefined ? { message: before.message } : {}) };
             }
         }
+        // Whether the page still takes answers — its dates, its counts asked again — and each choice held still has room.
+        const refused = await stillTaking(asked);
+        if (refused)
+            return refused;
         // A file that did not reach the store stops it, under its field, with the form's own checks.
         const errors = { ...collectErrors(), ...fileProblems() };
         if (Object.keys(errors).length) {
@@ -1295,6 +1950,13 @@ function innerForm(options, within, place, outer) {
         const source = options.dataSource;
         serverErrors = {};
         set({ status: 'saving', errors: {}, error: null, saveProblem: null, conflict: null });
+        // A draft being kept on the server goes first, so the send names the draft it ends; none is kept after it.
+        if (draftTimer !== null)
+            scheduler.clearTimeout(draftTimer);
+        draftTimer = null;
+        if (keeping)
+            await draftGoing;
+        const draft = serverKey ? { draft: serverKey } : {};
         /** The generation the record was in when this save went to the source. */
         let at = generation;
         try {
@@ -1313,8 +1975,10 @@ function innerForm(options, within, place, outer) {
                 const sent = shownValues();
                 const before = state.values;
                 at = generation;
+                const resetAt = resets;
                 const seen = botReport();
-                await source.submit({ pageId: page.id, values: sent, ...(seen ? { bot: seen } : {}) });
+                // What the source answered: the id it gave the response, and the values it added — what an ending reads.
+                const answer = (await source.submit({ pageId: page.id, values: sent, ...(seen ? { bot: seen } : {}), ...draft })) ?? {};
                 // The captcha's token is spent once sent: the next send waits for a new one.
                 if (seen?.captcha)
                     bot.captcha = null;
@@ -1324,8 +1988,13 @@ function innerForm(options, within, place, outer) {
                 forgetDraft();
                 // What it sent is what an answer changed since is told against: still to send.
                 sentAs = before;
-                set({ status: 'saved', unsent: unsentNow() });
+                const added = answer.values && typeof answer.values === 'object' ? structuredCopy(answer.values) : {};
+                // Started again meanwhile (`reset`): a new response is on screen, and no ending is the old one's.
+                set({ status: 'saved', unsent: unsentNow(), ...(resets === resetAt ? { sent: { id: answer.id ?? null, values: { ...structuredCopy(sent), ...added } } } : {}) });
                 emit('send', { values: sent, ...(seen ? { bot: seen } : {}) });
+                // Counted again: one response fewer to take, this person's sent.
+                if (asksLimits())
+                    void track(askLimits());
                 void track(moment('on.afterSave', page.on?.afterSave, chain, false));
                 return null;
             }
@@ -1343,6 +2012,7 @@ function innerForm(options, within, place, outer) {
                 values: sentValues(),
                 // The version it was opened at, for a source that refuses a save over someone else's.
                 ...(state.recordId != null && state.version ? { version: state.version } : {}),
+                ...draft,
             });
             // Answered for a record no longer shown — another opened, or this one loaded again: the source has it, and the
             // form lays nothing of it over the record it shows now.
@@ -1618,7 +2288,11 @@ function innerForm(options, within, place, outer) {
                 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), version: version ?? null, can: can ?? null, unread: {} });
+            set({ status: 'ready', values: structuredCopy(baseline), dirty: [], errors: {}, warnings: withValues(baseline, collectWarnings), version: version ?? null, can: can ?? null, unread: {}, takenOut: {} });
+            // Each choice's places, for this record: its own choices are its own.
+            loadedOnce = true;
+            if (asksLimits())
+                void track(askLimits());
             if (again)
                 return;
             offerDraft();
@@ -1647,7 +2321,11 @@ function innerForm(options, within, place, outer) {
         told = null;
         showing = false;
         clearFiles();
-        const fresh = { dirty: [], errors: {}, warning: null, warningField: null, error: null, draft: null, step: steps[0] ?? null, skipped: [], saveProblem: null, version: null, can: null, conflict: null, setAside: null, unsent: [], unread: {} };
+        // The draft kept for the record shown before is that one's.
+        found = null;
+        serverKey = null;
+        draftEpoch++;
+        const fresh = { dirty: [], errors: {}, warning: null, warningField: null, error: null, draft: null, step: steps[0] ?? null, skipped: [], saveProblem: null, version: null, can: null, conflict: null, setAside: null, unsent: [], unread: {}, takenOut: {}, resume: null };
         if (id != null) {
             set({ ...fresh, recordId: id, status: 'idle' });
             await load();
@@ -1657,6 +2335,8 @@ function innerForm(options, within, place, outer) {
         baseline = startFrom(startingValues(true, false));
         const values = syncParts(structuredCopy(baseline), 'start');
         set({ ...fresh, recordId: null, status: 'ready', values, warnings: withValues(values, collectWarnings) });
+        if (asksLimits())
+            void track(askLimits());
         offerDraft();
         await opening();
         return true;
@@ -2017,10 +2697,18 @@ function innerForm(options, within, place, outer) {
     }
     const form = {
         page,
+        ...(table ? { functions: table } : {}),
         getState: () => state,
         subscribe(listener) {
             listeners.add(listener);
-            return () => listeners.delete(listener);
+            // Listened to: the page opening or closing is said as it comes.
+            if (listeners.size === 1)
+                limitsKit?.heard(true);
+            return () => {
+                listeners.delete(listener);
+                if (!listeners.size)
+                    limitsKit?.heard(false);
+            };
         },
         load() {
             const go = letGo();
@@ -2028,6 +2716,9 @@ function innerForm(options, within, place, outer) {
         },
         setValue(name, value, how) {
             fieldDef(name);
+            // A choice whose places are all taken is shown, and refused when the person picks it: said under its field.
+            if ((how?.by ?? 'person') === 'person' && refusedFull(name, value))
+                return;
             writeValues({ ...state.values, [name]: structuredCopy(value) });
             afterEdit(name);
             changed(name, how?.by ?? 'person');
@@ -2053,13 +2744,38 @@ function innerForm(options, within, place, outer) {
             // Nothing of the record changed; what shows of it may have.
             set({});
         },
-        fieldReadonly: (name) => lockedField(fieldDef(name)) || state.can?.edit === false || state.can?.readonlyFields?.includes(name) === true,
-        loadChoices,
+        fieldReadonly: (name) => lockedField(fieldDef(name)) || state.can?.edit === false || state.can?.readonlyFields?.includes(name) === true || signedNow().has(name),
+        loadChoices: (field) => loadChoices(field),
         loadDefinitions,
         addDefinition,
+        lineChoices(field, key, subfield, values = {}) {
+            const one = listedAt(field, subfield);
+            const line = key === null ? one && { values: newLineValues(field) } : lineAt(field, key);
+            if (!one || !line)
+                throw new Error(`"${field}.${key}.${subfield}" is no line's choice from the app's lists`);
+            return track(askLine(one, { ...line.values, ...values }));
+        },
+        offered(name) {
+            const cell = cellOf(name);
+            if (!cell)
+                return page.fields[name]?.type === 'selection' ? (optionKit ? optionKit.offered(name, state.values, reading()) : everyOption(name)) : null;
+            const lines = page.fields[cell.table];
+            const line = lineAt(cell.table, cell.key);
+            return lines?.type === 'one2many' && lines.fields[cell.column]?.type === 'selection' && line ? lineOffered(cell.table, line, cell.column, reading().context) : null;
+        },
+        offersChange(name) {
+            const cell = cellOf(name);
+            const lines = cell ? page.fields[cell.table] : undefined;
+            return changesOptions(cell ? (lines?.type === 'one2many' ? lines.fields[cell.column] : undefined) : page.fields[name]);
+        },
         waitsFor(name) {
+            // What it is worked out from first: an answer that does not read, or that the form refuses, is never asked about.
             const from = workedOut.get(name);
-            return from ? waitingOn(page, from, state.values, state.unread) : null;
+            const waits = from ? waitingOn(page, from, state.values, state.unread, refusedAt) : null;
+            if (waits)
+                return waits;
+            const found = state.asked[name];
+            return found ? { field: name, asking: true, ...(found.failed !== undefined ? { failed: found.failed } : {}) } : null;
         },
         problem(name) {
             fieldDef(name);
@@ -2139,6 +2855,9 @@ function innerForm(options, within, place, outer) {
         save: () => track(save()),
         canUpload: () => typeof options.dataSource?.upload === 'function',
         today,
+        now: () => options.now?.() ?? new Date(),
+        user: () => options.user ?? null,
+        shownFields: () => [...new Set([...visibleFieldNodes(), ...visibleFieldNodes(undefined, 'form')].map((node) => answerOf(node)).filter((name) => !!name))],
         recordReads: (id, values, fields) => recordContext(values, fields ?? page.fields, { recordId: id, user: options.user, editing: false, context: options.context }),
         canFindSlots: () => typeof options.dataSource?.slots === 'function',
         findSlots(field, ask) {
@@ -2173,6 +2892,22 @@ function innerForm(options, within, place, outer) {
             const others = (matches ?? []).filter((match) => match && String(match.id) !== String(recordId));
             return others.every((match) => typeof match.score === 'number') ? others.sort((a, b) => b.score - a.score) : others;
         },
+        keepsNotDuplicates: () => !!(page.data.kind === 'record' && options.dataSource?.notDuplicates && options.dataSource.markNotDuplicate),
+        async notDuplicates() {
+            const [source, model] = recordSource('notDuplicates');
+            const recordId = state.recordId;
+            if (recordId === null)
+                return [];
+            const ids = await source.notDuplicates({ model, recordId });
+            return Array.isArray(ids) ? ids.filter((id) => (typeof id === 'string' || typeof id === 'number') && String(id) !== String(recordId)) : [];
+        },
+        async markNotDuplicate(matchId) {
+            const [source, model] = recordSource('markNotDuplicate');
+            const recordId = state.recordId;
+            if (recordId === null)
+                throw new Error('A new record has no id to keep it by');
+            await source.markNotDuplicate({ model, recordId, matchId });
+        },
         canMerge: () => !!(page.data.kind === 'record' && options.dataSource?.merge && options.dataSource.load),
         async readRecord(id) {
             const [source, model] = recordSource('load');
@@ -2213,7 +2948,19 @@ function innerForm(options, within, place, outer) {
             // Started again: a new response, timed from now.
             bot = { ...bot, honeypot: false, since: clock() };
             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, conflict: null, unsent: [], unread: {} });
+            set({ values, dirty: [], errors: {}, warnings: withValues(values, collectWarnings), warning: null, warningField: null, draft: null, step: steps[0] ?? null, skipped: [], saveProblem: null, conflict: null, unsent: [], unread: {}, takenOut: {}, sent: null });
+            // Started again: whether the page takes another response, and each choice's places, asked again.
+            if (asksLimits())
+                void track(askLimits());
+        },
+        words: (text) => wordsNow(text),
+        ending: endingNow,
+        endingWords(text) {
+            const sent = state.sent;
+            if (!sent)
+                return wordsNow(text);
+            // The response's id where the page has no field of that name: "Your booking is {id}".
+            return wordsNow(text, sent.values, (name) => (name === 'id' && !page.fields['id'] ? String(sent.id ?? '') : undefined));
         },
         changes,
         addLine: (field, values = {}) => addLine(field, values, 'person'),
@@ -2474,16 +3221,27 @@ function innerForm(options, within, place, outer) {
             return () => void heard.delete(listener);
         },
         restoreDraft() {
-            const raw = options.drafts?.store.getItem(draftKey());
-            if (!raw)
-                return;
-            const draft = JSON.parse(raw);
-            writeValues(withDraft(draft.values), { draft: null }, true);
+            const kept = found ?? draftRead(options.drafts?.store.getItem(storeKey()) ?? null);
+            if (kept && 'values' in kept)
+                applyDraft(kept);
         },
         discardDraft() {
             forgetDraft();
             set({ draft: null });
         },
+        canContinueLater: () => page.continueLater === true && onServer() && page.layout.type !== 'list',
+        async continueLater() {
+            if (!form.canContinueLater())
+                throw new Error('No continueLater, or no saveDraft and loadDraft');
+            // What is typed is read first, as a save reads it: text that does not read is kept as typed, said again as it opens.
+            await (readTyped() ?? Promise.resolve());
+            if (draftTimer !== null)
+                scheduler.clearTimeout(draftTimer);
+            draftTimer = null;
+            const saved = await track(keepDraft(true));
+            return saved;
+        },
+        refreshLimits: () => askLimits(),
         async reloadTheirs() {
             // A save on its way first: its answer is not dropped by the load.
             const asked = shownNow();
@@ -2610,6 +3368,8 @@ function innerForm(options, within, place, outer) {
                 scheduler,
                 messages,
                 now: options.now,
+                // Its words that show its answers read them as this form's do.
+                ...(options.valueWords ? { valueWords: options.valueWords } : {}),
             }, chain, 
             // Its files are the record's: stored for it, under the part's name.
             { model: where.model, recordId: where.recordId, under: `${where.under}${part.name}.` }, 
@@ -2653,6 +3413,7 @@ function innerForm(options, within, place, outer) {
                 scheduler.clearTimeout(draftTimer);
             if (autosaveTimer !== null)
                 scheduler.clearTimeout(autosaveTimer);
+            limitsKit?.dispose();
             listeners.clear();
             events.clear();
             for (const part of attached.values())
@@ -2661,11 +3422,16 @@ function innerForm(options, within, place, outer) {
     };
     // A record's starting values may already break a warning rule; nothing listens yet.
     state = { ...state, warnings: collectWarnings() };
-    if (state.recordId == null)
-        offerDraft();
-    // 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));
+    // When the page takes answers — at once where the limits part has come, else as soon as it does — its counts and each
+    // choice's places as the source tells them: a record's own once it is loaded, its own choices not counted against it.
+    if (keepsLimits())
+        void track(limitsCode());
+    // A new form has its values now — a draft continued from its key once it is laid — and opens once whoever made it
+    // has had the chance to listen.
+    if (state.recordId == null) {
+        const continued = offerDraft();
+        void track(Promise.resolve(continued).then(opening));
+    }
     return {
         form,
         take(values, how) {
@@ -2675,7 +3441,7 @@ function innerForm(options, within, place, outer) {
             filed.clear();
             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, unread: {} });
+            set({ values: start, dirty: [], errors: {}, warnings: withValues(start, collectWarnings), warning: null, warningField: null, unread: {}, takenOut: {} });
         },
         errorsNow: () => collectErrors(),
         typing: typingNow,
@@ -2699,6 +3465,8 @@ function innerForm(options, within, place, outer) {
 const sameHow = (a, b) => !!a.changes === !!b.changes && !!a.discard === !!b.discard;
 /** Two lists of names the same, in the same order. */
 const sameList = (a, b) => a.length === b.length && a.every((name, i) => name === b[i]);
+/** Whether what waits for an app's answer is the same as before: the same paths, each waiting or failed for the same reason. */
+const sameAsked = (shown, now) => Object.keys(shown).length === now.size && [...now].every(([path, found]) => shown[path] !== undefined && shown[path].failed === found.failed);
 /** A file on its way in a saved form placed in another, as that one names it: its id and its field under the part's name. */
 function underPart(name, upload) {
     return { ...upload, id: `${name}/${upload.id}`, ...(upload.line ? { line: { ...upload.line, field: `${name}.${upload.line.field}` } } : { field: `${name}.${upload.field}` }) };
@@ -2809,7 +3577,7 @@ function linkOps(before, now) {
         ...before.filter((r) => !has.has(r.id)).map((r) => ({ op: 'unlink', id: r.id })),
     ];
 }
-function indexLayout(root) {
+function indexLayout(root, functions) {
     const index = new Map();
     const add = (source, parent, kind, modifiers) => {
         const roles = source.roles;
@@ -2821,10 +3589,10 @@ function indexLayout(root) {
             kind,
             field: modifiers.field,
             ...(roles?.length ? { roles } : {}),
-            invisible: compileModifier(modifiers.invisible),
-            readonly: compileModifier(modifiers.readonly),
-            required: compileModifier(modifiers.required),
-            ...(pressed !== undefined ? { pressed: compileModifier(pressed) } : {}),
+            invisible: compileModifier(modifiers.invisible, functions),
+            readonly: compileModifier(modifiers.readonly, functions),
+            required: compileModifier(modifiers.required, functions),
+            ...(pressed !== undefined ? { pressed: compileModifier(pressed, functions) } : {}),
             ...(does.length ? { does } : {}),
             source,
         });