@fieldia/core 0.22.0 → 0.24.0

package/src/lib/record/form.mjs

@@ -1,6 +1,7 @@
 import { upgradePage } from '../format/upgrade.mjs';
+import { zonedPage } from '../format/zoned.mjs';
 import { compileModifier } from '../expression/modifier.mjs';
-import { localDay } from '../expression/functions.mjs';
+import { dayIn, ownZone } from './zones.mjs';
 import { checkProperties, checkValue } from './check.mjs';
 import { checkInput } from './inputs.mjs';
 import { compileComputed } from './compute.mjs';
@@ -28,15 +29,23 @@ export function unsavedWork(state) {
 }
 /**
  * Whether a way out would lose the person's work without their knowing: a
- * change of theirs the last save did not send (`unsent`), files still on
- * their way, changes Reload set aside — and, `how.changes`, any change not
- * saved. What `form.leave()` — the one check every way out goes through —
- * asks about, once the save on its way and the files on theirs settled.
- * Before a record's first save, a change not saved is not at risk: as in
- * 0.20, each way out decides.
+ * change of theirs the last save did not send, or text they left since that
+ * does not read ("12a" counts as "12" does: `unsent`), files still on
+ * their way, changes Reload set aside, the changes of a save refused for a
+ * conflict, waiting for Reload or Keep mine (only a source that keeps
+ * versions has one) — and, `how.changes`, any change not saved. What
+ * `form.leave()` — the one check every way out goes through — asks about,
+ * once the save on its way and the files on theirs settled. Before a
+ * record's first save, a change not saved is not at risk: as in 0.20, each
+ * way out decides.
  */
 export function workAtRisk(state, how = {}) {
-    return (state.unsent ?? []).length > 0 || state.setAside != null || (state.uploads ?? []).some(uploadGoing) || (how.changes === true && (state.dirty.length > 0 || Object.keys(state.unread ?? {}).length > 0));
+    return ((state.unsent ?? []).length > 0 ||
+        state.setAside != null ||
+        (state.uploads ?? []).some(uploadGoing) ||
+        // The person asked for these to be saved, and someone else's save came first: still theirs, and not saved.
+        (state.conflict != null && state.dirty.length > 0) ||
+        (how.changes === true && (state.dirty.length > 0 || Object.keys(state.unread ?? {}).length > 0)));
 }
 /**
  * The record state behind a page: values, what changed, what is visible and
@@ -48,6 +57,8 @@ export function createForm(options) {
     const page = upgradePage(options.page);
     return innerForm(page === options.page ? options : { ...options, page }, []).form;
 }
+/** Whether a run works a person's change out: a page's `change` steps, set off by it, or a run they set off. */
+const worksOut = (chain) => chain.some((key) => key.startsWith('on.change.'));
 /** A line's cell whose line is no longer there. */
 const gone = Symbol('gone');
 const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
