@fieldia/core 0.21.0 → 0.22.0

package/src/lib/record/form.mjs

@@ -1,3 +1,4 @@
+import { upgradePage } from '../format/upgrade.mjs';
 import { compileModifier } from '../expression/modifier.mjs';
 import { localDay } from '../expression/functions.mjs';
 import { checkProperties, checkValue } from './check.mjs';
@@ -11,25 +12,54 @@ import { resolveFilter } from './filter.mjs';
 import { rolesAllow } from './roles.mjs';
 import { compileFieldTone, compileTable } from './cells.mjs';
 import { fill, MESSAGES } from './messages.mjs';
-import { saveProblemOf } from './data-source.mjs';
+import { loadedRecordOf, saveProblemOf, } from './data-source.mjs';
+import { createUploads, fileBytesIn, uploadGoing, withoutFileBytes } from './uploads.mjs';
 import { hostScheduler } from './scheduler.mjs';
 import { createMoments, createRunner } from './run.mjs';
 import { emptyValue, initialValues, isEmpty, lineKind, structuredCopy, } from './values.mjs';
+/**
+ * Whether leaving the record now would lose the person's work: changes not
+ * saved, files still on their way to the store, or changes Reload set aside
+ * and not yet put back or let go, or text left in a box that does not read.
+ * Every way out of a record asks this.
+ */
+export function unsavedWork(state) {
+    return state.dirty.length > 0 || Object.keys(state.unread ?? {}).length > 0 || state.setAside != null || (state.uploads ?? []).some(uploadGoing);
+}
+/**
+ * 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.
+ */
+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));
+}
 /**
  * The record state behind a page: values, what changed, what is visible and
  * required, errors, loading and saving. No DOM and no framework — every
  * binding renders from `getState()` and calls these methods.
  */
 export function createForm(options) {
-    return innerForm(options, []).form;
+    // A page in an older format is read in the current one (upgradePage): the same object when it already is.
+    const page = upgradePage(options.page);
+    return innerForm(page === options.page ? options : { ...options, page }, []).form;
 }
 /** 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);
 /** A saved form's answers, as the one value they are in the form round it. */
 const asValue = (values) => values;
