@fieldia/core 0.30.1 → 0.31.1

package/src/lib/record/form.mjs

@@ -22,13 +22,14 @@ import { askKey, cellOf, listedColumns, notOffered } from './line-choices.mjs';
 import { loadedRecordOf, saveProblemOf, } from './data-source.mjs';
 import { formLimitsPart, hasLimits } from './taking.mjs';
 import { formLanguagesPart, hasLanguages } from './languages.mjs';
-import { formApprovalsPart } from './approving.mjs';
-import { draftRead, resumeStep } from './drafts.mjs';
+import { draftRead, resumeStep, timedStore } 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 { formJoins } from './joins.mjs';
+import { pressUndoPart } from './undo-later.mjs';
+import { createMoments, createRunner, takenNow } from './run.mjs';
 import { emptyValue, initialValues, isEmpty, lineKind, structuredCopy, } from './values.mjs';
 /**
  * Whether leaving the record now would lose the person's work: changes not
@@ -89,7 +90,9 @@ function innerForm(options, within, place, outer) {
     // A field's label small inside a message's sentence where the page asks (`lowerLabels`).
     // …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);
+    // The page's ask over the language's messages, each read through to them as it is said: a language whose words come in a
+    // chunk of their own fills its table in place once they have come (words-chunks.ts).
+    const messages = page.lowerLabels || dateOrder ? Object.assign(Object.create(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);
     /** The app's functions the page's expressions call: a name none may call is refused now. */
@@ -186,7 +189,23 @@ function innerForm(options, within, place, outer) {
         placeholderOf('#title', page.layout.title);
     /** Whether any rule only warns: without one, there are never warnings to look for. */
     const warns = [...nodeRules.values()].some((rules) => rules.some((compiled) => compiled.rule.level === 'warning'));
-    const steps = page.layout.type === 'wizard' ? page.layout.children.map((step) => step.id) : [];
+    const layoutSteps = page.layout.type === 'wizard' ? page.layout.children.map((step) => step.id) : [];
+    /** The wizard's steps in the order shown: the page's, or the order drawn for this respondent (`state.order`). */
+    let steps = layoutSteps;
+    /**
+     * The parts that join this form where its page or its source asks (`formJoins`: an offline outbox, the fields its link
+     * fills, proof by a code, a payment, a survey's flow, a record's approvals, the record made live), each made as it
+     * comes — at once where it has — and kept in their order: holes until then. While one has not come, a send waits for it
+     * (`joining`); a draft laid before one came is laid on it as it does (`laid`).
+     */
+    const joins = [];
+    const joinParts = formJoins(page, options).filter((part) => !outer || part.name !== 'approvals');
+    let joining;
+    let laid = null;
+    /** A part's side of this form, by its name, once it came. */
+    const joined = (name) => (joins[joinParts.findIndex((part) => part.name === name)] ?? null);
+    /** Whether a part that joins the form says so of a part of the page, or of a field. */
+    const anyJoin = (says) => joins.some((join) => join && says(join));
     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);
