@fieldia/core 0.30.1 → 0.31.0

package/src/lib/record/form.js

@@ -28,12 +28,13 @@ const line_choices_1 = require("./line-choices");
 const data_source_1 = require("./data-source");
 const taking_1 = require("./taking");
 const languages_1 = require("./languages");
-const approving_1 = require("./approving");
 const drafts_1 = require("./drafts");
 const waits_1 = require("./waits");
 const uploads_1 = require("./uploads");
 const scheduler_1 = require("./scheduler");
 const signed_1 = require("./signed");
+const joins_1 = require("./joins");
+const undo_later_1 = require("./undo-later");
 const run_1 = require("./run");
 const values_1 = require("./values");
 /**
@@ -95,7 +96,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_1.MESSAGES.en), lowerLabels: page.lowerLabels, dateOrder } : (options.messages ?? messages_1.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_1.MESSAGES.en), { lowerLabels: page.lowerLabels, dateOrder }) : (options.messages ?? messages_1.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) => (0, record_words_1.recordSentence)(page.records, noun, plain, messages.locale);
     /** The app's functions the page's expressions call: a name none may call is refused now. */
@@ -192,7 +195,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 = (0, joins_1.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 = () => (0, zones_1.dayIn)(options.now?.() ?? new Date(), page.timeZone);
@@ -370,6 +389,9 @@ function innerForm(options, within, place, outer) {
         limits: null,
         resume: null,
         approval: null,
+        order: null,
+        timers: {},
+        timeUp: [],
     };
     started = true;
     /**
@@ -462,6 +484,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
@@ -559,6 +583,87 @@ function innerForm(options, within, place, outer) {
     const listed = (0, line_choices_1.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,
+        keep: () => void ((options.drafts || onServer()) && scheduleDraft()),
+        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 = undo_later_1.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
+            undo_later_1.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 ? undo_later_1.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]: (0, values_1.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;
@@ -592,6 +697,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.
@@ -631,6 +740,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();
@@ -743,6 +853,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));
@@ -1114,13 +1227,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 ? !(0, roles_1.rolesAllow)(at.roles, userRoles) || at.invisible.evaluate(ctx, env) : false);
+        const hidden = (at) => (at ? anyJoin((join) => join.hides?.(at.id)) || !(0, roles_1.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;
         }
@@ -1138,7 +1251,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,
@@ -1280,6 +1393,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);
@@ -1588,6 +1704,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: (0, values_1.structuredCopy)(state.unread) } : {}),
             answered: Object.keys(fields).filter((name) => state.dirty.includes(name)),
             savedAt: new Date(clock()).toISOString(),
@@ -1643,6 +1760,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.
@@ -1737,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))
@@ -1778,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 ? approving_1.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.
@@ -1863,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 = (0, values_1.structuredCopy)(state.values);
@@ -1973,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] };
@@ -2004,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;
@@ -2022,8 +2149,13 @@ function innerForm(options, within, place, outer) {
                 sentAs = before;
                 const added = answer.values && typeof answer.values === 'object' ? (0, values_1.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: { ...(0, values_1.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: { ...(0, values_1.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());
@@ -2036,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,
@@ -2045,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)
@@ -2064,11 +2199,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) {
@@ -2174,7 +2309,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))
@@ -2187,6 +2323,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;
@@ -2331,8 +2469,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();
@@ -2368,6 +2505,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;
         }
@@ -2375,6 +2513,7 @@ function innerForm(options, within, place, outer) {
         baseline = startFrom(startingValues(true, false));
         const values = syncParts((0, values_1.structuredCopy)(baseline), 'start');
         set({ ...fresh, recordId: null, status: 'ready', values, warnings: withValues(values, collectWarnings) });
+        joinsReset();
         if (asksLimits())
             void track(askLimits());
         offerDraft();
@@ -2699,8 +2838,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 = (0, run_1.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.
@@ -2734,9 +2877,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(undo_later_1.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 } : {}),
@@ -2761,7 +2916,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]: (0, values_1.structuredCopy)(value) });
+            if ((how?.by ?? 'person') === 'person')
+                noteChange(name, undefined, before, true);
             afterEdit(name);
             changed(name, how?.by ?? 'person');
         },
@@ -2786,7 +2944,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,
@@ -2827,8 +2985,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;
@@ -2842,7 +3001,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)
@@ -2865,6 +3026,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;
@@ -2887,10 +3049,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;
         },
@@ -2983,6 +3146,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();
@@ -2991,6 +3155,9 @@ function innerForm(options, within, place, outer) {
             bot = { ...bot, honeypot: false, since: clock() };
             const values = syncParts((0, values_1.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());
@@ -3010,8 +3177,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]: (0, values_1.structuredCopy)(value) } } : line);
+            const before = state.values[field];
+            const lines = (before ?? []).map((line) => line.key === key ? { ...line, values: { ...line.values, [name]: (0, values_1.structuredCopy)(value) } } : line);
             writeValues({ ...state.values, [field]: lines });
+            noteChange(field, key, before, true);
             afterEdit(field);
             changed(field, 'person', { line: key });
         },
@@ -3041,7 +3210,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');
         },
@@ -3055,8 +3226,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 });
         },
@@ -3123,6 +3296,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))
@@ -3284,14 +3459,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();
@@ -3391,6 +3570,9 @@ function innerForm(options, within, place, outer) {
             if (state.setAside)
                 set({ setAside: null });
         },
+        undo: () => replay(true),
+        redo: () => replay(false),
+        history: () => undo_later_1.pressUndoPart.loaded?.nextSteps(noted, inner.same) ?? { undo: null, redo: null },
         async settled() {
             while (pending.size)
                 await Promise.allSettled([...pending]);
@@ -3457,6 +3639,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)
@@ -3476,9 +3660,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) {