@@ -60,7 +71,8 @@ const asValue = (values) => values;
  * its ways out go through that one's check.
  */
 function innerForm(options, within, place, outer) {
-    const { page } = options;
+    // Its time zone written into each date and time field naming none, for whatever reads one from its field alone.
+    const page = zonedPage(options.page);
     const scheduler = options.scheduler ?? hostScheduler;
     const messages = options.messages ?? MESSAGES.en;
     const index = indexLayout(page.layout);
@@ -124,7 +136,19 @@ function innerForm(options, within, place, outer) {
     const warns = [...nodeRules.values()].some((rules) => rules.some((compiled) => compiled.rule.level === 'warning'));
     const steps = page.layout.type === 'wizard' ? page.layout.children.map((step) => step.id) : [];
     const draftKey = () => `fieldia:draft:${page.id}:${state.recordId ?? 'new'}`;
-    const today = () => localDay(options.now?.() ?? new Date());
+    /** 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);
+    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() };
+    /** What the bot check saw as the answers go; none without one. */
+    function botReport() {
+        const check = page.botCheck;
+        if (!check)
+            return undefined;
+        const taken = Math.max(0, clock() - bot.since) / 1000;
+        return { honeypot: check.honeypot !== false && bot.honeypot, tooFast: taken < (check.minSeconds ?? 3), seconds: Math.round(taken * 10) / 10, ...(check.captcha ? { captcha: bot.captcha } : {}) };
+    }
     // The record's id and the person, as worked-out values read them: the id is the one asked for until the form has its state.
     let started = false;
     let editing = options.editing !== false;
@@ -286,16 +310,41 @@ function innerForm(options, within, place, outer) {
     let generation = 0;
     /** Closed (`dispose`): a run still going stops quietly, as its dialog or page is gone — no other record replaced it. */
     let disposed = false;
-    /** The fields whose last write was the person's: a step's, a rule's or the app's write takes one over. */
+    /** Counted at each reset (the person's Discard): a save on its way then lands as the record it stored. */
+    let resets = 0;
+    /**
+     * THE test every late answer passes (`recordShown`): taken as it is asked for, true while the record it was asked
+     * for is still the one shown, as it was. A save's answer, a call's, an onchange's, a name looked up, a line's
+     * dialog, a record step's — none is laid on another record, nor over the values the person's Discard let go.
+     */
+    function shownNow() {
+        const at = generation;
+        const reset = resets;
+        // A saved form placed in a record is the record's: another shown round it, its answers are laid nowhere either.
+        const round = outer?.recordShown();
+        return () => !disposed && at === generation && reset === resets && (!round || round());
+    }
+    /**
+     * The person's claims on the record: the fields whose last write was theirs. A step's, a rule's or the app's
+     * write of the whole field takes one over; a write that works the person's change out (the source's onchange, the
+     * page's `change` steps it sets off) keeps it.
+     */
     const personal = new Set();
+    /**
+     * Of a table the person did not write whole: the keys of the lines they changed, added or took away. A line a
+     * step adds is none of theirs, and leaves theirs as they are.
+     */
+    const personalLines = new Map();
     /** Fields where a file the person picked landed from the store: at risk until a save sends it, a first save or not. */
     const filed = new Set();
     /** The record as the last finished save left it — what it sent and what came back; a page of answers: what it sent. Null before one. */
     let sentAs = null;
-    /** Counted at each reset (the person's Discard): a save on its way then lands as the record it stored. */
-    let resets = 0;
-    /** Above 0 while a delete the person chose goes on: a way out it takes lets their work go, unasked. */
-    let deletes = 0;
+    /**
+     * The records being deleted, by the person's choice, each by its generation: a way out of one of them lets their
+     * work in it go, unasked. Another record shown meanwhile is asked about as any.
+     */
+    const deleting = new Map();
+    const deletingShown = () => (deleting.get(generation) ?? 0) > 0;
     /** Each field's last comparison with what was sent, so a value that did not move is not compared again. */
     const compared = new Map();
     /** Fields showing a file that did not reach the store: shown until it is sent again or taken away, whatever else changes. */
@@ -433,8 +482,9 @@ function innerForm(options, within, place, outer) {
         const was = state.values;
         const shown = state.errors;
         state = { ...state, ...patch };
-        // The person's changes the last save did not send, worked out again from the values as they are now.
-        if (patch.unsent === undefined && patch.values !== undefined) {
+        // 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)) {
             const unsent = unsentNow();
             if (!sameList(unsent, state.unsent))
                 state = { ...state, unsent };
@@ -463,42 +513,66 @@ function innerForm(options, within, place, outer) {
             for (const listener of [...heard])
                 listener(payload);
     }
-    /** A field written: told to the app, and — a person's change — the page's `change` steps for it run. */
-    function changed(field, by) {
-        noteOrigin(field, by);
+    /**
+     * A field written: told to the app, and — a person's change — the page's `change` steps for it run. `claim` says
+     * what of the person's it touches: `line`, the key of the one line of a table the person changed; `keep`, a write
+     * that leaves the person's claims as they are (a line a step adds, a write working their change out).
+     */
+    function changed(field, by, claim = {}) {
+        noteOrigin(field, by, claim);
         emit('change', { field, value: state.values[field], values: state.values, by });
         const list = page.on?.change?.[field];
         if (by === 'person' && list)
             void track(moment(`on.change.${field}`, list, [], true));
     }
-    /** Another record is shown: nothing of the last one's is the person's work any more. */
+    /** 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++;
         personal.clear();
+        personalLines.clear();
         filed.clear();
         compared.clear();
         sentAs = null;
+        clearFiles();
     }
     /** Whether a field holds a file the store holds that no save sent: its own, or one in a saved form placed here under its name. */
     const filedIn = (name) => filed.has(name) || [...attached.values()].some((part) => part.name === name && part.inner.files.filed());
     /**
      * The person's work no save took, by field, in the page's order: each of
      * their changes that differs from the record as the last save left it —
-     * before a first save, only a file the store holds.
+     * a field they wrote, or a line of a table they changed — and text they
+     * left in a box of it that does not read (`unread`), which no save can
+     * send; before a first save, only a file the store holds.
      */
     function unsentNow() {
-        if (!personal.size)
+        const typed = sentAs ? unreadFields() : null;
+        if (!personal.size && !personalLines.size && !typed?.size)
             return [];
         const out = [];
         for (const name of Object.keys(fields)) {
-            if (!personal.has(name))
+            // Typed and left unread since a save: the person's, as a change is — a value changed to "12" is, so is "12a".
+            if (typed?.has(name)) {
+                out.push(name);
+                continue;
+            }
+            const lines = personalLines.get(name);
+            if (!personal.has(name) && !lines)
                 continue;
             const from = sentAs ?? (filedIn(name) ? baseline : null);
-            if (from && differs(name, state.values[name], from[name]))
+            if (!from)
+                continue;
+            if (lines ? linesDiffer(name, lines, state.values[name], from[name]) : differs(name, state.values[name], from[name]))
                 out.push(name);
         }
         return out;
     }
+    /** The fields with text left unread in a box of theirs: a field's, a line's cell's, a property's. */
+    function unreadFields() {
+        const out = new Set();
+        for (const path of Object.keys(state.unread ?? {}))
+            out.add(path.split('.')[0]);
+        return out;
+    }
     function differs(name, value, sent) {
         const known = compared.get(name);
         if (known && known.value === value && known.sent === sent)
@@ -507,18 +581,53 @@ function innerForm(options, within, place, outer) {
         compared.set(name, { value, sent, differs: verdict });
         return verdict;
     }
+    /** Whether any of these lines of a table differs from the table as sent: changed, added, or taken away. */
+    function linesDiffer(name, keys, value, sent) {
+        const def = fields[name];
+        const find = (lines, key) => (lines ?? []).find((line) => line.key === key);
+        for (const key of keys) {
+            const now = find(value, key);
+            const was = find(sent, key);
+            if (!now && !was)
+                continue;
+            if (!now || !was)
+                return true;
+            if (now.values === was.values)
+                continue;
+            for (const sub of new Set([...Object.keys(now.values), ...Object.keys(was.values)])) {
+                if (!sameValue(def.fields[sub], now.values[sub], was.values[sub]))
+                    return true;
+            }
+        }
+        return false;
+    }
     /** `unsent` as it is now, told when it changed. */
     function refreshUnsent() {
         const unsent = unsentNow();
         if (!sameList(unsent, state.unsent))
             set({ unsent });
     }
-    /** A field written, and by whom: the person's change is theirs until a step, a rule or the app writes the field in its place. */
-    function noteOrigin(field, by) {
-        if (by === 'person')
-            personal.add(field);
-        else
+    /**
+     * A field written, and by whom: the person's change is theirs — the field, or the line of a table they changed —
+     * until a step, a rule or the app writes the whole field in its place. A write that leaves their change where it
+     * is (`keep`: a line a step adds, a `change` step working out what they typed) leaves it theirs.
+     */
+    function noteOrigin(field, by, claim) {
+        if (by === 'person') {
+            if (claim.line === undefined) {
+                personal.add(field);
+                personalLines.delete(field);
+            }
+            else if (!personal.has(field)) {
+                const keys = personalLines.get(field) ?? new Set();
+                keys.add(claim.line);
+                personalLines.set(field, keys);
+            }
+        }
+        else if (!claim.keep) {
             personal.delete(field);
+            personalLines.delete(field);
+        }
         refreshUnsent();
     }
     /** A wizard step entered: told to the app, and its `show` steps run. */
@@ -688,10 +797,12 @@ function innerForm(options, within, place, outer) {
         const ticks = node.source.widget === 'tick' && page.fields[name].type === 'boolean';
         return ticks && state.values[name] !== true && nodeState(node.id).required ? messages.tick : undefined;
     }
+    /** 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. */
     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()) ?? ruleCheck(node).error;
+        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;
     }
     /** Warnings for the visible fields of the page, without publishing them. */
     function collectWarnings() {
@@ -775,7 +886,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());
+                        const lineMessage = checkValue(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;
                     }
@@ -840,7 +951,7 @@ function innerForm(options, within, place, outer) {
             if (isEmpty(fieldDef(field), value))
                 return undefined;
             return (shown.map((node) => checkInput(page.fields[field], node.source, value, messages)).find(Boolean) ??
-                besidesRows(field, checkValue(checked(field), value, false, messages, today())) ??
+                besidesRows(field, checkValue(checked(field), value, false, messages, today(), shownWidget(shown))) ??
                 shown.map((node) => ruleCheck(node).error).find(Boolean));
         }
         if (parts.length === 2 && page.fields[field]?.type === 'properties')
@@ -1026,8 +1137,10 @@ function innerForm(options, within, place, outer) {
             return;
         const seq = ++onchangeSeq;
         const request = { model: page.data.model, id: state.recordId, changed, values: structuredCopy(state.values) };
+        const shown = shownNow();
         void track(source.onchange(request).then((result) => {
-            if (seq !== onchangeSeq)
+            // A newer change asked since; or the record it was asked for is gone, or its values let go: none of it is laid.
+            if (seq !== onchangeSeq || !shown())
                 return;
             const values = { ...state.values, ...(result.values ?? {}) };
             writeValues(values, { warning: result.warning ?? null, warningField: result.warning ? changed : null });
@@ -1128,18 +1241,27 @@ function innerForm(options, within, place, outer) {
             set({ status: 'error', error: problem.message, saveProblem: problem, conflict: null });
             return { reason: 'save', message: problem.message };
         }
+        // Asked for the record shown now: another shown while it waits below, it saves nothing of that one, nor says anything there.
+        const asked = generation;
+        const elsewhere = () => ({ reason: 'save', message: messages.recordReplaced });
         // What is still typed in a box is read first: it is what is saved, or why nothing is. A name still being looked
         // up is waited for, so the record it names is what is saved — or, named by none, why nothing is.
         const waiting = readTyped();
         if (waiting)
             await waiting;
+        if (asked !== generation)
+            return elsewhere();
         // 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 });
             await filesSettled();
+            if (asked !== generation)
+                return elsewhere();
             set({ status: 'ready' });
         }
         if (page.on?.beforeSave) {
+            // Its run stops of itself on a record shown by anything but its own steps (a `call`'s `{ record }`, a reload):
+            // those move the save on with it.
             const before = await moment('on.beforeSave', page.on.beforeSave, chain, false);
             if (!before.done) {
                 // A check's problems, or an inner save's, are shown already; any other stop is this save's problem.
@@ -1164,6 +1286,8 @@ function innerForm(options, within, place, outer) {
         try {
             // Bytes still in the record — a signature drawn, a value the app set, in a saved form placed here too — go to the store first, where it keeps files.
             await storeBytes(page.data.kind === 'responses' || state.recordId == null ? Object.keys(fields) : state.dirty);
+            if (at !== generation)
+                return elsewhere();
             const failed = fileProblems();
             if (Object.keys(failed).length) {
                 set({ errors: failed, ...unstored(failed) });
@@ -1175,7 +1299,11 @@ function innerForm(options, within, place, outer) {
                 const sent = shownValues();
                 const before = state.values;
                 at = generation;
-                await source.submit({ pageId: page.id, values: sent });
+                const seen = botReport();
+                await source.submit({ pageId: page.id, values: sent, ...(seen ? { bot: seen } : {}) });
+                // The captcha's token is spent once sent: the next send waits for a new one.
+                if (seen?.captcha)
+                    bot.captcha = null;
                 // Answered for answers no longer shown — the form was started again meanwhile: the source has them, the form lays nothing.
                 if (at !== generation)
                     return null;
@@ -1183,7 +1311,7 @@ function innerForm(options, within, place, outer) {
                 // What it sent is what an answer changed since is told against: still to send.
                 sentAs = before;
                 set({ status: 'saved', unsent: unsentNow() });
-                emit('send', { values: sent });
+                emit('send', { values: sent, ...(seen ? { bot: seen } : {}) });
                 void track(moment('on.afterSave', page.on?.afterSave, chain, false));
                 return null;
             }
@@ -1219,7 +1347,8 @@ function innerForm(options, within, place, outer) {
                 scheduleDraft();
                 scheduleAutosave();
             }
-            emit('save', { recordId: state.recordId, values: state.values });
+            // 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));
             return null;
         }
@@ -1275,8 +1404,12 @@ function innerForm(options, within, place, outer) {
     }
     /** The form has its values: told to the app, its `open` steps run, then the wizard step it shows is told. */
     async function opening() {
+        const at = generation;
         emit('open', { recordId: state.recordId, values: state.values });
         await moment('on.open', page.on?.open, [], true);
+        // Another record shown while its open steps ran: that one's opening tells its own steps.
+        if (at !== generation)
+            return;
         showing = true;
         tellStep([]);
     }
@@ -1297,8 +1430,8 @@ function innerForm(options, within, place, outer) {
         for (const name of names)
             changed(name, 'app');
     }
-    /** Write fields — a step's or the app's — worked out once, and tell each. */
-    function write(written, by) {
+    /** Write fields — a step's or the app's — worked out once, and tell each; `keep`, a write working the person's change out. */
+    function write(written, by, keep = false) {
         const names = Object.keys(written);
         names.forEach(fieldDef);
         if (!names.length)
@@ -1307,8 +1440,9 @@ function innerForm(options, within, place, outer) {
         for (const name of names)
             afterEdit(name);
         for (const name of names)
-            changed(name, by);
+            changed(name, by, { keep });
     }
+    /** A line added: the person's, theirs; a step's, none of theirs, and the lines they changed stay theirs. */
     function addLine(field, values, by) {
         const def = lineField(field);
         const current = state.values[field] ?? [];
@@ -1331,7 +1465,7 @@ function innerForm(options, within, place, outer) {
         const lines = [...current, line];
         writeValues({ ...state.values, [field]: lines });
         afterEdit(field);
-        changed(field, by);
+        changed(field, by, by === 'person' ? { line: key } : { keep: true });
         return key;
     }
     /**
@@ -1340,15 +1474,44 @@ function innerForm(options, within, place, outer) {
      */
     async function check(names) {
         names?.forEach(fieldDef);
+        const at = generation;
         const waiting = readTyped();
         if (waiting)
             await waiting;
+        // Another record shown while it waited: nothing found is shown on that one.
+        if (at !== generation)
+            return replaced();
         const all = collectErrors();
         const found = names ? Object.fromEntries(Object.entries(all).filter(([key]) => names.some((name) => key === name || key.startsWith(`${name}.`)))) : all;
         set({ errors: found });
         const first = Object.values(found)[0];
         return first === undefined ? null : { reason: 'check', message: first };
     }
+    /**
+     * What is typed read first, for a run the person or the app set off (`RunScope.typed`): every box read as a save
+     * reads it, a name looked up waited for. Text left that does not read stops the run, said under its box as a check
+     * says it — never a value under it handed on or worked from.
+     */
+    async function typedFirst() {
+        const at = generation;
+        const waiting = readTyped();
+        if (waiting)
+            await waiting;
+        // Another record shown while it waited: the run is not for that one.
+        if (at !== generation)
+            return replaced();
+        const found = unreadProblems();
+        const first = Object.values(found)[0];
+        if (first === undefined)
+            return null;
+        set({ errors: { ...state.errors, ...found } });
+        return { reason: 'check', message: first };
+    }
+    /** The problems of text left unread in boxes shown — this form's and its saved forms' placed here — by path. */
+    function unreadProblems() {
+        const inner = (path) => [...attached.values()].some((part) => path.startsWith(`${part.name}.`) && !!part.inner.form.getState().unread?.[path.slice(part.name.length + 1)]);
+        return Object.fromEntries(Object.entries(collectErrors()).filter(([path]) => !!state.unread[path] || inner(path)));
+    }
     /** Go to a wizard's step for a run; undefined when the target is no step of it, but a tab. */
     async function goToStep(target, chain) {
         if (!steps.includes(target))
@@ -1356,16 +1519,19 @@ function innerForm(options, within, place, outer) {
         if (!form.steps().includes(target))
             return { reason: 'cannot', message: `The step "${target}" does not apply now` };
         // A name still being looked up in a box on the way is waited for, as a save waits for it.
+        const at = generation;
         const waiting = readTyped();
         if (waiting)
             await waiting;
+        if (at !== generation)
+            return replaced();
         let went = false;
         inRun(chain, () => (went = form.goTo(target)));
         return went ? null : { reason: 'check', message: Object.values(state.errors)[0] };
     }
     /** Run steps from the top — a button's, a moment's, the app's — and tell how it ended: on the record shown as it starts (`generation`). */
     async function runTop(list, scope) {
-        scope.generation = generation;
+        scope.generation ??= generation;
         const result = await runner.runSteps(list, scope);
         emit('run', { id: scope.id, steps: list, result });
         return result;
@@ -1383,7 +1549,7 @@ function innerForm(options, within, place, outer) {
             throw new Error(`"${name}" cannot make records: its data source has no create, or it is not a link`);
         return track(source.create({ model, name: typed.trim(), ...(Object.keys(values).length ? { values } : {}) }));
     }
-    async function runSearch(def, name, ctx, query, limit, model, ids) {
+    async function runSearch(def, name, ctx, query, limit, { model, ids, exact } = {}) {
         // Formatted text names people and records in place (@mention, #4127): searched by the model they are of.
         const byModel = def.type === 'reference' || def.type === 'json' || def.type === 'html';
         if (def.type !== 'many2one' && def.type !== 'many2many' && !byModel) {
@@ -1398,7 +1564,7 @@ function innerForm(options, within, place, outer) {
         const own = byModel || !def.filter ? undefined : resolveFilter(def.filter, ctx);
         const filter = ids ? [...(own ?? []), { field: 'id', op: 'in', value: ids }] : own;
         const relation = byModel ? model : def.relation;
-        return track(source.search({ model: relation, query, ...(filter ? { filter } : {}), limit }));
+        return track(source.search({ model: relation, query, ...(filter ? { filter } : {}), limit, ...(exact ? { exact: true } : {}) }));
     }
     function lineField(field) {
         const def = fieldDef(field);
@@ -1499,7 +1665,7 @@ function innerForm(options, within, place, outer) {
         }
     }
     /** Whether a way out goes at once: nothing to wait for, no check going, nothing at risk — as in 0.20. */
-    const atOnce = (how, own = false) => !deletes && !checking && !busy(own) && (how.discard === true || !workAtRisk(state, how));
+    const atOnce = (how, own = false) => !deletingShown() && !checking && !busy(own) && (how.discard === true || !workAtRisk(state, how));
     /** The saves on their way, settled: what a load that is not a way out (a conflict's Reload) waits for. */
     async function savesSettled() {
         while (saveRunning)
@@ -1525,10 +1691,13 @@ function innerForm(options, within, place, outer) {
         if (outer)
             return outer.letGo(how, chain);
         // A delete the person chose: their work goes with the record, unasked.
-        if (deletes) {
+        if (deletingShown()) {
             forget();
             return true;
         }
+        // The person's own Discard stops the files on their way, never waits for them.
+        if (how.discard)
+            clearFiles();
         const own = chain.includes('on.beforeSave');
         if (atOnce(how, own)) {
             if (how.discard)
@@ -1571,13 +1740,46 @@ function innerForm(options, within, place, outer) {
             forget();
         return yes;
     }
-    /** Let go of the person's work at risk: files on their way stop, changes set aside go, changes no save took are asked about no more. */
+    /**
+     * Let go of the person's work at risk: files on their way stop, changes set aside go, a conflict's changes are
+     * asked about no more, and the changes no save took go back to the record as the last save left it — so what a
+     * dialog or a page in place hands back once it saved is the record as saved, never the change let go.
+     */
     function forget() {
+        const back = unsentLetGo();
         clearFiles();
         personal.clear();
+        personalLines.clear();
         filed.clear();
-        if (state.setAside !== null || state.unsent.length)
-            set({ setAside: null, unsent: [] });
+        if (back)
+            writeValues({ ...state.values, ...back });
+        // Text left that does not read goes too: each box shows what its field holds.
+        const unread = Object.keys(state.unread).length ? { unread: {} } : {};
+        if (state.setAside !== null || state.unsent.length || state.conflict !== null || unread.unread)
+            set({ setAside: null, unsent: [], conflict: null, ...unread });
+    }
+    /** The fields holding the person's changes no save took, as the record as last saved holds them: their lines alone, for a table. */
+    function unsentLetGo() {
+        if (!state.unsent.length)
+            return null;
+        const out = {};
+        for (const name of state.unsent) {
+            const from = sentAs ?? baseline;
+            const keys = personalLines.get(name);
+            out[name] = keys && !personal.has(name) ? linesAsSent(state.values[name], from[name], keys) : structuredCopy(from[name]);
+        }
+        return out;
+    }
+    /** A table with these lines as sent: changed ones as they were, added ones gone, ones taken away back in their place. */
+    function linesAsSent(value, sent, keys) {
+        const was = sent ?? [];
+        const of = (key) => was.find((line) => line.key === key);
+        const out = (value ?? []).filter((line) => !keys.has(line.key) || of(line.key)).map((line) => (keys.has(line.key) ? structuredCopy(of(line.key)) : line));
+        was.forEach((line, at) => {
+            if (keys.has(line.key) && !out.some((other) => other.key === line.key))
+                out.splice(Math.min(at, out.length), 0, structuredCopy(line));
+        });
+        return out;
     }
     /** The check as a step meets it: null to go on — at once when nothing is at risk — else why the run stops. */
     function letGoStep(chain) {
@@ -1585,12 +1787,19 @@ function innerForm(options, within, place, outer) {
         return go === true ? null : go.then((yes) => (yes ? null : kept()));
     }
     const kept = () => ({ reason: 'no', message: messages.discardChanges });
-    /** Load the record again, once the check let what is shown go. */
-    function loadAgain(again, chain = []) {
+    /**
+     * A step's own move — the record loaded again, or another shown — once the check let what is shown go: kept, the
+     * person kept their work; replaced, another record was shown before it ended (the run's steps are not for that one).
+     */
+    async function ownMove(chain, move) {
         const go = letGo({}, chain);
-        if (go === true)
-            return load(again).then(() => true);
-        return go.then((yes) => (yes ? load(again).then(() => true) : false));
+        if (go !== true && !(await go))
+            return kept();
+        // The record it shows is a generation of its own, made as it starts: another made before it ends replaced it.
+        const moving = move();
+        const mine = generation;
+        await moving;
+        return mine === generation ? null : replaced();
     }
     /**
      * The host's close, as every `close` step reaches it: the form takes it
@@ -1612,6 +1821,10 @@ function innerForm(options, within, place, outer) {
         const go = letGo({}, chain);
         return go === true ? shut() : go.then((yes) => (yes ? shut() : kept()));
     }
+    /** Why a run stops whose record was replaced while it went on — quietly, when the form was closed. */
+    function replaced() {
+        return disposed ? { reason: 'closed' } : { reason: 'cannot', message: messages.recordReplaced };
+    }
     /** The record a record step asks the data source about. */
     const record = () => ({ model: page.data.model, id: state.recordId, fields });
     async function post(message) {
@@ -1634,18 +1847,30 @@ function innerForm(options, within, place, outer) {
         recordId: () => state.recordId,
         reading,
         today,
-        write: (values) => write(values, 'step'),
+        // A step's write of a field takes the person's change in it over — unless the step works that change out: the
+        // page's `change` steps, set off by it, as the source's onchange does.
+        write: (values, chain) => write(values, 'step', worksOut(chain)),
         store: (values) => store(values),
+        // The person's own change: the field's, or a line of it (a claim by line): put back, the whole field is theirs
+        // again — at risk, asked about — never less than it was.
+        mine: (field) => personal.has(field) || personalLines.has(field),
+        putBack(values, mine) {
+            write(values, 'step');
+            for (const name of mine)
+                noteOrigin(name, 'person', {});
+        },
         addLine: (field, values) => void addLine(field, values, 'step'),
         check,
+        typedFirst,
         save: saving,
         generation: () => generation,
-        gone: () => (disposed ? { reason: 'closed' } : { reason: 'cannot', message: messages.recordReplaced }),
+        gone: replaced,
         async reload(chain) {
             if (state.recordId == null)
                 return { reason: 'cannot', message: 'The record is not saved yet: there is nothing to load again' };
-            if (!(await loadAgain(true, chain)))
-                return kept();
+            const stopped = await ownMove(chain, () => load(true));
+            if (stopped)
+                return stopped;
             return state.status === 'error' ? { reason: 'cannot', message: state.error ?? 'The record could not be loaded again' } : null;
         },
         reset(chain) {
@@ -1666,24 +1891,32 @@ function innerForm(options, within, place, outer) {
         changed: () => state.dirty.length > 0 || state.uploads.some(uploadGoing),
         letGo: letGoStep,
         async deleting(remove, done) {
-            deletes++;
+            const of = generation;
+            const shown = shownNow();
+            deleting.set(of, (deleting.get(of) ?? 0) + 1);
             try {
                 const out = await remove();
-                // Deleted: what the person had not saved in it goes with it. Refused, it stays theirs.
-                if (done(out))
+                // Deleted: what the person had not saved in it goes with it. Refused, it stays theirs. Another record shown
+                // meanwhile keeps what was typed in it.
+                if (done(out) && shown())
                     forget();
                 return out;
             }
             finally {
-                deletes--;
+                const left = (deleting.get(of) ?? 1) - 1;
+                if (left)
+                    deleting.set(of, left);
+                else
+                    deleting.delete(of);
             }
         },
         ...(options.dataSource?.archive && page.data.kind === 'record' ? { archive: (archive) => track((options.dataSource?.archive)({ ...record(), archive })) } : {}),
         ...(options.dataSource?.copy && page.data.kind === 'record' ? { copy: async () => (await track((options.dataSource?.copy)(record()))).id } : {}),
         ...(options.dataSource?.delete && page.data.kind === 'record' ? { remove: () => track((options.dataSource?.delete)(record())) } : {}),
         async showRecord(id, chain) {
-            if (!(await openRecord(id, chain)))
-                return kept();
+            const stopped = await ownMove(chain, () => showNow(id));
+            if (stopped)
+                return stopped;
             return state.status === 'error' ? { reason: 'cannot', message: state.error ?? 'The record could not be loaded' } : null;
         },
         told(event, id) {
@@ -1702,8 +1935,24 @@ function innerForm(options, within, place, outer) {
         wordsOf: (field) => wordsOfValue(fieldDef(field), state.values[field]),
         barred: (right) => (state.can?.[right] === false ? state.can.reason ?? messages[MAY_NOT[right]] : null),
     });
-    const moment = createMoments((key, list, chain) => runTop(list, { id: key, chain }));
-    /** A press of a button: its confirmation first, then its steps and its app action as a final call, in `scope`. */
+    // A moment's run is on the record it was set off on: one set off again while its run goes, and run after it, is let
+    // go when another record is shown by then (its steps were for that one).
+    const moment = createMoments((key, list, chain, on) => runTop(list, { id: key, chain, generation: on }), () => generation);
+    /**
+     * Whether steps do something before their first save — set a status, call the app, open a page — so a record's
+     * button made of them saves first. Steps that start with the save (Save and close), or only check before it, need
+     * no save before them: theirs is the first.
+     */
+    function actsBeforeSaving(list) {
+        const first = list.findIndex((step) => step.do === 'save');
+        return first > 0 && list.slice(0, first).some((step) => step.do !== 'check');
+    }
+    /**
+     * A press of a button: its confirmation first, then its steps and its app action as a final call, in `scope`. A
+     * record's button whose steps act and then save saves the record first when it is new or changed, as Flectra's
+     * button does: refused — a field it requires left empty — none of its steps run, so nothing it does happens to a
+     * record that cannot be saved.
+     */
     function press(source, scope) {
         const list = [...(source.steps ?? [])];
         if (source.action !== undefined)
@@ -1714,12 +1963,37 @@ function innerForm(options, within, place, outer) {
             list.push({ do: builtin });
         const asked = builtin === 'archive' ? messages.archiveConfirm : builtin === 'delete' ? messages.deleteConfirm : undefined;
         const confirm = 'confirm' in source && source.confirm !== undefined ? source.confirm : asked;
+        // On the record it was pressed on: another shown while its question is asked, it does nothing to that one.
+        scope.generation ??= generation;
+        // Pressed by the person: what is typed is read before a step reads the form or hands its values on.
+        scope.typed ??= 'first';
         return track((async () => {
             if (confirm && !(await runner.ask(confirm))) {
                 const result = { done: false, reason: 'no', message: confirm };
                 emit('run', { id: scope.id, steps: list, result });
                 return result;
             }
+            const saveFirst = page.data.kind === 'record' && actsBeforeSaving(list);
+            // What is typed is read first, as the run reads it before its first step that reads the form (run.ts): text
+            // that does not read stops it with `check`, said under its box — before the save that comes first, and any step.
+            if (saveFirst && scope.typed === 'first') {
+                const unread = await typedFirst();
+                if (unread) {
+                    const at = Math.max(0, list.findIndex((step) => step.do !== 'check'));
+                    const result = { done: false, stoppedAt: at, step: list[at], reason: unread.reason, ...(unread.message !== undefined ? { message: unread.message } : {}) };
+                    emit('run', { id: scope.id, steps: list, result });
+                    return result;
+                }
+            }
+            // Then the save first, then the steps.
+            if (saveFirst && (state.recordId == null || state.dirty.length > 0 || Object.keys(state.unread ?? {}).length > 0 || state.uploads.some(uploadGoing))) {
+                const first = await saving(scope.chain);
+                if (first) {
+                    const result = { done: false, step: { do: 'save' }, reason: first.reason, ...(first.message !== undefined ? { message: first.message } : {}), ...(first.error !== undefined ? { error: first.error } : {}) };
+                    emit('run', { id: scope.id, steps: list, result });
+                    return result;
+                }
+            }
             return runTop(list, scope);
         })());
     }
@@ -1745,6 +2019,7 @@ function innerForm(options, within, place, outer) {
         openRecord: (id) => track(openRecord(id)),
         leave: (how) => Promise.resolve(letGo(how)),
         leaveNow: (how = {}) => (outer ? outer.leaveNow(how) : atOnce(how)),
+        recordShown: shownNow,
         post,
         setEditing(next) {
             if (next === editing)
@@ -1773,7 +2048,7 @@ function innerForm(options, within, place, outer) {
             }
             const own = shown.map(unticked).find(Boolean) ??
                 shown.map((node) => checkInput(page.fields[name], node.source, state.values[name], messages)).find(Boolean) ??
-                checkValue(checked(name), state.values[name], shown.some((node) => nodeState(node.id).required), messages, today());
+                checkValue(checked(name), state.values[name], shown.some((node) => nodeState(node.id).required), messages, today(), shownWidget(shown));
             return own ?? shown.map((node) => ruleCheck(node).error).find((error) => error !== undefined) ?? null;
         },
         setUnread(path, unread) {
@@ -1819,6 +2094,12 @@ function innerForm(options, within, place, outer) {
             };
         },
         settle: () => readTyped() ?? Promise.resolve(),
+        botCheck(seen) {
+            if (seen.honeypot !== undefined)
+                bot.honeypot = seen.honeypot;
+            if (seen.captcha !== undefined)
+                bot.captcha = seen.captcha;
+        },
         reading: () => readingNow > 0 || [...attached.values()].some((part) => part.inner.form.reading()),
         validate() {
             readTyped();
@@ -1828,6 +2109,27 @@ function innerForm(options, within, place, outer) {
         },
         save: () => track(save()),
         canUpload: () => typeof options.dataSource?.upload === 'function',
+        today,
+        canFindSlots: () => typeof options.dataSource?.slots === 'function',
+        findSlots(field, ask) {
+            const source = options.dataSource;
+            if (!source?.slots)
+                return Promise.reject(new Error('The data source has no slots()'));
+            const def = page.fields[field];
+            const { schedule = field, length, between, from, to } = ask;
+            return source.slots({
+                model: page.data.kind === 'record' ? page.data.model : '',
+                field,
+                recordId: state.recordId,
+                schedule,
+                from,
+                to,
+                timeZone: (def?.type === 'datetime' && def.timeZone) || page.timeZone || ownZone(),
+                ...(length ? { length } : {}),
+                ...(between ? { between } : {}),
+                values: structuredCopy(state.values),
+            });
+        },
         upload: (field, files, how = {}) => uploads.start(field, files, how),
         uploading: (field) => state.uploads.filter((upload) => upload.field === field && !upload.line),
         cancelUpload(id) {
@@ -1853,8 +2155,11 @@ function innerForm(options, within, place, outer) {
             // 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++;
             personal.clear();
+            personalLines.clear();
             filed.clear();
             sentAs = null;
+            // 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: {} });
         },
@@ -1867,7 +2172,7 @@ function innerForm(options, within, place, outer) {
             const lines = (state.values[field] ?? []).map((line) => line.key === key ? { ...line, values: { ...line.values, [name]: structuredCopy(value) } } : line);
             writeValues({ ...state.values, [field]: lines });
             afterEdit(field);
-            changed(field, 'person');
+            changed(field, 'person', { line: key });
         },
         moveLine(field, key, to) {
             const def = lineField(field);
@@ -1912,10 +2217,10 @@ function innerForm(options, within, place, outer) {
             const lines = (state.values[field] ?? []).filter((line) => line.key !== key);
             writeValues({ ...state.values, [field]: lines });
             afterEdit(field);
-            changed(field, 'person');
+            changed(field, 'person', { line: key });
         },
         async search(field, query, limit = 8, options = {}) {
-            return runSearch(fieldDef(field), field, context(), query, limit, options.model, options.ids);
+            return runSearch(fieldDef(field), field, context(), query, limit, options);
         },
         async previewLine(field, key, values) {
             lineField(field);
@@ -1940,7 +2245,7 @@ function innerForm(options, within, place, outer) {
             const line = (state.values[field] ?? []).find((l) => l.key === key);
             if (!line)
                 throw new Error(`"${field}" has no line "${key}"`);
-            return runSearch(sub, subfield, lineContext(line.values, def.fields, context(), line.id ?? null), query, limit, options.model, options.ids);
+            return runSearch(sub, subfield, lineContext(line.values, def.fields, context(), line.id ?? null), query, limit, options);
         },
         canCreate: (field) => creatable(page.fields[field]) !== null,
         quickCreate: (field, typed) => runCreate(page.fields[field], field, typed, page.fields[field] ? createValuesOf(field) : {}),
@@ -2102,7 +2407,7 @@ function innerForm(options, within, place, outer) {
                 lines: { field: source.field, keys: [...keys], ids: lines.flatMap((line) => (line.id === undefined ? [] : [line.id])), values: lines.map((line) => structuredCopy(line.values)) },
             });
         },
-        run: (list, context = {}) => track(runTop(list, { id: context.id ?? 'run', chain: [], ...(context.recordIds ? { recordIds: [...context.recordIds] } : {}) })),
+        run: (list, context = {}) => track(runTop(list, { id: context.id ?? 'run', chain: [], typed: 'first', ...(context.recordIds ? { recordIds: [...context.recordIds] } : {}) })),
         shown(tab) {
             // A wizard's steps are told by the form itself, as they are entered.
             if (steps.includes(tab))
@@ -2129,20 +2434,36 @@ function innerForm(options, within, place, outer) {
         },
         async reloadTheirs() {
             // A save on its way first: its answer is not dropped by the load.
+            const asked = shownNow();
             await savesSettled();
-            // The person's changes, kept before theirs are loaded over them.
+            if (!asked())
+                return false;
+            // What is still typed is the person's too: read, a name looked up waited for, before theirs are loaded.
+            const waiting = readTyped();
+            if (waiting)
+                await waiting;
+            if (!asked())
+                return false;
+            // The person's changes, kept before theirs are loaded over them; and text they left that does not read.
             const mine = {};
             for (const name of state.dirty)
                 mine[name] = structuredCopy(state.values[name]);
-            await track(load(true));
-            if (state.status !== 'ready')
+            const typed = state.unread;
+            // The record loaded again is a record shown anew: what is set aside is laid on it alone.
+            const loading = load(true);
+            const loaded = generation;
+            await track(loading);
+            if (loaded !== generation || state.status !== 'ready')
                 return false;
             // Set aside where theirs differ from mine: a change they made the same way is no loss.
             const aside = { ...(state.setAside ?? {}) };
             for (const [name, value] of Object.entries(mine))
                 if (!sameValue(fields[name], value, state.values[name]))
                     aside[name] = value;
-            set({ conflict: null, saveProblem: null, setAside: Object.keys(aside).length ? aside : null });
+            // Text that does not read is no value to set aside: it stays in its box, unread with why, over their value —
+            // never dropped unsaid. A line of theirs no longer there takes its cells' text with it.
+            const unread = Object.fromEntries(Object.entries(typed).filter(([path]) => valueAt(state.values, path) !== gone));
+            set({ conflict: null, saveProblem: null, setAside: Object.keys(aside).length ? aside : null, ...(Object.keys(unread).length ? { unread } : {}) });
             return true;
         },
         async keepMine() {
@@ -2153,6 +2474,7 @@ function innerForm(options, within, place, outer) {
             const source = options.dataSource;
             if (conflict && !told) {
                 if (source?.load && state.recordId != null && page.data.kind === 'record') {
+                    const shown = shownNow();
                     try {
                         const now = loadedRecordOf(await track(source.load({ model: page.data.model, id: state.recordId, fields })));
                         told = now.values;
@@ -2161,6 +2483,9 @@ function innerForm(options, within, place, outer) {
                     catch {
                         // Unread: said below.
                     }
+                    // Read, or not, once another record is shown or the values let go: nothing is laid, nothing saved.
+                    if (!shown())
+                        return false;
                 }
                 // Still unread: saving now would go over work this person never saw. Nothing is saved; they are told, and choose again.
                 if (!told) {
@@ -2223,7 +2548,8 @@ function innerForm(options, within, place, outer) {
             const given = state.values[part.name];
             // A record of no model of its own: its links search and its lists load, but it never loads, saves, sends or recalculates alone.
             const made = innerForm({
-                page: { ...inner, data: { kind: 'responses' } },
+                // In the record's time zone, unless it names its own.
+                page: { ...inner, data: { kind: 'responses' }, ...(inner.timeZone || !page.timeZone ? {} : { timeZone: page.timeZone }) },
                 dataSource: options.dataSource,
                 values: isRecord(given) ? given : {},
                 onAction: options.onAction,
@@ -2236,7 +2562,7 @@ function innerForm(options, within, place, outer) {
             // 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}.` }, 
             // Its ways out are the record's: through this form's check.
-            { letGo, close, leaveNow: (how) => atOnce(how) });
+            { letGo, close, leaveNow: (how) => atOnce(how), recordShown: shownNow });
             attached.set(id, { name: part.name, inner: made });
             // A change inside it is told as a change of its answers here, whoever made it.
             made.form.on('change', ({ by }) => {