-/** `within` are the pages round this one, outermost first: a page among them placed again would hold itself. */
-function innerForm(options, within) {
+/**
+ * `within` are the pages round this one, outermost first: a page among them
+ * placed again would hold itself. `place`, for a saved form placed in a
+ * record: the record its files are stored for. `outer`, the form round it:
+ * its ways out go through that one's check.
+ */
+function innerForm(options, within, place, outer) {
     const { page } = options;
     const scheduler = options.scheduler ?? hostScheduler;
     const messages = options.messages ?? MESSAGES.en;
@@ -100,7 +130,9 @@ function innerForm(options, within) {
     let editing = options.editing !== false;
     /** The record a line's form is of, as its conditions read it: worked out once. */
     const parentContext = options.parent ? recordContext(options.parent.values, options.parent.fields, { recordId: options.parent.id ?? null, user: options.user, context: options.context }) : undefined;
-    const about = () => ({ recordId: started ? state.recordId : (options.recordId ?? null), user: options.user, editing, context: options.context, parent: parentContext });
+    /** Whether the record is being edited now: not while a view locks it, nor when its source lets the person only read it. */
+    const editingNow = () => editing && !(started && state.can?.edit === false);
+    const about = () => ({ recordId: started ? state.recordId : (options.recordId ?? null), user: options.user, editing: editingNow(), context: options.context, parent: parentContext });
     const computed = compileComputed(page, today, about);
     const setWhen = compileSetWhen(page, today, about);
     /** The saved forms placed on the page, by the part's id: each one's answers sit under its name, as JSON. */
@@ -235,9 +267,148 @@ function innerForm(options, within) {
         saveProblem: null,
         choices: {},
         definitions: {},
+        uploads: [],
+        version: null,
+        can: null,
+        conflict: null,
+        setAside: null,
+        unsent: [],
+        leaving: false,
         unread: {},
     };
     started = true;
+    /**
+     * Each record shown — opened, loaded again, a new one — is a generation of
+     * its own: a save's answer, or a call's, started in another is not laid
+     * over it. What follows is kept for the generation shown, and starts again
+     * with the next.
+     */
+    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. */
+    const personal = new Set();
+    /** 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;
+    /** 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. */
+    const unstoredShown = new Set();
+    /** The record this form's files are for: its own, or — a saved form placed in one — that record, its fields under the part's name. */
+    const where = place ?? { model: () => (page.data.kind === 'record' ? page.data.model : page.id), recordId: () => state.recordId, under: '' };
+    /** This form's own files on their way; the state's `uploads` adds those of each saved form placed in it. */
+    let ownUploads = [];
+    /** The problem a save was stopped by for files that did not reach the store: it goes once none of them is one. */
+    let filesProblem = null;
+    /** Above 0 while a save stores the bytes held in saved forms placed here: their links in place of bytes are no change of the person's. */
+    let quietParts = 0;
+    /** Files on their way to the store: uploads.ts. */
+    const uploads = createUploads({
+        source: () => options.dataSource,
+        model: where.model,
+        recordId: where.recordId,
+        under: where.under,
+        lineId: (field, key) => (state.values[field] ?? []).find((line) => line.key === key)?.id,
+        fileField(field, line) {
+            const def = line ? (fields[line.field]?.type === 'one2many' ? fields[line.field].fields[field] : undefined) : fields[field];
+            return def?.type === 'binary' || def?.type === 'image' ? def : null;
+        },
+        read: (field, line) => (line ? (state.values[line.field] ?? []).find((l) => l.key === line.key)?.values[field] : state.values[field]),
+        write(field, line, value, quiet) {
+            if (!quiet) {
+                // A file the store holds now, picked by the person: at risk until a save sends it.
+                filed.add(line ? line.field : field);
+                return line ? form.updateLine(line.field, line.key, field, value) : form.setValue(field, value);
+            }
+            // A link in place of the bytes, as a save stores them: nothing else follows from it.
+            const values = line ? { [line.field]: (state.values[line.field] ?? []).map((l) => (l.key === line.key ? { ...l, values: { ...l.values, [field]: value } } : l)) } : { [field]: value };
+            writeValues({ ...state.values, ...values });
+        },
+        changed(list) {
+            ownUploads = list;
+            filesChanged();
+        },
+        track,
+    });
+    /**
+     * Files on their way changed, here or in a saved form placed here: the
+     * state shows them all, and a file sent again, or taken away, takes its
+     * problem with it — and the save it stopped is no longer said to be stopped
+     * once none of its files is a problem.
+     */
+    function filesChanged() {
+        const problems = fileProblems();
+        const gone = [...unstoredShown].filter((key) => !(key in problems));
+        for (const key of gone)
+            unstoredShown.delete(key);
+        const errors = gone.length ? Object.fromEntries(Object.entries(state.errors).filter(([key]) => !gone.includes(key))) : null;
+        const stopped = filesProblem;
+        const mended = stopped !== null && state.saveProblem === stopped && !Object.keys(stopped.fields ?? {}).some((key) => key in problems);
+        if (mended)
+            filesProblem = null;
+        set({ uploads: allUploads(), ...(errors ? { errors } : {}), ...(mended ? { status: 'ready', error: null, saveProblem: null } : {}) });
+    }
+    /** Every file on its way: this form's, then each saved form's placed in it, its id and field under the part's name. */
+    function allUploads() {
+        if (!attached.size)
+            return ownUploads;
+        const all = [...ownUploads];
+        for (const part of attached.values())
+            for (const upload of part.inner.form.getState().uploads)
+                all.push(underPart(part.name, upload));
+        return all;
+    }
+    /** What stops a save for files: this form's, and each saved form's placed in it under `name.field`. */
+    function fileProblems() {
+        const found = uploads.problems(messages);
+        for (const part of attached.values())
+            for (const [key, message] of Object.entries(part.inner.files.problems()))
+                found[`${part.name}.${key}`] = message;
+        return found;
+    }
+    const filesGoing = () => uploads.going() || [...attached.values()].some((part) => part.inner.files.going());
+    async function filesSettled() {
+        while (filesGoing())
+            await Promise.all([uploads.settled(), ...[...attached.values()].map((part) => part.inner.files.settled())]);
+    }
+    /** Store each file still held as its bytes in these fields — a saved form placed here holding one, among them — and wait for them all. */
+    async function storeBytes(names) {
+        quietParts++;
+        try {
+            const inParts = [...attached.values()].filter((part) => names.includes(part.name)).map((part) => part.inner.files.storeBytes());
+            await Promise.all([uploads.storeBytes(fileBytesIn(fields, state.values, names)), ...inParts]);
+        }
+        finally {
+            quietParts--;
+        }
+    }
+    /** Values as a draft keeps them where files are stored apart: no file's bytes, a saved form's answers included. */
+    function draftOf(values) {
+        const kept = withoutFileBytes(fields, values);
+        for (const part of attached.values())
+            if (isRecord(kept[part.name]))
+                kept[part.name] = asValue(part.inner.files.draft(kept[part.name]));
+        return kept;
+    }
+    /** Stop every upload, here and in the saved forms placed here. */
+    function clearFiles() {
+        filesProblem = null;
+        uploads.clear();
+        for (const part of attached.values())
+            part.inner.files.clear();
+    }
+    /** The saved form placed here an upload's id names (`consent/upload-3`), with the id it knows it by; null for this form's own. */
+    function partUpload(id) {
+        const at = id.indexOf('/');
+        const part = at < 0 ? undefined : [...attached.values()].find((p) => p.name === id.slice(0, at));
+        return part ? { form: part.inner.form, id: id.slice(at + 1) } : null;
+    }
     /** Field errors a refused save brought, each kept until its field changes from the value it was refused with. */
     let serverErrors = {};
     let lineKeys = 0;
@@ -262,6 +433,12 @@ function innerForm(options, within) {
         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) {
+            const unsent = unsentNow();
+            if (!sameList(unsent, state.unsent))
+                state = { ...state, unsent };
+        }
         // The problems found inside a saved form are shown on it, beside its own fields.
         if (state.errors !== shown)
             for (const part of attached.values())
@@ -288,11 +465,62 @@ function innerForm(options, within) {
     }
     /** 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);
         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. */
+    function newGeneration() {
+        generation++;
+        personal.clear();
+        filed.clear();
+        compared.clear();
+        sentAs = null;
+    }
+    /** 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.
+     */
+    function unsentNow() {
+        if (!personal.size)
+            return [];
+        const out = [];
+        for (const name of Object.keys(fields)) {
+            if (!personal.has(name))
+                continue;
+            const from = sentAs ?? (filedIn(name) ? baseline : null);
+            if (from && differs(name, state.values[name], from[name]))
+                out.push(name);
+        }
+        return out;
+    }
+    function differs(name, value, sent) {
+        const known = compared.get(name);
+        if (known && known.value === value && known.sent === sent)
+            return known.differs;
+        const verdict = value !== sent && !sameValue(fields[name], value, sent);
+        compared.set(name, { value, sent, differs: verdict });
+        return verdict;
+    }
+    /** `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
+            personal.delete(field);
+        refreshUnsent();
+    }
     /** A wizard step entered: told to the app, and its `show` steps run. */
     function tellStep(chain) {
         const step = state.step;
@@ -374,10 +602,10 @@ function innerForm(options, within) {
     }
     /** The values as expressions read them, and what else they read: the record's id, the person, the lines' rows, today. */
     function reading() {
-        if (contextCache?.values !== state.values || contextCache.recordId !== state.recordId || contextCache.editing !== editing) {
+        if (contextCache?.values !== state.values || contextCache.recordId !== state.recordId || contextCache.editing !== editingNow()) {
             const values = state.values;
             const context = recordContext(values, page.fields, about());
-            contextCache = { values, recordId: state.recordId, editing, context, env: expressionEnv(values, page.fields, today) };
+            contextCache = { values, recordId: state.recordId, editing: editingNow(), context, env: expressionEnv(values, page.fields, today) };
         }
         return contextCache;
     }
@@ -407,6 +635,14 @@ function innerForm(options, within) {
             readonly = index.get(parent)?.readonly.evaluate(ctx, env) ?? false;
         }
         const def = node.field ? page.fields[node.field] : undefined;
+        // What the record's source lets this person do: a field hidden from them or locked, a button that would do what they may not.
+        const can = state.can;
+        if (can) {
+            if ((node.field !== undefined && can.hiddenFields?.includes(node.field)) || node.does?.some((right) => can[right] === false))
+                invisible = true;
+            if ((node.kind === 'field' || node.kind === 'form') && (can.edit === false || (node.field !== undefined && can.readonlyFields?.includes(node.field) === true)))
+                readonly = true;
+        }
         return {
             invisible,
             readonly: readonly || (def !== undefined && lockedField(def)),
@@ -702,6 +938,11 @@ function innerForm(options, within) {
             else
                 delete serverErrors[name];
         }
+        // A file that did not reach the store stays said under its field.
+        const unstoredNow = fileProblems();
+        for (const key of unstoredShown)
+            if (unstoredNow[key])
+                kept[key] ??= unstoredNow[key];
         return kept;
     }
     function scheduleDraft() {
@@ -712,9 +953,27 @@ function innerForm(options, within) {
             scheduler.clearTimeout(draftTimer);
         draftTimer = scheduler.setTimeout(() => {
             draftTimer = null;
-            drafts.store.setItem(draftKey(), JSON.stringify({ savedAt: new Date().toISOString(), values: state.values }));
+            // Where files are stored apart, never a file's bytes: they would fill the browser's store (uploads.ts). Without, kept as always.
+            // A store that is full anyway keeps no draft.
+            const values = options.dataSource?.upload ? draftOf(state.values) : state.values;
+            try {
+                drafts.store.setItem(draftKey(), JSON.stringify({ savedAt: new Date().toISOString(), values }));
+            }
+            catch {
+                // The draft is a convenience: the form goes on without it.
+            }
         }, drafts.delayMs ?? 400);
     }
+    /** The values with a draft's over them: a field it left out — a file's bytes — as the record holds it, in a saved form placed here too. */
+    function withDraft(kept) {
+        const values = { ...state.values, ...kept };
+        for (const part of attached.values()) {
+            const now = state.values[part.name];
+            if (isRecord(now) && isRecord(kept[part.name]))
+                values[part.name] = asValue({ ...now, ...kept[part.name] });
+        }
+        return values;
+    }
     function forgetDraft() {
         if (draftTimer !== null)
             scheduler.clearTimeout(draftTimer);
@@ -737,13 +996,14 @@ function innerForm(options, within) {
             return;
         }
         if (drafts.restore === 'auto')
-            writeValues({ ...state.values, ...draft.values }, { draft: null }, true);
+            writeValues(withDraft(draft.values), { draft: null }, true);
         else
             set({ draft: { savedAt: draft.savedAt } });
     }
     function scheduleAutosave() {
         const autosave = options.autosave;
-        if (!autosave || page.data.kind !== 'record')
+        // A record the person may not change is never saved unasked: it would only be refused.
+        if (!autosave || page.data.kind !== 'record' || state.can?.edit === false)
             return;
         if (autosaveTimer !== null)
             scheduler.clearTimeout(autosaveTimer);
@@ -817,74 +1077,202 @@ function innerForm(options, within) {
     async function save(chain = []) {
         return (await saving(chain)) === null;
     }
+    /** Every value, for a source that saves whole records: those of fields hidden from the person, which they never had, left out. */
+    function sentValues() {
+        const values = structuredCopy(state.values);
+        for (const name of state.can?.hiddenFields ?? [])
+            delete values[name];
+        return values;
+    }
+    /** A conflict as the form tells it: what they changed since the record was opened, and what both changed. */
+    function conflictOf(conflict) {
+        const theirs = conflict.theirs;
+        const changed = theirs ? Object.keys(fields).filter((name) => name in theirs && !sameValue(fields[name], theirs[name], baseline[name])) : [];
+        const both = changed.filter((name) => state.dirty.includes(name) && !sameValue(fields[name], theirs[name], state.values[name]));
+        return { version: conflict.version, ...(theirs ? { theirs } : {}), changed, both };
+    }
     /**
      * Save, or send: null once done, or why not. The page's `beforeSave` steps
      * run first — before its own check, so they may fill in what it asks for —
      * and a stop keeps it unsaved; `afterSave` runs once it is saved.
      */
-    async function saving(chain) {
+    /** The save running now: the next one waits for it. */
+    let saveRunning = null;
+    /**
+     * One save at a time: a second — Ctrl+Enter pressed twice, or while the
+     * first waits for files — waits for the first, then saves what is left to
+     * save with the version the first got back, never as someone else's. A save
+     * the page's own beforeSave steps ask for runs inside the one that set them off.
+     */
+    function saving(chain) {
+        if (chain.includes('on.beforeSave'))
+            return savingNow(chain);
+        const before = saveRunning;
+        const mine = (async () => {
+            if (before)
+                await before;
+            return savingNow(chain);
+        })();
+        const done = mine.then(() => undefined, () => undefined);
+        saveRunning = done;
+        void done.then(() => {
+            if (saveRunning === done)
+                saveRunning = null;
+        });
+        return mine;
+    }
+    async function savingNow(chain) {
+        // A record its source does not let this person change is refused here, in its words or the form's: no source is asked.
+        if (page.data.kind === 'record' && state.can?.edit === false) {
+            const problem = { kind: 'rule', message: state.can.reason ?? messages.mayNotEdit };
+            set({ status: 'error', error: problem.message, saveProblem: problem, conflict: null });
+            return { reason: 'save', message: problem.message };
+        }
         // 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;
+        // 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();
+            set({ status: 'ready' });
+        }
         if (page.on?.beforeSave) {
             const before = await moment('on.beforeSave', page.on.beforeSave, chain, false);
             if (!before.done) {
                 // A check's problems, or an inner save's, are shown already; any other stop is this save's problem.
                 if (before.reason !== 'check' && before.reason !== 'save') {
                     const problem = { kind: 'stopped', reason: before.reason, message: before.message ?? '' };
-                    set({ status: 'error', error: problem.message || null, saveProblem: problem });
+                    set({ status: 'error', error: problem.message || null, saveProblem: problem, conflict: null });
                 }
                 return { reason: 'save', ...(before.message !== undefined ? { message: before.message } : {}) };
             }
         }
-        const errors = collectErrors();
+        // A file that did not reach the store stops it, under its field, with the form's own checks.
+        const errors = { ...collectErrors(), ...fileProblems() };
         if (Object.keys(errors).length) {
-            set({ errors });
+            set({ errors, ...unstored(errors) });
             return { reason: 'save', message: Object.values(errors)[0] };
         }
         const source = options.dataSource;
         serverErrors = {};
-        set({ status: 'saving', errors: {}, error: null, saveProblem: null });
+        set({ status: 'saving', errors: {}, error: null, saveProblem: null, conflict: null });
+        /** The generation the record was in when this save went to the source. */
+        let at = generation;
         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);
+            const failed = fileProblems();
+            if (Object.keys(failed).length) {
+                set({ errors: failed, ...unstored(failed) });
+                return { reason: 'save', message: Object.values(failed)[0] };
+            }
             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 before = state.values;
+                at = generation;
                 await source.submit({ pageId: page.id, values: sent });
+                // 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;
                 forgetDraft();
-                set({ status: 'saved' });
+                // 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 });
                 void track(moment('on.afterSave', page.on?.afterSave, chain, false));
                 return null;
             }
             if (!source?.save)
                 throw new Error('This page has no data source to save to');
+            // What is sent: a change made while it is on its way is not in it, and stays a change to save.
+            const sent = state.values;
+            at = generation;
+            const resetAt = resets;
             const result = await source.save({
                 model: page.data.model,
                 id: state.recordId,
                 fields,
                 changes: changes(),
-                values: structuredCopy(state.values),
+                values: sentValues(),
+                // The version it was opened at, for a source that refuses a save over someone else's.
+                ...(state.recordId != null && state.version ? { version: state.version } : {}),
             });
+            // 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)
+                return null;
             forgetDraft();
-            // Lines the save brings back load again, in their tables' orders, as Flectra's reload after a save.
-            const values = syncParts(startFrom(result.values ? ordered({ ...state.values, ...result.values }, Object.keys(result.values)) : state.values), 'start');
-            baseline = structuredCopy(values);
-            set({ status: 'saved', recordId: result.id, values, dirty: [], warnings: withValues(values, collectWarnings), unread: {} });
+            // Reset by the person meanwhile: the record as it stored it, the reset values never laid over it.
+            const { values, dirty } = afterSave(sent, result.values, resets !== resetAt);
+            // The record as this save left it: what the person changes from here is told against it.
+            sentAs = baseline;
+            // Its version now, for the next save to carry; and what the person may do now, when the save changed that.
+            // The person's changes it did not send are at risk (`unsent`): every way out asks before it leaves them.
+            set({ status: 'saved', recordId: result.id, values, dirty, warnings: withValues(values, collectWarnings), version: result.version ?? null, ...(result.can ? { can: result.can } : {}) });
+            // Changed while it saved: kept in a draft, and saved as any change is.
+            if (dirty.length) {
+                scheduleDraft();
+                scheduleAutosave();
+            }
             emit('save', { recordId: state.recordId, values: state.values });
             void track(moment('on.afterSave', page.on?.afterSave, chain, false));
             return null;
         }
         catch (error) {
             const problem = saveProblemOf(error);
+            // Refused for a record no longer shown: nothing of it is laid over the one shown now.
+            if (at !== generation)
+                return { reason: 'save', message: problem.message };
+            // Refused: what the person changed meanwhile is a change not saved, as the rest.
             const fields = problem.kind === 'fields' ? problem.fields ?? {} : {};
             serverErrors = Object.fromEntries(Object.entries(fields).map(([name, message]) => [name, { message, value: JSON.stringify(state.values[name] ?? null) }]));
-            set({ status: 'error', error: problem.message, saveProblem: problem, errors: { ...fields } });
+            set({ status: 'error', error: problem.message, saveProblem: problem, errors: { ...fields }, ...(problem.conflict ? { conflict: conflictOf(problem.conflict) } : {}) });
             return { reason: 'save', message: problem.message };
         }
     }
+    /**
+     * The record as a save left it — what was sent, with what the save brought
+     * back, lines loaded again in their tables' orders, as Flectra's reload after
+     * a save — as the new starting point. What the person changed while it was
+     * on its way (a file stored meanwhile) was not sent: it is laid over that,
+     * still a change to save, never taken as saved.
+     */
+    function afterSave(sent, back, whole = false) {
+        const stored = (from) => (back ? ordered({ ...from, ...back }, Object.keys(back)) : from);
+        const since = whole ? [] : Object.keys(fields).filter((name) => state.values[name] !== sent[name] && !sameValue(fields[name], state.values[name], sent[name]));
+        if (!since.length) {
+            const values = syncParts(startFrom(stored(whole ? sent : state.values)), 'start');
+            baseline = structuredCopy(values);
+            return { values, dirty: [] };
+        }
+        const record = stored(sent);
+        const mine = { ...record };
+        for (const name of since)
+            mine[name] = keepIds(fields[name], state.values[name], record[name]);
+        const values = syncParts(startFrom(mine), 'start');
+        // The starting point is the record as stored: those fields as it holds them.
+        const base = { ...values };
+        for (const name of since)
+            base[name] = record[name];
+        baseline = structuredCopy(computed.apply(base));
+        return { values, dirty: dirtyFields(values) };
+    }
+    /** A save stopped by files that did not reach the store: shown under their fields, as a refused save's fields are. */
+    function unstored(errors) {
+        const files = fileProblems();
+        const only = Object.fromEntries(Object.entries(errors).filter(([key]) => key in files));
+        for (const key of Object.keys(only))
+            unstoredShown.add(key);
+        if (!Object.keys(only).length)
+            return {};
+        filesProblem = { kind: 'fields', message: Object.values(only)[0], fields: only };
+        return { status: 'error', error: Object.values(only)[0], saveProblem: filesProblem };
+    }
     /** The form has its values: told to the app, its `open` steps run, then the wizard step it shows is told. */
     async function opening() {
         emit('open', { recordId: state.recordId, values: state.values });
@@ -975,8 +1363,9 @@ function innerForm(options, within) {
         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. */
+    /** 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;
         const result = await runner.runSteps(list, scope);
         emit('run', { id: scope.id, steps: list, result });
         return result;
@@ -1035,14 +1424,17 @@ function innerForm(options, within) {
         }
         // Only the latest load is taken: a pager pressed twice shows the record it ended on.
         const seq = ++loads;
-        set({ status: 'loading', error: null });
+        // The record loaded again is shown anew: an answer started for it before is not laid over it.
+        newGeneration();
+        set({ status: 'loading', error: null, unsent: [] });
         try {
-            const loaded = await source.load({ model: page.data.model, id: state.recordId, fields });
+            // A source may give the record's version and what the person may do with it beside its values.
+            const { values: loaded, version, can } = loadedRecordOf(await source.load({ model: page.data.model, id: state.recordId, fields }));
             if (seq !== loads)
                 return;
             // Lines load in their tables' orders; where a person moves them after, they stay.
             baseline = syncParts(startFrom(ordered({ ...initialValues(fields, today()), ...loaded })), 'start');
-            set({ status: 'ready', values: structuredCopy(baseline), dirty: [], errors: {}, warnings: withValues(baseline, collectWarnings), unread: {} });
+            set({ status: 'ready', values: structuredCopy(baseline), dirty: [], errors: {}, warnings: withValues(baseline, collectWarnings), version: version ?? null, can: can ?? null, unread: {} });
             if (again)
                 return;
             offerDraft();
@@ -1054,8 +1446,14 @@ function innerForm(options, within) {
         }
     }
     let loads = 0;
+    /** Another record in this form's place, or a new one, once the one check let what was there go: false when the person kept it. */
+    function openRecord(id, chain = []) {
+        const go = letGo({}, chain);
+        return go === true ? showNow(id) : go.then((yes) => (yes ? showNow(id) : false));
+    }
     /** Another record in this form's place, or a new one: what was there let go, the new one loaded and opened. */
-    async function openRecord(id) {
+    async function showNow(id) {
+        newGeneration();
         if (draftTimer !== null)
             scheduler.clearTimeout(draftTimer);
         if (autosaveTimer !== null)
@@ -1064,10 +1462,12 @@ function innerForm(options, within) {
         serverErrors = {};
         told = null;
         showing = false;
-        const fresh = { dirty: [], errors: {}, warning: null, warningField: null, error: null, draft: null, step: steps[0] ?? null, skipped: [], saveProblem: null, unread: {} };
+        clearFiles();
+        const fresh = { dirty: [], errors: {}, warning: null, warningField: null, error: null, draft: null, step: steps[0] ?? null, skipped: [], saveProblem: null, version: null, can: null, conflict: null, setAside: null, unsent: [], unread: {} };
         if (id != null) {
             set({ ...fresh, recordId: id, status: 'idle' });
-            return load();
+            await load();
+            return true;
         }
         loads++;
         baseline = startFrom(startingValues(true, false));
@@ -1075,6 +1475,142 @@ function innerForm(options, within) {
         set({ ...fresh, recordId: null, status: 'ready', values, warnings: withValues(values, collectWarnings) });
         offerDraft();
         await opening();
+        return true;
+    }
+    /** The check going now — waiting, or asking — that a way out taken meanwhile joins, with how it was taken. */
+    let checking = null;
+    /** Whether a way out has to wait first: a save on its way (not the one whose beforeSave steps take it: `own`), or files on theirs. */
+    const busy = (own) => (!own && saveRunning !== null) || filesGoing();
+    /** Wait for the saves on their way — unless `own`, the way out is a step of one of them — and the files on theirs, saying so meanwhile. */
+    async function quietFirst(own) {
+        if (!busy(own))
+            return;
+        set({ leaving: true });
+        try {
+            while (busy(own)) {
+                if (!own && saveRunning)
+                    await saveRunning;
+                else
+                    await filesSettled();
+            }
+        }
+        finally {
+            set({ leaving: false });
+        }
+    }
+    /** 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));
+    /** 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)
+            await saveRunning;
+    }
+    /**
+     * THE check: every way the form's values go — another record, the record
+     * loaded again, the host's close, a reset step, the app's own ways out
+     * through `leave()` — passes here, so none can lose the person's work
+     * unasked. First it waits for a save on its way and files on theirs, so
+     * no answer lands on a record that is gone and nothing is told against
+     * values that are about to change; then it looks at the record as it is
+     * now. Nothing at risk (`workAtRisk`; with `changes`, every change not
+     * saved too): true — at once when nothing was on its way, as in 0.20. Else
+     * "Discard your changes?" through the host — Discard worded Yes, the focus
+     * on Cancel — or `confirm`; with neither, the work is kept. `discard`: the
+     * person's own Discard, asked nothing. A way out taken while one waits or
+     * asks joins it, and gets its answer. A saved form placed in a record asks
+     * the record's. `chain`: the moments the run taking it was set off by — a
+     * step of a save's own beforeSave does not wait for that save.
+     */
+    function letGo(how = {}, chain = []) {
+        if (outer)
+            return outer.letGo(how, chain);
+        // A delete the person chose: their work goes with the record, unasked.
+        if (deletes) {
+            forget();
+            return true;
+        }
+        const own = chain.includes('on.beforeSave');
+        if (atOnce(how, own)) {
+            if (how.discard)
+                forget();
+            return true;
+        }
+        if (checking) {
+            const joined = checking;
+            // Its answer is this one's too; asked another way (every change counting), it is checked that way after.
+            return joined.going.then((yes) => yes && (sameHow(joined.how, how) || Promise.resolve(letGo(how, chain))));
+        }
+        const going = (async () => {
+            await quietFirst(own);
+            if (how.discard) {
+                forget();
+                return true;
+            }
+            if (!workAtRisk(state, how))
+                return true;
+            return askToLetGo();
+        })();
+        checking = { how, going };
+        void going.then(() => {
+            if (checking?.going === going)
+                checking = null;
+        });
+        return going;
+    }
+    async function askToLetGo() {
+        const message = messages.discardChanges;
+        const host = options.host;
+        let yes = false;
+        try {
+            yes = host ? await host.ask(message, { discard: true }) : options.confirm ? await options.confirm(message) : false;
+        }
+        catch {
+            // A question that could not be asked keeps the work.
+        }
+        if (yes)
+            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. */
+    function forget() {
+        clearFiles();
+        personal.clear();
+        filed.clear();
+        if (state.setAside !== null || state.unsent.length)
+            set({ setAside: null, unsent: [] });
+    }
+    /** 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) {
+        const go = letGo({}, chain);
+        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 = []) {
+        const go = letGo({}, chain);
+        if (go === true)
+            return load(again).then(() => true);
+        return go.then((yes) => (yes ? load(again).then(() => true) : false));
+    }
+    /**
+     * The host's close, as every `close` step reaches it: the form takes it
+     * once, here where it is made, and puts the check before it — so the app's
+     * own close (its panel's, its modal's: `host.close`) never drops the
+     * person's work unasked, nor does the viewer's dialog, panel or page in
+     * place. A saved form placed in a record closes as the record does.
+     */
+    function close(chain = []) {
+        if (outer)
+            return outer.close(chain);
+        const host = options.host;
+        if (!host?.close)
+            return { reason: 'cannot', message: 'Nothing can close this form: it has no host, or was not opened in a dialog or panel' };
+        const shut = () => {
+            host.close?.();
+            return null;
+        };
+        const go = letGo({}, chain);
+        return go === true ? shut() : go.then((yes) => (yes ? shut() : kept()));
     }
     /** The record a record step asks the data source about. */
     const record = () => ({ model: page.data.model, id: state.recordId, fields });
@@ -1103,25 +1639,51 @@ function innerForm(options, within) {
         addLine: (field, values) => void addLine(field, values, 'step'),
         check,
         save: saving,
-        async reload() {
+        generation: () => generation,
+        gone: () => (disposed ? { reason: 'closed' } : { reason: 'cannot', message: messages.recordReplaced }),
+        async reload(chain) {
             if (state.recordId == null)
                 return { reason: 'cannot', message: 'The record is not saved yet: there is nothing to load again' };
-            await load(true);
+            if (!(await loadAgain(true, chain)))
+                return kept();
             return state.status === 'error' ? { reason: 'cannot', message: state.error ?? 'The record could not be loaded again' } : null;
         },
-        reset: () => form.reset(),
+        reset(chain) {
+            const reset = () => {
+                form.reset();
+                return null;
+            };
+            const go = letGo({}, chain);
+            return go === true ? reset() : go.then((yes) => (yes ? reset() : kept()));
+        },
+        close,
         goTo: goToStep,
         showing: inRun,
         host: options.host,
         confirm: options.confirm,
         onAction: options.onAction,
         answered: (request, result) => emit('action', { request, result }),
-        changed: () => state.dirty.length > 0,
+        changed: () => state.dirty.length > 0 || state.uploads.some(uploadGoing),
+        letGo: letGoStep,
+        async deleting(remove, done) {
+            deletes++;
+            try {
+                const out = await remove();
+                // Deleted: what the person had not saved in it goes with it. Refused, it stays theirs.
+                if (done(out))
+                    forget();
+                return out;
+            }
+            finally {
+                deletes--;
+            }
+        },
         ...(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) {
-            await openRecord(id);
+        async showRecord(id, chain) {
+            if (!(await openRecord(id, chain)))
+                return kept();
             return state.status === 'error' ? { reason: 'cannot', message: state.error ?? 'The record could not be loaded' } : null;
         },
         told(event, id) {
@@ -1138,6 +1700,7 @@ function innerForm(options, within) {
         },
         post,
         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`. */
@@ -1167,7 +1730,10 @@ function innerForm(options, within) {
             listeners.add(listener);
             return () => listeners.delete(listener);
         },
-        load: () => track(load()),
+        load() {
+            const go = letGo();
+            return track(go === true ? load() : go.then((yes) => (yes ? load() : undefined)));
+        },
         setValue(name, value, how) {
             fieldDef(name);
             writeValues({ ...state.values, [name]: structuredCopy(value) });
@@ -1177,6 +1743,8 @@ function innerForm(options, within) {
         setValues: (values, how) => (how?.stored ? store(values) : write(values, 'app')),
         node: nodeState,
         openRecord: (id) => track(openRecord(id)),
+        leave: (how) => Promise.resolve(letGo(how)),
+        leaveNow: (how = {}) => (outer ? outer.leaveNow(how) : atOnce(how)),
         post,
         setEditing(next) {
             if (next === editing)
@@ -1185,7 +1753,7 @@ function innerForm(options, within) {
             // Nothing of the record changed; what shows of it may have.
             set({});
         },
-        fieldReadonly: (name) => lockedField(fieldDef(name)),
+        fieldReadonly: (name) => lockedField(fieldDef(name)) || state.can?.edit === false || state.can?.readonlyFields?.includes(name) === true,
         loadChoices,
         loadDefinitions,
         addDefinition,
@@ -1234,7 +1802,7 @@ function innerForm(options, within) {
             state = before;
             set({ unread: next, errors });
         },
-        leave(path) {
+        boxLeft(path) {
             const problem = leftProblem(path);
             if (!problem || state.errors[path] === problem)
                 return;
@@ -1259,12 +1827,36 @@ function innerForm(options, within) {
             return Object.keys(errors).length === 0;
         },
         save: () => track(save()),
+        canUpload: () => typeof options.dataSource?.upload === 'function',
+        upload: (field, files, how = {}) => uploads.start(field, files, how),
+        uploading: (field) => state.uploads.filter((upload) => upload.field === field && !upload.line),
+        cancelUpload(id) {
+            const inner = partUpload(id);
+            if (inner)
+                inner.form.cancelUpload(inner.id);
+            else
+                uploads.cancel(id);
+        },
+        retryUpload(id) {
+            const inner = partUpload(id);
+            if (inner)
+                inner.form.retryUpload(inner.id);
+            else
+                uploads.retry(id);
+        },
         reset() {
             forgetDraft();
+            // Files on their way were changes too: they go with the rest.
+            clearFiles();
             serverErrors = {};
             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++;
+            personal.clear();
+            filed.clear();
+            sentAs = null;
             const values = syncParts(structuredCopy(baseline), 'start');
-            set({ values, dirty: [], errors: {}, warnings: withValues(values, collectWarnings), warning: null, warningField: null, draft: null, step: steps[0] ?? null, skipped: [], saveProblem: null, unread: {} });
+            set({ values, dirty: [], errors: {}, warnings: withValues(values, collectWarnings), warning: null, warningField: null, draft: null, step: steps[0] ?? null, skipped: [], saveProblem: null, conflict: null, unsent: [], unread: {} });
         },
         changes,
         addLine: (field, values = {}) => addLine(field, values, 'person'),
@@ -1529,12 +2121,91 @@ function innerForm(options, within) {
             if (!raw)
                 return;
             const draft = JSON.parse(raw);
-            writeValues({ ...state.values, ...draft.values }, { draft: null }, true);
+            writeValues(withDraft(draft.values), { draft: null }, true);
         },
         discardDraft() {
             forgetDraft();
             set({ draft: null });
         },
+        async reloadTheirs() {
+            // A save on its way first: its answer is not dropped by the load.
+            await savesSettled();
+            // The person's changes, kept before theirs are loaded over them.
+            const mine = {};
+            for (const name of state.dirty)
+                mine[name] = structuredCopy(state.values[name]);
+            await track(load(true));
+            if (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 });
+            return true;
+        },
+        async keepMine() {
+            const conflict = state.conflict;
+            let told = conflict?.theirs;
+            let version = conflict?.version;
+            // Not told the record as they left it: read as it is now, so a source that saves whole records keeps their work.
+            const source = options.dataSource;
+            if (conflict && !told) {
+                if (source?.load && state.recordId != null && page.data.kind === 'record') {
+                    try {
+                        const now = loadedRecordOf(await track(source.load({ model: page.data.model, id: state.recordId, fields })));
+                        told = now.values;
+                        version = now.version ?? version;
+                    }
+                    catch {
+                        // Unread: said below.
+                    }
+                }
+                // Still unread: saving now would go over work this person never saw. Nothing is saved; they are told, and choose again.
+                if (!told) {
+                    const message = messages.theirsUnread;
+                    set({ status: 'error', error: message, saveProblem: { kind: 'conflict', message, conflict: { version: conflict.version } }, conflict: { ...conflict, unread: true } });
+                    return false;
+                }
+            }
+            if (told) {
+                // The record as they left it is where this person's changes start from: theirs stay wherever they changed nothing.
+                const theirs = {};
+                for (const [name, value] of Object.entries(told))
+                    if (fields[name])
+                        theirs[name] = structuredCopy(value);
+                const mine = state.dirty;
+                baseline = { ...baseline, ...theirs };
+                const values = { ...state.values };
+                for (const [name, value] of Object.entries(theirs))
+                    if (!mine.includes(name))
+                        values[name] = value;
+                writeValues(values);
+            }
+            // Saved with the version it has now: these changes over the record as it is.
+            if (version)
+                set({ version });
+            return track(save());
+        },
+        putBack(field) {
+            const aside = state.setAside;
+            if (!aside)
+                return;
+            const names = field === undefined ? Object.keys(aside) : Object.prototype.hasOwnProperty.call(aside, field) ? [field] : [];
+            if (!names.length)
+                return;
+            const left = { ...aside };
+            for (const name of names)
+                delete left[name];
+            set({ setAside: Object.keys(left).length ? left : null });
+            for (const name of names)
+                form.setValue(name, aside[name]);
+        },
+        discardSetAside() {
+            if (state.setAside)
+                set({ setAside: null });
+        },
         async settled() {
             while (pending.size)
                 await Promise.allSettled([...pending]);
@@ -1561,19 +2232,30 @@ function innerForm(options, within) {
                 scheduler,
                 messages,
                 now: options.now,
-            }, chain);
+            }, chain, 
+            // Its files are the record's: stored for it, under the part's name.
+            { model: where.model, recordId: where.recordId, under: `${where.under}${part.name}.` }, 
+            // Its ways out are the record's: through this form's check.
+            { letGo, close, leaveNow: (how) => atOnce(how) });
             attached.set(id, { name: part.name, inner: made });
             // A change inside it is told as a change of its answers here, whoever made it.
             made.form.on('change', ({ by }) => {
                 if (!syncing)
                     changed(part.name, by);
             });
-            // A change made inside it is a change of this form's: shown, kept in a draft, saved.
+            // A change made inside it is a change of this form's: shown, kept in a draft, saved. Its files on their way are this form's too.
+            let seenUploads = made.form.getState().uploads;
             made.form.subscribe((inside) => {
+                if (inside.uploads !== seenUploads) {
+                    seenUploads = inside.uploads;
+                    filesChanged();
+                }
                 if (syncing || inside.values === state.values[part.name])
                     return;
                 writeValues({ ...state.values, [part.name]: asValue(inside.values) });
-                afterEdit(part.name);
+                // A link a save put in place of bytes is no change of the person's.
+                if (!quietParts)
+                    afterEdit(part.name);
             });
             // What it starts with, its defaults and worked-out values filled in, is this form's starting point too — unless changed already.
             const start = asValue(made.form.getState().values);
@@ -1585,6 +2267,10 @@ function innerForm(options, within) {
         },
         embedded: (id) => attached.get(id)?.inner.form ?? null,
         dispose() {
+            // An answer that lands after is for no record shown.
+            disposed = true;
+            newGeneration();
+            clearFiles();
             if (draftTimer !== null)
                 scheduler.clearTimeout(draftTimer);
             if (autosaveTimer !== null)
@@ -1607,6 +2293,8 @@ function innerForm(options, within) {
         take(values, how) {
             if (how !== 'start')
                 return writeValues({ ...initialValues(page.fields, today()), ...values }, {}, how === 'fresh');
+            // Started again from the record round it: a file it held is the record's now, sent or let go with it.
+            filed.clear();
             baseline = startFrom({ ...initialValues(page.fields, today()), ...structuredCopy(values) });
             const start = syncParts(structuredCopy(baseline), 'start');
             set({ values: start, dirty: [], errors: {}, warnings: withValues(start, collectWarnings), warning: null, warningField: null, unread: {} });
@@ -1617,8 +2305,26 @@ function innerForm(options, within) {
             if (JSON.stringify(errors) !== JSON.stringify(state.errors))
                 set({ errors });
         },
+        files: {
+            going: filesGoing,
+            settled: filesSettled,
+            problems: fileProblems,
+            // Its answers are sent whole: every field's bytes are stored.
+            storeBytes: () => storeBytes(Object.keys(fields)),
+            draft: draftOf,
+            clear: clearFiles,
+            filed: () => filed.size > 0,
+        },
     };
 }
+/** Two ways out taken the same way: the one joined answers for the other. */
+const sameHow = (a, b) => !!a.changes === !!b.changes && !!a.discard === !!b.discard;
+/** Two lists of names the same, in the same order. */
+const sameList = (a, b) => a.length === b.length && a.every((name, i) => name === b[i]);
+/** A file on its way in a saved form placed in another, as that one names it: its id and its field under the part's name. */
+function underPart(name, upload) {
+    return { ...upload, id: `${name}/${upload.id}`, ...(upload.line ? { line: { ...upload.line, field: `${name}.${upload.line.field}` } } : { field: `${name}.${upload.field}` }) };
+}
 /** The problems found inside a saved form, by its own fields' names. */
 function inside(errors, name) {
     const found = {};
@@ -1654,6 +2360,46 @@ function compareLines(a, b, by) {
 function lockedField(def) {
     return def.readonly === true || def.compute !== undefined;
 }
+/** The words a person is told when a step would do what they may not, and the source gave no reason. */
+const MAY_NOT = { edit: 'mayNotEdit', archive: 'mayNotArchive', duplicate: 'mayNotDuplicate', delete: 'mayNotDelete' };
+/**
+ * What a press does that a record's source may forbid, read from what it
+ * runs: its steps — saving is editing; archiving and bringing back are both
+ * archiving — or, for a gear menu's built-in item with nothing of its own, the
+ * built-in itself.
+ */
+function rightsUsed(source) {
+    const steps = source.steps ?? [];
+    const names = steps.map((step) => step.do);
+    if ('builtin' in source && source.builtin && !steps.length && source.action === undefined)
+        names.push(source.builtin);
+    const rights = new Set();
+    for (const name of names) {
+        if (name === 'save')
+            rights.add('edit');
+        else if (name === 'archive' || name === 'unarchive')
+            rights.add('archive');
+        else if (name === 'duplicate' || name === 'delete')
+            rights.add(name);
+    }
+    return [...rights];
+}
+/** A table's lines as the person has them, each new one given the id a save just gave it, by its key: the next save changes it, never makes it again. */
+function keepIds(def, mine, stored) {
+    if (def.type !== 'one2many' || !Array.isArray(mine) || !Array.isArray(stored))
+        return mine;
+    const ids = new Map(stored.filter((line) => line.id !== undefined).map((line) => [line.key, line.id]));
+    return mine.map((line) => (line.id === undefined && ids.has(line.key) ? { ...line, id: ids.get(line.key) } : line));
+}
+/** Two values of a field the same: a link by the record it points to, whatever name it is shown by; the rest as written. */
+function sameValue(def, a, b) {
+    const id = (value) => (value !== null && typeof value === 'object' && !Array.isArray(value) && 'id' in value ? value.id : value);
+    if (def?.type === 'many2one')
+        return JSON.stringify(id(a) ?? null) === JSON.stringify(id(b) ?? null);
+    if (def?.type === 'many2many')
+        return JSON.stringify((a ?? []).map(id)) === JSON.stringify((b ?? []).map(id));
+    return JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+}
 function lineOps(before, now) {
     const ops = [];
     const old = new Map(before.filter((line) => line.id !== undefined).map((line) => [line.key, line]));
@@ -1690,6 +2436,7 @@ function indexLayout(root) {
     const add = (source, parent, kind, modifiers) => {
         const roles = source.roles;
         const pressed = kind === 'button' ? source.pressed : undefined;
+        const does = kind === 'button' || kind === 'stat' ? rightsUsed(source) : [];
         index.set(source.id, {
             id: source.id,
             parent,
@@ -1700,6 +2447,7 @@ function indexLayout(root) {
             readonly: compileModifier(modifiers.readonly),
             required: compileModifier(modifiers.required),
             ...(pressed !== undefined ? { pressed: compileModifier(pressed) } : {}),
+            ...(does.length ? { does } : {}),
             source,
         });
         // A button's menu: each item a button of the record, hidden with it.