@@ -364,6 +383,9 @@ function innerForm(options, within, place, outer) {
         limits: null,
         resume: null,
         approval: null,
+        order: null,
+        timers: {},
+        timeUp: [],
     };
     started = true;
     /**
@@ -456,6 +478,8 @@ function innerForm(options, within, place, outer) {
             filesChanged();
         },
         track,
+        // Through the parts that join the form: a photo taken without signal kept as its bytes, on a page with an outbox.
+        through,
     });
     /**
      * Files on their way changed, here or in a saved form placed here: the
@@ -553,6 +577,88 @@ function innerForm(options, within, place, outer) {
     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;
+    /**
+     * The one kit the parts that work inside the form are given of it (joins.ts): the parts that join it, its limits, the
+     * undo part's press.
+     */
+    const inner = {
+        get form() {
+            return form;
+        },
+        page,
+        fields,
+        options,
+        messages,
+        scheduler,
+        state: () => state,
+        set,
+        reading,
+        sending: () => (page.data.kind === 'responses' ? answersSent() : sentValues()),
+        baseline: () => baseline,
+        same: (name, one, other) => sameValue(fields[name], one, other),
+        conflictOf,
+        store,
+        settled: savesSettled,
+        track,
+        shownNow,
+        generation: () => generation,
+        emit,
+        replaced,
+        clock,
+        started: () => started,
+        listened: () => listeners.size > 0,
+        disposed: () => disposed,
+        // A clock started is kept at once where drafts are kept here: a reload a moment after Start finds it.
+        keep: () => (onServer() ? scheduleDraft() : keepHere(draftNow())),
+        order: (list) => void (steps = list ?? layoutSteps),
+        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 } });
+        },
+        reload: () => load(true),
+    };
+    /** The person's changes to the record shown, as made (history.ts); and whether one is being taken back or made again now. */
+    let noted = [];
+    let replaying = false;
+    /**
+     * A person's change written to `field` (on `line`), noted for Undo with what it held `before`: typing on joins it
+     * (`joins`). The undo part takes them as they come, asked for with the first: in by the time the person presses Ctrl+Z.
+     */
+    const noteChange = (field, line, before, joins) => {
+        if (replaying)
+            return;
+        noted.push([field, line, before ?? null, state.values[field] ?? null, joins]);
+        const part = pressUndoPart.loaded;
+        if (part)
+            part.takeNoted(noted, inner.same);
+        // Kept while it comes; where it cannot, the oldest let go.
+        else if (noted.length > 500)
+            noted.shift();
+        else
+            pressUndoPart.load().catch(() => undefined);
+    };
+    /**
+     * Undo (`back`) or Redo, once the undo part has come: the change taken, written as the person's own change back —
+     * the page's `change` steps and the source's onchange run as for any — once its field still holds what the change
+     * left and may be changed.
+     */
+    function replay(back) {
+        const step = editing ? pressUndoPart.loaded?.takeStep(noted, inner.same, back, (one, left) => !form.fieldReadonly(one.field) && sameValue(fields[one.field], state.values[one.field], left)) : null;
+        if (!step)
+            return null;
+        const { value, ...taken } = step;
+        replaying = true;
+        try {
+            writeValues({ ...state.values, [taken.field]: structuredCopy(value) });
+            afterEdit(taken.field);
+            changed(taken.field, 'person', taken.line === undefined ? {} : { line: taken.line });
+        }
+        finally {
+            replaying = false;
+        }
+        return taken;
+    }
     function set(patch) {
         const was = state.values;
         const choicesWas = state.choices;
@@ -586,6 +692,10 @@ function innerForm(options, within, place, outer) {
                 part.inner.show(inside(state.errors, part.name));
         for (const listener of [...listeners])
             listener(state);
+        // What the parts that join the form follow of it: the record shown, watched for changes made elsewhere and for who
+        // else has it open, asked again as that changes.
+        for (const join of joins)
+            join?.changed?.();
         // 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.
@@ -625,6 +735,7 @@ 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++;
+        noted = [];
         // Another record's lines ask the source anew.
         lineAsks = new Map();
         answers = new Map();
@@ -737,6 +848,9 @@ function innerForm(options, within, place, outer) {
             return;
         told = step;
         emit('step', { step });
+        // A step with a time limit: its clock starts as it is first entered.
+        for (const join of joins)
+            join?.entered?.(step);
         const list = page.on?.show?.[step];
         if (list)
             void track(moment(`on.show.${step}`, list, chain, true));
@@ -1108,13 +1222,13 @@ function innerForm(options, within, place, outer) {
         if (!node)
             throw new Error(`The page has no element "${id}"`);
         const { context: ctx, env } = reading();
-        const hidden = (at) => (at ? !rolesAllow(at.roles, userRoles) || at.invisible.evaluate(ctx, env) : false);
+        const hidden = (at) => (at ? anyJoin((join) => join.hides?.(at.id)) || !rolesAllow(at.roles, userRoles) || at.invisible.evaluate(ctx, env) : false);
         let invisible = hidden(node);
         for (let parent = node.parent; !invisible && parent; parent = index.get(parent)?.parent ?? null) {
             invisible = hidden(index.get(parent));
         }
-        // A section read-only right now makes everything inside it read-only too.
-        let readonly = node.readonly.evaluate(ctx, env);
+        // A section read-only right now makes everything inside it read-only too; a page's, or a step's, time run out too.
+        let readonly = node.readonly.evaluate(ctx, env) || anyJoin((join) => join.locks?.(id));
         for (let parent = node.parent; !readonly && parent; parent = index.get(parent)?.parent ?? null) {
             readonly = index.get(parent)?.readonly.evaluate(ctx, env) ?? false;
         }
@@ -1132,7 +1246,7 @@ function innerForm(options, within, place, outer) {
         if (answer !== undefined && signedNow().has(answer))
             readonly = true;
         // A record waiting for approval: locked but for the fields the page leaves open (the approvals part).
-        if (answer !== undefined && approvalKit?.locks(answer))
+        if (answer !== undefined && anyJoin((join) => join.locksField?.(answer)))
             readonly = true;
         return {
             invisible,
@@ -1274,6 +1388,9 @@ function innerForm(options, within, place, outer) {
         const errors = {};
         const seen = new Set();
         for (const node of visibleFieldNodes(root)) {
+            // The answers of a time run out go as they stood: their checks refuse nothing.
+            if (anyJoin((join) => join.locks?.(node.id)))
+                continue;
             const name = node.field;
             seen.add(name);
             const end = rangeEnd(node);
@@ -1550,8 +1667,10 @@ function innerForm(options, within, place, outer) {
      * 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();
+    /** Where drafts are kept in the browser: the app's store, else a timed page's tab (`timedStore`); none else. */
+    const draftStore = options.drafts?.store ?? timedStore(page);
+    /** Whether drafts are kept: in a store, or on the server. */
+    const draftsOn = () => !!draftStore || 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. */
@@ -1582,6 +1701,7 @@ function innerForm(options, within, place, outer) {
         return {
             values,
             ...(steps.length ? { step: state.step, skipped: [...state.skipped] } : {}),
+            ...Object.assign({}, ...joins.map((join) => join?.kept?.())),
             ...(Object.keys(state.unread).length ? { unread: structuredCopy(state.unread) } : {}),
             answered: Object.keys(fields).filter((name) => state.dirty.includes(name)),
             savedAt: new Date(clock()).toISOString(),
@@ -1590,7 +1710,7 @@ function innerForm(options, within, place, outer) {
     /** 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));
+            draftStore?.setItem(storeKey(), JSON.stringify(kept));
         }
         catch {
             // The draft is a convenience: the form goes on without it.
@@ -1637,6 +1757,10 @@ function innerForm(options, within, place, outer) {
     /** 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;
+        // Its draw and its clocks, by the survey flow's part: now, or once it came.
+        laid = draft;
+        for (const join of joins)
+            join?.lay?.(draft);
         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.
@@ -1659,12 +1783,15 @@ function innerForm(options, within, place, outer) {
         serverKey = null;
         if (state.resume)
             set({ resume: null });
-        options.drafts?.store.removeItem(storeKey());
+        draftStore?.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') {
+    /**
+     * A draft found: laid at once (`restore: "auto"`, a draft continued from its key over nothing typed, one kept in a
+     * timed page's tab, or one whose clock started — let go, it would start again), else offered.
+     */
+    function offer(draft, auto = !options.drafts || 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)
+        if ((auto || draft.timers) && !state.dirty.length && !Object.keys(state.unread).length)
             return applyDraft(draft);
         found = draft;
         set({ draft: { savedAt: draft.savedAt } });
@@ -1678,7 +1805,7 @@ function innerForm(options, within, place, outer) {
         const source = options.dataSource;
         const given = resumeKey;
         resumeKey = undefined;
-        const kept = given ? null : draftRead(options.drafts?.store.getItem(storeKey()) ?? null);
+        const kept = given ? null : draftRead(draftStore?.getItem(storeKey()) ?? null);
         if (!given && !kept)
             return;
         if (kept && !('key' in kept))
@@ -1696,7 +1823,7 @@ function innerForm(options, within, place, outer) {
                 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());
+                draftStore?.removeItem(storeKey());
                 if (given)
                     set({ resume: { key, missing: true } });
                 return;
@@ -1731,27 +1858,8 @@ function innerForm(options, within, place, outer) {
     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 } });
-            },
-        });
+        // The one kit, made at the limits' own moment: once the form knows it keeps them (joins.ts).
+        const kit = part.formLimits(inner);
         limitsKit = kit;
         kit.show();
         if (kit.asks() && (state.recordId == null || loadedOnce))
@@ -1772,15 +1880,6 @@ function innerForm(options, within, place, outer) {
     }
     /** 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);
-    // ---- a record's approvals (the approvals part: form-approvals.ts) ---------------------------------------------------
-    /** The approvals made for this form from the approvals part, once it came: none before, nor on a page without them. */
-    let approvalKit = null;
-    /** Whether the form asks for approvals: a page with `approval` (a record's own, as its check says), its source telling them. */
-    const keepsApprovals = !outer && !!page.approval && !!options.dataSource?.approvals;
-    /** The approvals, made from their part once it came; null without them, or where it could not come. */
-    const approvalsCode = () => keepsApprovals ? formApprovalsPart.load().then((part) => (approvalKit ??= part.formApprovals({ form, dataSource: options.dataSource, messages, set, reload: () => load(true) })), () => null) : Promise.resolve(null);
-    /** Ask the record shown's approvals, once their part came; nothing on a page without them. */
-    const askApprovals = () => approvalsCode().then((kit) => kit?.ask());
     function scheduleAutosave() {
         const autosave = options.autosave;
         // A record the person may not change is never saved unasked: it would only be refused.
@@ -1857,9 +1956,24 @@ function innerForm(options, within, place, outer) {
         }
         return shown;
     }
+    /** A response's answers as they go: those shown, and what the parts that join the form add (a link's hidden fields). */
+    function answersSent() {
+        const values = shownValues();
+        for (const join of joins)
+            join.values?.(values);
+        return values;
+    }
     async function save(chain = [], yes) {
         return (await saving(chain, yes)) === null;
     }
+    /** A send — a response's, a save's, an upload's — through the parts that join the form, each around the next. Null: kept, not sent. */
+    function through(kind, sent, send) {
+        return joins.reduce((go, join) => (join.around ? (one) => join.around(kind, one, go) : go), send)(sent);
+    }
+    /** Started again, or another record opened: the parts that join the form let go of what the one before had. */
+    const joinsReset = () => joins.forEach((join) => join.reset?.());
+    /** The record loaded, or saved: what the parts that join the form ask again (a record's approvals). */
+    const joinsLoaded = () => joins.forEach((join) => join.loaded?.());
     /** Every value, for a source that saves whole records: those of fields hidden from the person, which they never had, left out. */
     function sentValues() {
         const values = structuredCopy(state.values);
@@ -1967,8 +2081,22 @@ function innerForm(options, within, place, outer) {
         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.
+        // The parts that join the form (`formJoins`), waited for where they have not come.
+        if (joining) {
+            await joining;
+            if (asked !== generation)
+                return elsewhere();
+        }
+        // A file that did not reach the store stops it, under its field, with the form's own checks — and what the parts that
+        // join the form find: an email or a phone not proved by a code; a payment not taken sends nothing.
         const errors = { ...collectErrors(), ...fileProblems() };
+        for (const join of joins) {
+            // A part that never came (a hole) has nothing to say.
+            if ((await join?.before?.(errors)) === false)
+                return { reason: 'save' };
+            if (asked !== generation)
+                return elsewhere();
+        }
         if (Object.keys(errors).length) {
             set({ errors, ...unstored(errors) });
             return { reason: 'save', message: Object.values(errors)[0] };
@@ -1998,13 +2126,18 @@ function innerForm(options, within, place, outer) {
             if (page.data.kind === 'responses') {
                 if (!source?.submit)
                     throw new Error('This page has no data source to send its answers to');
-                const sent = shownValues();
+                const sent = answersSent();
                 const before = state.values;
                 at = generation;
                 const resetAt = resets;
                 const seen = botReport();
+                // A quiz's marking, in before the answers go: what the person sees of their results.
                 // 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 })) ?? {};
+                const request = { pageId: page.id, values: sent, ...(seen ? { bot: seen } : {}), ...draft };
+                // Through the parts that join the form: kept on the device where an outbox finds no signal (null), the form going
+                // on as though it went.
+                const got = await through('submit', request, (one) => source.submit(one));
+                const answer = got ?? {};
                 // The captcha's token is spent once sent: the next send waits for a new one.
                 if (seen?.captcha)
                     bot.captcha = null;
@@ -2016,8 +2149,13 @@ function innerForm(options, within, place, outer) {
                 sentAs = before;
                 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 } } } : {}) });
+                // A quiz's results: the source's marking, else the page's, on the answers as sent.
+                const quiz = answer.quiz ?? joined('surveyflow')?.marked(sent);
+                set({ status: 'saved', unsent: unsentNow(), ...(resets === resetAt ? { sent: { id: answer.id ?? null, values: { ...structuredCopy(sent), ...added }, ...(quiz ? { quiz } : {}) } } : {}) });
                 emit('send', { values: sent, ...(seen ? { bot: seen } : {}) });
+                // Kept, not sent: its counts and its after-save steps wait for a send that went.
+                if (got === null)
+                    return null;
                 // Counted again: one response fewer to take, this person's sent.
                 if (asksLimits())
                     void track(askLimits());
@@ -2030,7 +2168,7 @@ function innerForm(options, within, place, outer) {
             const sent = state.values;
             at = generation;
             const resetAt = resets;
-            const result = await source.save({
+            const request = {
                 model: page.data.model,
                 id: state.recordId,
                 fields,
@@ -2039,7 +2177,10 @@ function innerForm(options, within, place, outer) {
                 // 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,
-            });
+            };
+            const got = await through('save', request, (one) => source.save(one));
+            // Kept on the device (null): the record as it was, its version too.
+            const result = got ?? { id: state.recordId, version: state.version ?? undefined };
             // 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.
             if (at !== generation)
@@ -2051,6 +2192,11 @@ function innerForm(options, within, place, outer) {
             sentAs = baseline;
             // Its version now, for the next save to carry; and what the person may do now, when the save changed that.
             // The person's changes it did not send are at risk (`unsent`): every way out asks before it leaves them.
+            // A save starts the person's changes afresh, as one saved is no change to take back (the viewer's Ctrl+Z says
+            // nothing changed since). Not on a page that saves itself as it is changed (`autosave`), whose changes are taken
+            // back across its saves; nor where a change made while it saved goes on past it.
+            if (!options.autosave && !dirty.length && got)
+                noted = [];
             set({ status: 'saved', recordId: result.id, values, dirty, warnings: withValues(values, collectWarnings), version: result.version ?? null, ...(result.can ? { can: result.can } : {}) });
             // Changed while it saved: kept in a draft, and saved as any change is.
             if (dirty.length) {
@@ -2058,11 +2204,11 @@ function innerForm(options, within, place, outer) {
                 scheduleAutosave();
             }
             // A save may have sent it for approval, or moved it on: its approvals asked again.
-            if (keepsApprovals)
-                void track(askApprovals());
+            joinsLoaded();
             // The record as this save left it: a change made while it was on its way is no value of it.
             emit('save', { recordId: state.recordId, values: baseline });
-            void track(moment('on.afterSave', page.on?.afterSave, chain, false));
+            if (got)
+                void track(moment('on.afterSave', page.on?.afterSave, chain, false));
             return null;
         }
         catch (error) {
@@ -2168,7 +2314,8 @@ function innerForm(options, within, place, outer) {
     }
     function addLine(field, values, by) {
         const def = lineField(field);
-        const current = state.values[field] ?? [];
+        const before = state.values[field];
+        const current = before ?? [];
         // A key no line holds: lines given (a line's own lines, back from its form) may hold new-… keys already.
         let key = `new-${++lineKeys}`;
         while (current.some((line) => line.key === key))
@@ -2181,6 +2328,8 @@ function innerForm(options, within, place, outer) {
         }
         const lines = [...current, line];
         writeValues({ ...state.values, [field]: lines });
+        if (by === 'person')
+            noteChange(field, key, before, false);
         afterEdit(field);
         changed(field, by, by === 'person' ? { line: key } : { keep: true });
         return key;
@@ -2325,8 +2474,7 @@ function innerForm(options, within, place, outer) {
             if (asksLimits())
                 void track(askLimits());
             // Its approvals: where it stands, what was decided, what this person may decide — its fields locked while it waits.
-            if (keepsApprovals)
-                void track(askApprovals());
+            joinsLoaded();
             if (again)
                 return;
             offerDraft();
@@ -2362,6 +2510,7 @@ function innerForm(options, within, place, outer) {
         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, approval: null };
         if (id != null) {
             set({ ...fresh, recordId: id, status: 'idle' });
+            joinsReset();
             await load();
             return true;
         }
@@ -2369,6 +2518,7 @@ 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) });
+        joinsReset();
         if (asksLimits())
             void track(askLimits());
         offerDraft();
@@ -2693,8 +2843,12 @@ function innerForm(options, within, place, outer) {
         const builtin = 'builtin' in source && !list.length ? source.builtin : undefined;
         if (builtin)
             list.push({ do: builtin });
-        const asked = builtin === 'archive' ? named(messages.archiveConfirmNoun, messages.archiveConfirm) : builtin === 'delete' ? named(messages.deleteConfirmNoun, messages.deleteConfirm) : undefined;
+        // Undo after it, in place of asking first: a built-in with `undo` asks nothing unless it says so.
+        const offers = 'undo' in source ? source.undo : undefined;
+        const asked = offers !== undefined ? undefined : builtin === 'archive' ? named(messages.archiveConfirmNoun, messages.archiveConfirm) : builtin === 'delete' ? named(messages.deleteConfirmNoun, messages.deleteConfirm) : undefined;
         const confirm = 'confirm' in source && source.confirm !== undefined ? source.confirm : asked;
+        if (offers !== undefined)
+            scope.taken = takenNow(state.values);
         // Its question's Yes, and its ask steps', say what it does: its own words, else Archive or Delete.
         scope.yes ??= source.label || (builtin === 'archive' ? messages.archiveYes : builtin === 'delete' ? messages.deleteYes : undefined);
         // On the record it was pressed on: another shown while its question is asked, it does nothing to that one.
@@ -2728,9 +2882,21 @@ function innerForm(options, within, place, outer) {
                     return result;
                 }
             }
-            return runTop(list, scope);
+            const result = await runTop(list, scope);
+            if (scope.taken)
+                offerUndo(source, scope, result, offers);
+            return result;
         })());
     }
+    /**
+     * A press that offers Undo has ended: its words said — the last with Undo, where what it did can be taken back — by
+     * the undo part (press-undo.ts), which a page whose buttons offer Undo asks for first; plainly where it cannot come.
+     */
+    function offerUndo(source, scope, result, offers) {
+        const taken = scope.taken;
+        scope.taken = undefined;
+        void track(pressUndoPart.load().then((part) => part.offerUndo(inner, { kit: runner.kit, source, scope, taken, result, offers }), () => taken.said.forEach((words) => options.host?.say(words.message, words.tone))));
+    }
     const form = {
         page,
         ...(table ? { functions: table } : {}),
@@ -2755,7 +2921,10 @@ function innerForm(options, within, place, outer) {
             // 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;
+            const before = state.values[name];
             writeValues({ ...state.values, [name]: structuredCopy(value) });
+            if ((how?.by ?? 'person') === 'person')
+                noteChange(name, undefined, before, true);
             afterEdit(name);
             changed(name, how?.by ?? 'person');
         },
@@ -2780,7 +2949,7 @@ 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 || signedNow().has(name) || !!approvalKit?.locks(name),
+        fieldReadonly: (name) => lockedField(fieldDef(name)) || state.can?.edit === false || state.can?.readonlyFields?.includes(name) === true || signedNow().has(name) || anyJoin((join) => join.locksField?.(name)),
         loadChoices: (field) => loadChoices(field),
         loadDefinitions,
         addDefinition,
@@ -2821,8 +2990,9 @@ function innerForm(options, within, place, outer) {
                 return null;
             if (state.unread[name])
                 return state.unread[name].message;
-            // A property's text left unread answers for its field.
-            if (page.fields[name].type === 'properties') {
+            // A property's text left unread answers for its field, and so does a box of a value drawn in parts (a repeat
+            // rule's number, an opening hour's time: `field.part`).
+            if (['properties', 'json', 'char'].includes(page.fields[name].type)) {
                 const row = Object.keys(state.unread).find((path) => path.startsWith(`${name}.`));
                 if (row)
                     return state.unread[row].message;
@@ -2836,7 +3006,9 @@ function innerForm(options, within, place, outer) {
             const field = path.split('.')[0];
             // A line's cell (`field.lineKey.subfield`), or a property (`field.property`).
             const def = fieldDef(field);
-            if (path.includes('.') && def.type !== 'properties')
+            // A line's cell, a property, or one of the boxes a value is drawn in (a repeat rule's number, an opening hour's
+            // time: `field.part`, of a char or a json field).
+            if (path.includes('.') && def.type !== 'properties' && !((def.type === 'json' || def.type === 'char') && path.split('.').length === 2))
                 lineField(field);
             const had = state.unread[path];
             if (!unread && !had)
@@ -2859,6 +3031,7 @@ function innerForm(options, within, place, outer) {
             set({ unread: next, errors });
         },
         boxLeft(path) {
+            noted.push([path.split('.')[0]]);
             const problem = leftProblem(path);
             if (!problem || state.errors[path] === problem)
                 return;
@@ -2881,10 +3054,11 @@ function innerForm(options, within, place, outer) {
             if (seen.captcha !== undefined)
                 bot.captcha = seen.captcha;
         },
+        joined: (name) => (joins[joinParts.findIndex((part) => part.name === name)] ?? null),
         reading: () => readingNow > 0 || [...attached.values()].some((part) => part.inner.form.reading()),
-        validate() {
+        validate(within) {
             readTyped();
-            const errors = collectErrors();
+            const errors = collectErrors(within);
             set({ errors });
             return Object.keys(errors).length === 0;
         },
@@ -2977,6 +3151,7 @@ function innerForm(options, within, place, outer) {
             holding = setWhen.holding(baseline);
             // The person's own Discard: nothing of theirs is left at risk, and a save on its way lands as the record it stored.
             resets++;
+            noted = [];
             personal.clear();
             personalLines.clear();
             filed.clear();
@@ -2985,6 +3160,9 @@ function innerForm(options, within, place, outer) {
             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: {}, takenOut: {}, sent: null });
+            // Started again: a new response proves and pays its own; a new respondent is drawn anew (unless the app or the
+            // person's id is the seed), on the first step drawn, no clock running.
+            joinsReset();
             // Started again: whether the page takes another response, and each choice's places, asked again.
             if (asksLimits())
                 void track(askLimits());
@@ -3004,8 +3182,10 @@ function innerForm(options, within, place, outer) {
             const def = lineField(field);
             if (!def.fields[name])
                 throw new Error(`The lines of "${field}" have no field "${name}"`);
-            const lines = (state.values[field] ?? []).map((line) => line.key === key ? { ...line, values: { ...line.values, [name]: structuredCopy(value) } } : line);
+            const before = state.values[field];
+            const lines = (before ?? []).map((line) => line.key === key ? { ...line, values: { ...line.values, [name]: structuredCopy(value) } } : line);
             writeValues({ ...state.values, [field]: lines });
+            noteChange(field, key, before, true);
             afterEdit(field);
             changed(field, 'person', { line: key });
         },
@@ -3035,7 +3215,9 @@ function innerForm(options, within, place, outer) {
                 const value = trusted ? (i >= low && i <= high ? pool[i - low] : line.values[sequence]) : i + 1;
                 return value === line.values[sequence] ? line : { ...line, values: { ...line.values, [sequence]: value } };
             });
+            const was = state.values[field];
             writeValues({ ...state.values, [field]: renumbered });
+            noteChange(field, undefined, was, false);
             afterEdit(field);
             changed(field, 'person');
         },
@@ -3049,8 +3231,10 @@ function innerForm(options, within, place, outer) {
                     throw new Error(`The line "${key}" of "${field}" cannot be deleted now: its table's lineDelete does not hold on it`);
                 }
             }
-            const lines = (state.values[field] ?? []).filter((line) => line.key !== key);
+            const before = state.values[field];
+            const lines = (before ?? []).filter((line) => line.key !== key);
             writeValues({ ...state.values, [field]: lines });
+            noteChange(field, key, before, false);
             afterEdit(field);
             changed(field, 'person', { line: key });
         },
@@ -3117,6 +3301,8 @@ function innerForm(options, within, place, outer) {
             set({ step: previous, errors: {} });
             return true;
         },
+        startTimer: () => joined('surveyflow')?.start(),
+        countdown: () => joined('surveyflow')?.countdown() ?? null,
         skip() {
             const current = state.step;
             if (!current || !optionalStep(current))
@@ -3257,7 +3443,7 @@ function innerForm(options, within, place, outer) {
             return () => void heard.delete(listener);
         },
         restoreDraft() {
-            const kept = found ?? draftRead(options.drafts?.store.getItem(storeKey()) ?? null);
+            const kept = found ?? draftRead(draftStore?.getItem(storeKey()) ?? null);
             if (kept && 'values' in kept)
                 applyDraft(kept);
         },
@@ -3278,14 +3464,18 @@ function innerForm(options, within, place, outer) {
             return saved;
         },
         refreshLimits: () => askLimits(),
-        refreshApprovals: askApprovals,
+        async refreshApprovals() {
+            await joining;
+            await joined('approvals')?.ask();
+        },
         async decide(level, decision, reason) {
-            const kit = await approvalsCode();
+            await joining;
+            const kit = joined('approvals');
             if (!kit)
                 throw new Error('No approvals on this page');
             return track(kit.decide(level, decision, reason));
         },
-        approvalLock: (name) => approvalKit?.lockWords(name) ?? null,
+        approvalLock: (name) => joined('approvals')?.lockWords(name) ?? null,
         async reloadTheirs() {
             // A save on its way first: its answer is not dropped by the load.
             const asked = shownNow();
@@ -3385,6 +3575,9 @@ function innerForm(options, within, place, outer) {
             if (state.setAside)
                 set({ setAside: null });
         },
+        undo: () => replay(true),
+        redo: () => replay(false),
+        history: () => pressUndoPart.loaded?.nextSteps(noted, inner.same) ?? { undo: null, redo: null },
         async settled() {
             while (pending.size)
                 await Promise.allSettled([...pending]);
@@ -3451,6 +3644,8 @@ function innerForm(options, within, place, outer) {
         dispose() {
             // An answer that lands after is for no record shown.
             disposed = true;
+            for (const join of joins)
+                join?.dispose?.();
             newGeneration();
             clearFiles();
             if (draftTimer !== null)
@@ -3470,9 +3665,22 @@ function innerForm(options, within, place, outer) {
     // 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 record's approvals: their part asked for as the form is made, ready by the time its record is loaded.
-    if (keepsApprovals)
-        void track(approvalsCode());
+    // The parts its page or its source asks to join it — a survey's draw made before a draft is laid, which lays its own
+    // draw over it; a record's approvals ready by the time its record is loaded; the record made live — each made at once
+    // where it has come, else as it does, a draft laid meanwhile laid on it.
+    if (joinParts.length) {
+        const made = (at) => (part) => {
+            if (disposed || joins[at])
+                return;
+            const join = (joins[at] = part.join(inner));
+            if (laid)
+                join.lay?.(laid);
+            // Its record loaded before it came: what it asks of a loaded record, asked now.
+            if (loadedOnce)
+                join.loaded?.();
+        };
+        joining = Promise.all(joinParts.map((part, at) => (part.loaded ? made(at)(part.loaded) : track(part.load().then(made(at), () => undefined)))));
+    }
     // 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) {