@dynamicforms/vue-forms 2.0.3 → 3.0.0-alpha.2

package/dist/index.d.ts

@@ -1,38 +1,32 @@
-import { ComponentOptionsMixin } from 'vue';
-import { ComponentProvideOptions } from 'vue';
-import { ComputedRef } from 'vue';
-import { DefineComponent } from 'vue';
-import { PublicProps } from 'vue';
 import { Ref } from 'vue';
-import { TranslateStringsCallback } from '@dynamicforms/translatable';
 
 /**
- * Thrown from a handler to end the run it is in. What the trigger answers with is the exception itself rather than
- * `null`, so a caller can tell a run a handler ended from one that reached no handler at all - and the setters
- * that ask a `*Changing*` handler read it as a refusal and write nothing. The answer carries it directly where the
- * chain ran synchronously, and as what the answered promise resolves to where a handler in it was asynchronous.
+ * Thrown from a handler to end the current run. The trigger returns the exception itself, not `null`, so a caller
+ * can distinguish a run a handler ended from one that reached no handler; a setter that triggers a `*Changing*`
+ * handler cancels the write when it receives it. The trigger returns the exception directly if the chain ran
+ * synchronously, and as the resolution of the returned promise if a handler in it was asynchronous.
  */
 export declare class AbortEventHandlingException extends Error {
 }
 
 /**
  * What a form element accepts and what it sends. The four values follow HTML: `'editable'` and `'readonly'` send
- * the element's value the way an `<input>` and an `<input readonly>` are submitted, `'disabled'` sends nothing the
- * way an `<input disabled>` is left out, and `'disabled-null'` sends `null` in the element's place.
+ * the element's value, as an `<input>` and an `<input readonly>` are submitted, `'disabled'` sends nothing, as an
+ * `<input disabled>` is omitted, and `'disabled-null'` sends `null` in place of the element's value.
  *
- * | access            | accepts input | contributes to its container's `value` |
+ * | access            | accepts input | sends to its container's `value`       |
  * |-------------------|---------------|----------------------------------------|
  * | `'editable'`      | yes           | its value                              |
  * | `'readonly'`      | no            | its value                              |
  * | `'disabled'`      | no            | nothing: the key or row is left out    |
  * | `'disabled-null'` | no            | `null`                                 |
  *
- * An element that contributes no value of its own is not counted in its container's validity. `fullValue` carries
- * every element whatever its access.
+ * An element that sends nothing is not counted in its container's validity. `fullValue` contains every element
+ * whatever its access.
  */
 export declare type Access = 'editable' | 'readonly' | 'disabled' | 'disabled-null';
 
-/** Told once an element's `access` has been written. */
+/** Fires after an element's `access` has been written. */
 export declare class AccessChangedAction extends FieldActionBase {
     constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, newValue: Access, oldValue: Access) => void);
     static get classIdentifier(): symbol;
@@ -40,8 +34,8 @@ export declare class AccessChangedAction extends FieldActionBase {
 }
 
 /**
- * Asked before an element's `access` is written. A handler answers with the access to write instead, or throws
- * `AbortEventHandlingException` to refuse the write.
+ * Fires before an element's `access` is written. A handler returns the access to write instead, or throws
+ * `AbortEventHandlingException` to cancel the write.
  */
 export declare class AccessChangingAction extends FieldActionBase {
     constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, newValue: Access, oldValue: Access) => Access);
@@ -56,37 +50,56 @@ export declare class Action<T extends ActionValue = ActionValue, X extends objec
     get [Symbol.toStringTag](): string;
     protected init(params?: IFieldParams<T, X>): void;
     /**
-     * A copy of the value this action holds, carrying one member rewritten. A member handed undefined is dropped
-     * from the copy rather than written into it: an own key holding undefined is invisible to a reader and to
-     * JSON, but lodash isEqual compares own-key sets, so writing one would leave the action permanently changed
-     * against a baseline that never carried the key.
+     * Returns a copy of the value this action holds with one member replaced. A member set to undefined is deleted
+     * from the copy: an own key holding undefined is invisible to a reader and to JSON, but lodash isEqual compares
+     * own-key sets, so the action would remain changed against a baseline without that key.
      */
     private valueWith;
     get icon(): T['icon'];
     set icon(newValue: T['icon']);
     get label(): T['label'];
     /**
-     * The two setters hand the value setter a new object rather than writing into the one the action holds, so each
-     * is an ordinary value change: the handlers fire and isChanged answers over it.
-     * The new object is built only for a member that differs from the one held - the value setter compares by
-     * identity and every copy is a new object, so without the comparison here a write of the value already held
-     * would announce a change and invalidate the value cache of every container above.
+     * The two setters pass a new object to the value setter instead of modifying the one the action holds, so each
+     * is a regular value change: the handlers fire and isChanged reflects it.
+     * The new object is built only if the member differs from the current one: the value setter compares by identity
+     * and every copy is a new object, so without this check a write of the current value would announce a change and
+     * invalidate the value cache of every container above.
      */
     set label(newValue: T['label']);
-    /** the counter behind `busy`, allocated for this action the first time it is asked for */
+    /** `value.defaultConfirm`: whether a container's `confirm()` executes this action. */
+    get defaultConfirm(): boolean;
+    /** `value.defaultReject`: whether a container's `reject()` executes this action. */
+    get defaultReject(): boolean;
+    /**
+     * An action is a command, not data: it sends nothing to its container's `value` or `fullValue`, so it is not in
+     * the payload, does not affect the container's `isChanged`, and is not counted in its validity. Its validators do
+     * not run, as on any element that sends nothing.
+     */
+    protected serializesAs(): 'value' | 'null' | 'omit';
+    /** An action is sent nowhere, so a validator registered on it reaches no result and adds no error. */
+    [SentNowhere](): boolean;
+    /**
+     * Whether the action can run now: it accepts input (`effectiveEnabled`), is shown (`visibility` is `'full'`), is
+     * not running (`busy` is false), and every `ExecuteAction` handler registered on it returns true from
+     * `canExecute()`. Reactive, so a button binds `:disabled="!action.executable"`. A container's `confirm()` and
+     * `reject()` execute only an executable action. `execute()` does not check it.
+     */
+    get executable(): boolean;
+    /** The `ExecuteAction` handlers registered on this action, in registration order. */
+    [ExecuteHandlers](): ExecuteAction[];
+    /** the counter behind `busy`, created on first access */
     private get busyRuns();
-    /** true from the moment execute() is called until the handler it ran has settled, however it settles */
+    /** true from the call to execute() until the handler it ran has settled, resolved or rejected */
     get busy(): boolean;
     /**
-     * Runs the ExecuteAction chain registered on this action and answers what the chain returned. `busy` stands for
-     * the length of the run: the chain is entered synchronously, and the flag is cleared once the value it produced
-     * has settled - a handler that returns a promise holds it for as long as that promise takes, and one that
-     * rejects clears it as it rejects.
+     * Runs the ExecuteAction chain registered on this action and returns the chain's result. `busy` is true for the
+     * duration of the run: the chain starts synchronously, and the flag is cleared when its result has settled; a
+     * handler that returns a promise keeps it set until that promise settles, and a rejection clears it.
      *
-     * The answer is a promise whatever the handler returns, so a handler that throws rejects it rather than throwing
-     * out of this call: a caller that does not await the answer and does not attach a catch handler leaves that
-     * rejection unhandled. An `AbortEventHandlingException` is the one exception that does not reject: the answer
-     * resolves with it, in a synchronous chain as in an asynchronous one.
+     * The return value is a promise whatever the handler returns, so a handler that throws rejects the promise; this
+     * call does not throw. A caller that neither awaits it nor attaches a catch handler leaves the rejection
+     * unhandled. An `AbortEventHandlingException` does not reject: the promise resolves with it, for a synchronous
+     * and an asynchronous chain alike.
      */
     execute(params?: any): Promise<any>;
 }
@@ -95,170 +108,213 @@ declare type ActionExecutor = (field: FieldBase, supr: FieldActionExecute, ...pa
 
 /**
  * The actions one declaration has registered, in registration order. A trigger walks them from the end backwards
- * and passes over the ones registered under another identifier, so the newest registration of an identifier is its
- * outermost handler and reaches the ones before it through the `supr` it is handed. A handler that does not call
- * `supr` ends the run there, and one that calls it may transform what it answers with.
+ * and skips the ones registered under another identifier, so the newest registration of an identifier is its
+ * outermost handler and calls the earlier ones through its `supr` argument. A handler that does not call `supr`
+ * ends the run, and one that calls it may transform the result.
  *
- * The order is the whole index. An element carries a handful of actions, and a walk over that many is cheaper than
- * a keyed lookup as well as smaller: measured over three actions, the walk is about twice as fast as `Map.get` and
- * the two maps it replaces cost about 500 bytes per declaration.
+ * The array is the only index. An element has few actions, and a linear walk over a few entries is faster and
+ * smaller than a keyed lookup.
  */
 export declare class ActionsMap {
     /**
-     * Every action registered here, in registration order. It is replaced rather than written when an action is
-     * dropped, so a run already walking it finishes on the array it started with and the removal takes effect from
-     * the next trigger.
+     * Every action registered here, in registration order. Registering and unregistering replace the array instead of
+     * modifying it, so a run in progress finishes on the array it started with, the change takes effect from the next
+     * trigger, and an array read through `registrations` never changes.
      */
     private actions;
     /**
-     * Registers `action`. It becomes the outermost handler of its identifier, or - where `before` is given and is
-     * registered here under the same identifier - takes that action's place in the order, so `before` wraps it and
-     * reaches it through `supr`. That is what lets an action be added to a chain someone else built and still sit
-     * inside a handler already there.
+     * The registered actions, in registration order. The array is not modified later, so it records the
+     * registrations at the time of the read; `restore()` reinstates them.
+     */
+    get registrations(): readonly FieldActionBase[];
+    /**
+     * Replaces the registered actions with `registrations`, an array `registrations` returned earlier. The order of
+     * the handlers and every duplicate registration are restored with it.
+     */
+    restore(registrations: readonly FieldActionBase[]): void;
+    /**
+     * Registers `action`. It becomes the outermost handler of its identifier, or, if `before` is given, is inserted
+     * at the position of `before`, so `before` wraps it and calls it through `supr`. This adds an action to an
+     * existing chain inside a handler that is already registered. Throws if `before` is not registered here under the
+     * same identifier, and a TypeError for an `ErrorPolicy` naming an origin another one registered here names.
      */
     register(action: FieldActionBase, before?: FieldActionBase): void;
-    /** Drops `action` and answers whether it was registered here. */
+    /** A copy of `actions` with `action` inserted at `index`. */
+    private static inserted;
+    /** Unregisters `action` and returns whether it was registered here. */
     unregister(action: FieldActionBase): boolean;
-    /** True where something is registered under `identifier`. */
+    /** True if any action is registered under `identifier`. */
     willTrigger(identifier: symbol): boolean;
-    /** True where any eager action is registered, whatever identifier it stands under. */
+    /** True if any eager action is registered, under any identifier. */
     get hasEager(): boolean;
-    /** Runs the actions registered under `ActionClass` and answers with what the outermost of them returned. */
+    /** Runs the actions registered under `ActionClass` and returns the result of the outermost one. */
     trigger<T extends FieldActionBase>(ActionClass: (abstract new (...args: any[]) => T) & {
         classIdentifier: symbol;
     }, field: FieldBase, ...params: any[]): any;
     /**
-     * Runs the eager actions of every identifier, each group on its own. A group is entered at its outermost eager
-     * action, which is the last one registered under that identifier.
+     * Runs the eager actions of every identifier, each identifier's group separately. A group starts at its outermost
+     * eager action, the last one registered under that identifier. The rules run before the validators: a rule can
+     * change the element's access or value, so after one ran the validators receive what the element sends then, in
+     * place of the first parameter.
      */
     triggerEager(field: FieldBase, ...params: any[]): void;
-    /** Runs the eager actions registered under `identifier` and nothing else. */
+    /**
+     * Runs the eager actions other than the validators, as `triggerEager` does: the rules that set an element's flags
+     * or values from its record.
+     */
+    triggerEagerRules(field: FieldBase, ...params: any[]): void;
+    /** Runs the eager groups whose actions `include` accepts; returns whether any ran. */
+    private runEager;
+    /** Runs only the eager actions registered under `identifier`. */
     triggerEagerFor(identifier: symbol, field: FieldBase, ...params: any[]): any;
-    /** the validators registered here, in registration order */
+    /** The registered actions with `identifier`, in registration order. */
+    ofClass(identifier: symbol): FieldActionBase[];
+    /** The validators registered here, in registration order. */
     get validators(): Validator[];
     /**
-     * Tells every action here that it serves `owner`. A binding reads the map its declaration holds, so this is what
-     * announces the new element to the actions already in it - the way registering an action announces the elements
-     * it comes to serve.
+     * Binds every action in this map to `owner`. A binding uses its declaration's map, so this notifies the actions
+     * already in it of the new element, as registering an action binds it to the existing elements.
      */
     bindTo(owner: FieldBase): void;
-    /** True where no eager action of `identifier` stands after `index`, which makes `index` the group's entry. */
+    /** Tells every action in this map that `owner` is reset to a new binding of its declaration. */
+    resetBinding(owner: FieldBase): void;
+    /** True if no eager action of the same identifier follows `index`, so `index` is the group's entry point. */
     private static outermostEager;
     /**
-     * True where `value` is a promise, which is what a walk through an asynchronous handler answers with. The test is
-     * the type rather than a `then` member: a handler may answer with a value object that carries one, and calling
-     * `then` on such an object replaces the answer with whatever that call returns.
+     * True if `value` is a promise, which a walk through an asynchronous handler returns. The test checks the type,
+     * not a `then` member: a handler may return a value object with a `then` member, and calling it would replace the
+     * result with that call's return value.
      */
     private static isPromise;
     /**
-     * Answers an abort with itself on the asynchronous path as well. Where a handler in the chain is asynchronous, the
-     * walk answers with a promise and the abort raised under it arrives as that promise's rejection; this turns it back
-     * into the value the caller receives, so a promise the trigger answers with resolves to the exception instead of
-     * rejecting with it. Anything else keeps rejecting.
+     * Returns an abort as a value on the asynchronous path as well. If a handler in the chain is asynchronous, the
+     * walk returns a promise and an abort arrives as its rejection; this converts it to a resolution, so the promise
+     * the trigger returns resolves to the exception. Any other rejection is passed on.
      */
     private static answerAbort;
     /**
-     * Enters a group at its outermost action. An abort ends the run and is answered with rather than raised: the
-     * exception is what the caller receives - directly where the chain ran synchronously, as what the answered promise
-     * resolves to where it did not - so a run a handler ended is told apart from one that reached no handler and from
-     * one whose handler answered null.
+     * Runs a group from its outermost action. An abort ends the run and is returned, not thrown: the caller receives
+     * the exception directly if the chain ran synchronously, and as the resolution of the returned promise otherwise.
+     * This distinguishes an aborted run from one that reached no handler and from one whose handler returned null.
      */
     private run;
     /**
-     * Walks from `index` backwards to the first action of `identifier`, handing it a `supr` that continues at the one
-     * before it. The actions registered under other identifiers are passed over, so the array needs no grouping of
-     * its own; the closures exist for the length of the run and only as deep as the run actually goes.
+     * Walks from `index` backwards to the first action of `identifier` and calls it with a `supr` that continues at
+     * the action before it. Actions registered under other identifiers are skipped, so the array needs no grouping;
+     * a closure is created only for each level the run reaches and lives only for the run.
      */
     private walk;
 }
 
 /**
- * The value an `Action` holds. Both members are `unknown` because `Action` states the concept and a UI library
- * states what it renders: a subclass declares its value type with `label` and `icon` in whatever shape it renders
- * them - `string | MdString`, a per-breakpoint object - and the accessors below answer at that type, because they
- * read it off `T` rather than fixing one of their own.
+ * The value an `Action` holds. Both members are `unknown` because `Action` defines the concept and a UI library
+ * defines what it renders: a subclass declares its value type with `label` and `icon` in the shape it renders them
+ * (a string, a markdown string, a per-breakpoint object), and the accessors below return that type, because they
+ * read it from `T`.
  *
- * The consequence for an `Action` built without a type argument is that reading either member answers `unknown`
- * and the reader states what it expects. That is the shape the class is for; an application that renders actions
- * uses the subclass its UI library ships.
+ * For an `Action` built without a type argument, both members are `unknown` and the reader casts them. An
+ * application that renders actions uses the subclass its UI library provides.
  */
 export declare interface ActionValue {
     label?: unknown;
     icon?: unknown;
+    /** The action a container's `confirm()` executes: the one a confirm gesture, such as Enter, triggers. */
+    defaultConfirm?: boolean;
+    /** The action a container's `reject()` executes: the one a reject gesture, such as Escape, triggers. */
+    defaultReject?: boolean;
 }
 
 /**
- * The values a field may hold: a fixed list, or a reference or a callback for a list that is filled in or replaced
- * after the validator is built - the options a server answers with, or the ones another field's value leaves open.
+ * The values a field may hold: a fixed list, or a ref or a callback for a list that is filled or replaced after
+ * the validator is built (options returned by a server, or the options another field's value allows).
  */
 declare type AllowedValues<T> = T[] | Ref<T[]> | (() => T[]);
 
 /**
- * Depending on the useMarkdownInValidators setting, return either markdown or a plain string error message. A
- * Ref is stripped/wrapped on read rather than once here, so a translated template re-applies the same choice
- * as its text changes.
- * @param mdErrorString markdown source to optionally be stripped
- * @return MdString or string, or a ComputedRef of either where `mdErrorString` is itself a Ref
+ * Key of the `FieldBase` method that starts counting one asynchronous validation run and returns the function that
+ * ends it. A validator calls it; the package does not export it.
+ */
+declare const BeginValidating: unique symbol;
+
+/**
+ * The method a `Field` implements for `PluginContext.changeInPlace`. It is keyed by a symbol the package does not
+ * export, so it is not part of the documented API of `Field`.
  */
-export declare function buildErrorMessage<T extends string | Ref<string>>(mdErrorString: T): T extends Ref<string> ? ComputedRef<string | MdString> : string | MdString;
+declare const ChangeInPlace: unique symbol;
 
-export declare type ClassType = string | string[] | Record<string, boolean>;
+/**
+ * The base of the exceptions a `TargetedExecuteAction` ends with when its command did not complete. `execute()`
+ * resolves with it. A `SubmitAction` ends with a `SubmitFailedException` or a `SubmitRefusedException`, so the
+ * resolved value of a submit is `SubmitResult | CommandException`.
+ */
+export declare abstract class CommandException extends AbortEventHandlingException {
+}
 
-export declare type ClassTypes = ClassType | ClassType[];
+/**
+ * The element a `SubmitAction` or a `RejectAction` works on: an element, or a callback that returns it for the
+ * action the handler is registered on.
+ */
+export declare type CommandTarget = FieldBase | ((action: FieldBase) => FieldBase | null | undefined);
 
 declare class CompareTo<T = any> extends Validator {
     private isValidComparison;
     private readonly otherField;
     /**
-     * The fields this validator is registered on. Registration reaches one element at a time - the rows of a list
-     * take the validator on one by one, as they are built from the item template that carries it - so this is what
-     * says which of the fields a declaration stands for actually carry the rule, and a field that never took it on
-     * is left alone by a change of the compared field.
+     * The fields this validator is registered on. Registration happens one element at a time (the rows of a list
+     * receive the validator one by one, as they are built from the item template), so this set determines which
+     * elements of a declaration have the rule; a change of the compared element does not revalidate the others.
      */
     private readonly registrations;
     /**
-     * The fields this validator has installed its listener on. A binding of such a field carries the listener too -
-     * a binding takes on the actions of the field it was bound from - so the field it was bound from is what is
-     * asked about as well, and a list of a thousand rows installs one listener rather than a thousand.
+     * The declarations of the elements this validator has installed its listener on. A registration goes into the map
+     * of the element's declaration, which every binding of it uses, so a list of N rows installs one listener, not N.
      */
     private readonly listening;
     /**
-     * What the fields this validator was registered on were declared as. One entry stands for every binding of such a
-     * field, so a change of a compared field finds the fields of the record that change happened in without a list
-     * of a thousand rows being held here.
+     * The declarations of the fields this validator is registered on. One entry covers every binding of such a
+     * field, so a change of a compared element finds the fields of its record without this set holding every row.
+     * They are held weakly: the listener on the compared element keeps this validator reachable, and a form dropped
+     * without unregistering the validator is released all the same.
      */
     private readonly declarations;
-    constructor(otherField: CompareToTarget, isValidComparison: (myValue: T, otherValue: T) => boolean, message: RenderContentRef);
-    /** The field `field` is compared against, within the record `field` belongs to. */
+    /**
+     * The listener on the compared elements, one instance for all of them. It is removed when the validator is taken
+     * off its last declaration, or, once its declarations are collected, when an element it is registered on asks it
+     * to release itself.
+     */
+    private readonly relay;
+    constructor(otherField: CompareToTarget, isValidComparison: (myValue: T, otherValue: T) => boolean, options?: ValidationErrorOptions);
+    /** The element `field` is compared against, within the record `field` belongs to. */
     private resolve;
     /**
-     * Makes a change of `other` re-run this comparison. The listener re-runs it over the fields of the record the
-     * change happened in rather than over the field that installed it, so the listener a row inherits with the field
-     * it was bound from serves that row; and it re-runs this one validator, not the chain around it.
+     * Registers a listener so a change of `other` re-runs this comparison. The listener re-runs it over the fields of
+     * the record the change happened in, not over the field that installed it, so a listener a row inherits from its
+     * declaration applies to that row; it re-runs only this validator, not the whole chain.
      */
     private listenOn;
+    /** Removes the listener from every compared element; a rollback restores it and the record of the elements. */
+    private stopListening;
     boundToBinding(binding: FieldBase): void;
     private comparisonState;
     protected newBindingState(): CompareToBindingState<T>;
     unregisterFrom(binding: FieldBase): void;
 }
 
-/** What the validator remembers about one field it validates. */
+/** The validator's state for one field it validates. */
 declare interface CompareToBindingState<T> extends ValidatorBindingState {
     oldValue: T;
 }
 
 /**
- * How the field to compare against is named. A field names it directly, a string names it by the name its
- * container holds it under, and a callback works it out from the field being validated. All three answer for the
- * record the validation is running over: handed the field of a `List`'s item template, a row compares against that
- * row's field.
+ * The element to compare against: the element itself, its name in its container, or a callback that returns it
+ * for the field being validated. All three are resolved within the record the validation runs over: given an
+ * element of a `List`'s item template, a row compares against that row's element.
  */
 declare type CompareToTarget = FieldBase | string | ((field: FieldBase) => FieldBase | null | undefined);
 
 /**
  * Sets the access of the elements it is registered on from the statement's result: `whenTrue` while the statement
- * holds, `whenFalse` otherwise.
+ * is true, `whenFalse` otherwise.
  */
 export declare class ConditionalAccessAction extends ConditionalStatementAction {
     constructor(statement: Statement, whenTrue?: Access, whenFalse?: Access);
@@ -270,39 +326,55 @@ export declare class ConditionalStatementAction extends ValueChangedAction {
     private readonly statement;
     private readonly conditionalExecutor;
     /**
-     * What the elements this action was registered on were declared as. It holds declarations rather than the
-     * elements themselves, so one entry stands for every row of a list, and the element a result is applied to is
-     * the one that declaration names within the record the change happened in.
+     * The declarations of the elements this action is registered on. It holds declarations, not the elements, so one
+     * entry covers every row of a list; a result is applied to the element that corresponds to the declaration within
+     * the record the change happened in. They are held weakly: the relay on a field the statement reads keeps this
+     * action reachable, and a form dropped without unregistering the action is released all the same.
      */
     private readonly declarations;
     /**
-     * The elements this action was registered on. Registration reaches one element at a time - the rows of a list
-     * take the action on one by one, as they are built from the item template that carries it - so this is what
-     * says which of the elements a declaration stands for the action actually drives.
+     * The elements this action was registered on. Registration happens one element at a time (the rows of a list
+     * receive the action one by one, as they are built from the item template), so this set determines which of the
+     * elements of a declaration the action controls.
      */
     private readonly registrations;
     constructor(statement: Statement, executorFn: ConditionalExecutorFn);
+    /**
+     * The listener on the fields the statement reads. The constructor installs it; it is removed when the action is
+     * taken off its last element or its elements are collected, and installed again when the action is next
+     * registered.
+     */
+    private readonly relay;
+    private listening;
+    /** Whether the action has been registered on an element; until then the relay waits for its first element. */
+    private bound;
+    private listen;
+    /** Removes the relay from the fields the statement reads; a rollback restores it with the flag. */
+    private stopListening;
     static get classIdentifier(): symbol;
     get eager(): boolean;
     boundToBinding(binding: FieldBase): void;
+    /** Forgets the result last applied to `binding`, so the next pass applies the statement over its new flags. */
+    resetBinding(binding: FieldBase): void;
     unregisterFrom(binding: FieldBase): void;
     /**
-     * The elements of `scope` this action controls: what each declaration it serves names within that record, and of
-     * those the ones that took the action on. A row of a list that never took it on is not one this action drives.
+     * The elements of `scope` this action controls: for each of its declarations, the corresponding elements within
+     * that record that the action is registered on. A row of a list the action is not registered on is skipped.
      */
     private targetsIn;
     /**
-     * Re-evaluates the statement over one record and applies the result where it changed. The result is recorded
-     * before the executor runs, because an executor that writes a value re-enters through that value's eager pass
-     * and what it has to find there is the result being applied. It answers whether the record held anything for
-     * this action to drive, which is how a caller learns that the record is not assembled yet.
+     * Re-evaluates the statement over one record and applies the result to every target whose last applied result
+     * differs, so a target registered after the result was applied to another one in the same record receives it.
+     * The result is recorded before the executor runs, because an executor that writes a value re-enters through that
+     * value's eager pass, which must see the result being applied. Returns whether the record contains a target for
+     * this action; false means the record is not assembled yet.
      */
     private applyIn;
     /**
-     * Re-evaluates the records a change of `source` speaks for. A field of the record the targets live in speaks for
-     * that record alone, which is what keeps one row of a list from answering for another; a field above them - a
-     * form field every row reads - speaks for every record below it, and for the record the action was declared in
-     * where the change reaches none.
+     * Re-evaluates the records affected by a change of `source`. A change of an element in the targets' record
+     * affects only that record, so one row of a list does not affect another; a change of an element above them (a
+     * form field every row reads) affects every record below it, or the record the action was declared in if there
+     * is no record below it.
      */
     private applyFrom;
 }
@@ -313,28 +385,31 @@ export declare class ConditionalValueAction<T> extends ConditionalStatementActio
 
 /**
  * Sets the visibility of the elements it is registered on from the statement's result: `whenTrue` while the
- * statement holds, `whenFalse` otherwise. Visibility is presentation alone, so what the elements send is left to
- * their access.
+ * statement is true, `whenFalse` otherwise. Visibility affects presentation only; what the elements send is
+ * determined by their access.
  */
 export declare class ConditionalVisibilityAction extends ConditionalStatementAction {
     constructor(statement: Statement, whenTrue?: Visibility, whenFalse?: Visibility);
 }
 
+/** Sets what the devtools record and list. Does nothing in production. */
+export declare function configureDevtools(options: DevtoolsOptions): void;
+
 /**
- * A form element that holds other elements and composes its state out of theirs: `Group`, which holds named
+ * A form element that holds other elements and composes its state from theirs: `Group`, which holds named
  * members, and `List`, which holds rows. Every element's `parent` is a `Container`.
  *
- * What a container answers for over its children is the same whatever holds them: `valid` and `busy` are composed
- * of theirs, `touched` is true where any child is touched and propagates an assignment down, `validate(true)`
- * revalidates every child before the container forms its own verdict, and a child's change of value or verdict
- * reaches the container through `notifyValueChanged()` and the tallies below. How the children are reached - by
- * name or by position - is the subclass's.
+ * The behaviour over children is the same in both subclasses: `valid` and `busy` are composed from the children's,
+ * `touched` is true if any child is touched and an assignment propagates down to every child, `validate(true)`
+ * revalidates every child before the container computes its own validity, and a child's change of value or
+ * validity reaches the container through `notifyValueChanged()` and the counters below. The subclass defines how
+ * children are addressed: by name or by position.
  */
 export declare abstract class Container<T = any, X extends object = Extras> extends FieldBase<T, X> {
     get [Symbol.toStringTag](): string;
     /**
-     * The children this container holds, read through the tracked view of its state: a verdict or a flag composed
-     * over them is formed again when a child is added or removed.
+     * The children this container holds, read through the tracked view of its state, so a validity or flag composed
+     * over them is recomputed when a child is added or removed.
      */
     protected abstract get children(): readonly FieldBase[];
     get touched(): boolean;
@@ -343,50 +418,77 @@ export declare abstract class Container<T = any, X extends object = Extras> exte
     get busy(): boolean;
     validate(revalidate?: boolean): void;
     /**
-     * Records that a child changed its value, so that the transaction in progress works out at commit what this
-     * container's own value became and announces it once. The mutation methods call it themselves; you rarely need
-     * to.
+     * Records that a child changed its value, so that at commit the open transaction computes this container's new
+     * value and announces it once. The mutation methods call it; a direct call is rarely needed.
      */
     notifyValueChanged(): void;
+    /**
+     * Executes the action that confirms this container, with `params`, and returns what its `execute()` returns.
+     * The action is looked up in three steps; the first step that finds a candidate decides:
+     *
+     * 1. an action at or below this container with a `SubmitAction` whose target is this container;
+     * 2. an action with `defaultConfirm` among the direct members;
+     * 3. an action with `defaultConfirm` at a lower level.
+     *
+     * Only actions whose `visibility` is `'full'` are candidates. One candidate is executed if it is `executable`;
+     * where it is not, nothing is executed. Two or more candidates in one step are ambiguous: nothing is executed and
+     * a warning is logged. Returns undefined where nothing is executed. A rendering layer calls it for a confirm
+     * gesture, such as Enter in a dialog.
+     */
+    confirm(params?: any): Promise<any> | undefined;
+    /**
+     * Executes the action that rejects this container, looked up as in `confirm()` with `RejectAction` and
+     * `defaultReject`. A rendering layer calls it for a reject gesture, such as Escape in a dialog.
+     */
+    reject(params?: any): Promise<any> | undefined;
+    /**
+     * A container whose members are all actions, such as a bar of buttons, holds no data and sends nothing, like an
+     * action. A container without members, or with at least one member that is not an action, sends as its access
+     * determines.
+     */
+    protected serializesAs(purpose: 'value' | 'fullValue'): 'value' | 'null' | 'omit';
+    /** The action `confirm()` or `reject()` executes, or undefined. */
+    private command;
+    /** Every action at or below this container, depth-first in member order, with its depth below this container. */
+    private actionsBelow;
     protected get composesValue(): boolean;
     /**
-     * A container with nothing listening for what it holds does not compose it at all, so the copy it keeps is from
-     * before the changes nobody received. A registration that adds a listener brings it up to date here, and what
-     * the listener is then told about is the change that follows it.
+     * A container with no listener for what it holds does not compose it, so its stored copy predates the
+     * unannounced changes. A registration that adds a listener updates the copy here, so the listener receives the
+     * changes made after the registration.
      */
     protected refreshPreviousValue(): void;
     /** A container holds every member's value whatever the member sends: its `fullValue`. */
     protected get holding(): any;
     /**
-     * The composed verdict `valid` answers with, memoised by Vue. The walk over the children is what makes an error
-     * pushed into one of them visible without a validate() call, and the computed keeps that walk from repeating
-     * while nothing it read has moved.
+     * The composed validity `valid` returns, memoised by Vue. The walk over the children makes an error written into
+     * one of them visible without a validate() call, and the computed skips the walk while nothing it read has
+     * changed.
      */
     private get validRead();
     /**
-     * The composed answer `busy` gives, memoised by Vue. An `Action` counts its executions in a counter of its own,
-     * which no container is told about, so the answer is composed over the children instead of tallied; the computed
-     * keeps the walk from repeating while nothing it read has moved, and a child that is itself a container answers
-     * from its own computed.
+     * The composed value of `busy`, memoised by Vue. An `Action` counts its executions in its own counter, which does
+     * not notify containers, so the value is composed over the children; the computed skips the walk while nothing
+     * it read has changed, and a child that is a container reads its own computed.
      */
     private get busyRead();
     /**
-     * Records that a child started or stopped answering `validating` with true, and carries the transition further
-     * up where it changes this container's own answer.
+     * Records that a child's `validating` became true or false, and passes the transition up if it changes this
+     * container's own `validating`.
      */
     protected childValidatingChanged(started: boolean): void;
     /**
-     * Records a child's new verdict in this container's tally. The child reports it as it settles, and the commit
-     * settles the deepest element first, so the tally a container reads when its own turn comes is finished. The
-     * delta is applied here rather than recomputed by walking the children at commit, which would cost
-     * `O(children)` per container and turn a list fill back into the quadratic walk this tally exists to avoid.
+     * Records a child's new validity in this container's invalid count. The child calls it as it settles, and the
+     * commit settles the deepest element first, so the count is complete when the container settles. The delta is
+     * applied here; recomputing by walking the children at commit would cost `O(children)` per container and make
+     * filling a list quadratic.
      */
     protected childValidityChanged(nowValid: boolean): void;
 }
 
 /**
- * What a container holds beyond the common slots: the object the value getter last built, together with the
- * version of the tree it was built from.
+ * What a container holds beyond the common slots: the object the value getter last built, and the version of the
+ * tree it was built from.
  */
 declare interface ContainerSlots<T = any> extends ElementSlots<T> {
     cachedValue: T;
@@ -394,15 +496,15 @@ declare interface ContainerSlots<T = any> extends ElementSlots<T> {
 }
 
 /**
- * Told what an element contributes to its container's `value` once that changed over a transaction: the element's
- * value where its access sends it, `null` for `'disabled-null'`, and `undefined` for `'disabled'`, whose key or row
- * is left out. The pair carried is (contribution now, contribution at the last announcement).
+ * Fires when what an element sends to its container's `value` changed over a transaction: the element's value if
+ * its access sends it, `null` for `'disabled-null'`, and `undefined` for `'disabled'`, whose key or row is omitted.
+ * The parameters are (contribution now, contribution at the last announcement).
  *
- * It answers a different question from `ValueChangedAction`, which reports what the element holds. A write into a
- * `'disabled'` field changes what the field holds and not what it sends, so it fires `ValueChangedAction` alone;
- * switching a field's access changes what it sends and not what it holds, so it fires this action alone. On a
- * container, what it holds is its `fullValue` and what it sends is its `value`, so a change of a member's access
- * reaches the containers above as a change of their contribution, never of their value.
+ * `ValueChangedAction` reports what the element holds; this action reports what it sends. A write into a
+ * `'disabled'` field changes what the field holds and not what it sends, so it fires only `ValueChangedAction`;
+ * changing a field's access changes what it sends and not what it holds, so it fires only this action. A container
+ * holds its `fullValue` and sends its `value`, so a change of a member's access fires this action on the
+ * containers above, and not `ValueChangedAction`.
  */
 export declare class ContributionChangedAction<T = any> extends FieldActionBase {
     constructor(executorFn: (field: FieldBase<T>, supr: FieldActionExecute<T>, newValue: unknown, oldValue: unknown) => void);
@@ -410,87 +512,129 @@ export declare class ContributionChangedAction<T = any> extends FieldActionBase
     execute(field: FieldBase<T>, supr: FieldActionExecute<T>, newValue: unknown, oldValue: unknown): void;
 }
 
-/** What an element's access is when nothing sets it. */
+/** The keys of the members that send something: every member except an `Action`. */
+declare type DataKeys<T extends GenericFieldsInterface> = {
+    [K in keyof T]: T[K] extends Action<any, any> ? never : K;
+}[keyof T];
+
+/** The default access of an element. */
 export declare const defaultAccess: Access;
 
-/** What an element's visibility is when nothing sets it. */
+/** The default visibility of an element. */
 export declare const defaultVisibility: Visibility;
 
 /**
- * The mutable state of one element, held in an object of its own beside the element rather than in the element's
- * own properties.
+ * Names `element` for the devtools and lists it in opt-in mode. `name` replaces the element's class and number,
+ * `file` the file found from the constructing code. Does nothing in a production build.
+ */
+export declare function describeState(element: FieldBase, description: StateDescription): void;
+
+/** What `configureDevtools()` sets. A member left out keeps its setting. */
+export declare interface DevtoolsOptions {
+    /**
+     * Whether the devtools record and list elements. Defaults to true. While false, nothing is recorded or listed;
+     * an element built while false is not listed after it is set back to true.
+     */
+    enabled?: boolean;
+    /**
+     * Which root elements are listed: `'opt-out'` (default) every one that is not hidden, `'opt-in'` only those
+     * named with `describeState()`.
+     */
+    registration?: DevtoolsRegistration;
+    /**
+     * Whether the stack is captured when a root element is constructed, to show the file that constructed it.
+     * Defaults to true. While false, an element's file is the one `describeState()` gives, or none.
+     */
+    location?: boolean;
+}
+
+/** Which elements the devtools list: every root element except the hidden ones, or only the described ones. */
+export declare type DevtoolsRegistration = 'opt-out' | 'opt-in';
+
+/**
+ * The mutable state of one element, held in a separate object, not in the element's own properties.
  *
- * An element reaches it through two views of that one object, both in private class fields of `FieldBase`:
+ * An element accesses it through two views of that object, both in private class fields of `FieldBase`:
  * `this.state` is `reactive(slots)` and `this.raw` is the object itself. A slot read through `state` inside a
- * render effect or a computed subscribes that effect to the slot, and a write to the slot re-runs it. The
- * bookkeeping an element does for itself goes through `raw`, which neither records a read nor announces a write.
- * The value cache of a container goes through `raw` in particular: its getter writes the cache while it runs, and
- * a tracked write there costs the reading effect one extra evaluation, and one extra render on mount, for a value
- * it has already built.
+ * render effect or a computed subscribes that effect to the slot, and a write to the slot re-runs it. The element's
+ * internal bookkeeping goes through `raw`, which neither tracks a read nor triggers on a write. This includes a
+ * container's value cache: its getter writes the cache while it runs, and a tracked write there would cost the
+ * reading effect one extra evaluation, and one extra render on mount, for a value already built.
  *
- * Being private class fields is what puts the two views out of reach of everything outside `FieldBase`: a private
- * field is absent from `Object.keys`, `JSON.stringify`, `Object.getOwnPropertySymbols` and lodash `getAllKeys` by
- * construction, and needs no per-instance property definition to be. Both `JSON.stringify` and lodash `isEqual`
- * walk their way down a structure over own keys, enumerable symbols included, and the `parent` slot is in the
- * state: reachable, it would take either walker back into the container the element came from.
+ * As private class fields, the two views are not accessible outside `FieldBase`: a private field is absent from
+ * `Object.keys`, `JSON.stringify`, `Object.getOwnPropertySymbols` and lodash `getAllKeys` without any per-instance
+ * property definition. `JSON.stringify` and lodash `isEqual` both walk a structure over own keys, enumerable
+ * symbols included, and the `parent` slot is in the state: if reachable, it would lead either walk back into the
+ * element's container.
  *
- * What they do reach on an element is `_actions` once something is registered, `_fields` and the guarded view
- * over it on a `Group`, and `_itemTemplate` on a `List`. All of them lead downwards only.
+ * The own properties those walks do reach on an element are `_actions` once something is registered, `_fields` on
+ * a `Group`, and `_itemTemplate` on a `List`. All of them lead downwards only.
  */
 declare interface ElementSlots<T = any> {
     /** the value the element was given at construction; isChanged compares against it */
     originalValue: T;
     /**
-     * What the last ValueChangedAction reported the element as holding - its value, and a container's fullValue; the
-     * next transaction measures its net change against it
+     * The value the last ValueChangedAction reported for the element (its value; a container's fullValue); the next
+     * transaction compares its net change against it
      */
     announcedValue: T;
     /**
-     * What the last ContributionChangedAction reported the element as contributing to its container: its value,
-     * `null`, or `undefined` for nothing
+     * What the last ContributionChangedAction reported the element as sending to its container: its value, `null`,
+     * or `undefined` for nothing
      */
     announcedContribution: unknown;
     /**
-     * What a container's own validators last ran over - what it sends; the next transaction runs them where that
-     * moved. A leaf's validators run at the write and the access switch, and leave it untouched.
+     * What a container's own validators last ran over (what it sends); the next transaction runs them again if that
+     * changed. A leaf's validators run at the write and at an access change that changes what it sends, and do not
+     * use this slot.
      */
     validatedValue: unknown;
     errors: ValidationError[];
     visibility: Visibility;
     access: Access;
-    /** counts the writes that changed the value of the element or of anything below it */
+    /** counts the writes that changed the value of the element or of any element below it */
     valueVersion: number;
-    /** how many asynchronous validation runs are in flight on this element */
+    /** the number of asynchronous validation runs in flight on this element */
     validatingCount: number;
-    /** how many direct children answer `validating` with true; a child that starts or stops running moves it */
+    /** the number of direct children whose `validating` is true; updated when a child starts or stops validating */
     validatingChildren: number;
-    /** the container that holds this element, absent while none does; takeChild writes it, releaseChild clears it */
+    /** the container that holds this element, or undefined; takeChild writes it, releaseChild clears it */
     parent: Container | undefined;
-    /** the name the containing Group holds this element under; a List row carries none */
+    /** the name the containing Group holds this element under; undefined for a List row */
     fieldName: string | undefined;
-    /** generation of the validators attached to the element; clearValidators() raises it */
-    validationEpoch: number;
     /**
-     * The extended properties the element carries, typed by the element's own X parameter. A write replaces the
-     * object rather than writing into it, so an effect that read the slot re-runs on the write, and the object a
-     * transaction captured is the one a rollback puts back.
+     * The element's extended properties, typed by the element's X parameter. A write replaces the object instead of
+     * modifying it, so an effect that read the slot re-runs on the write, and a rollback restores the object the
+     * transaction captured.
      */
     extra: object;
     /**
-     * The element this one was bound from, absent on an element that was declared rather than bound. It is what lets
-     * an action shared by every binding work out which binding of a second element it means: `declaration` is the
-     * canonical one, so a binding of a binding names the element the whole family was declared as.
+     * The declaration this element was bound from; undefined on an element that was not bound. An action shared by
+     * every binding uses it to determine which binding of a second element applies: the slot holds the canonical
+     * declaration, so a binding of a binding refers to the original declaration.
      */
     declaration: FieldBase | undefined;
-    /** the verdict the last commit announced, which is what a change of validity is measured against */
+    /**
+     * The access and the visibility the last commit announced, recorded by the first write of either in a
+     * transaction and cleared once the commit announced the net change; undefined while no change is pending.
+     */
+    announcedAccess: Access | undefined;
+    announcedVisibility: Visibility | undefined;
+    /** the validity the last commit announced; a change of validity is detected against it */
     valid: boolean;
-    /** number of direct children whose last announced verdict was invalid */
+    /** the number of direct children whose last announced validity was invalid */
     invalidChildren: number;
+    /**
+     * What the element held when its errors of an origin other than `'validator'` were written, which a `touched`
+     * write compares against for the errors removed on `'edit'`. `NoErrorsBaseline` while there is none to compare
+     * against, and `ChangedSinceErrors` where the value changed before one was recorded.
+     */
+    errorsBaseline: unknown;
 }
 
 /**
- * Told once a write of `access` changed `enabled`: a switch into or out of `'editable'`. It fires after
- * `AccessChangedAction`, and a switch between two accesses that are not `'editable'` does not fire it.
+ * Fires after a write of `access` changed `enabled`: a change into or out of `'editable'`. It fires after
+ * `AccessChangedAction`; a change between two accesses that are not `'editable'` does not fire it.
  */
 export declare class EnabledChangedAction extends FieldActionBase {
     constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, newValue: boolean, oldValue: boolean) => void);
@@ -499,10 +643,11 @@ export declare class EnabledChangedAction extends FieldActionBase {
 }
 
 /**
- * Asked before a write of `access` that would change `enabled`: a switch into or out of `'editable'`. It is asked
- * after `AccessChangingAction`, over the access that would be written. `enabled` is read from `access`, so the
- * answer cannot set it: answering with the value `enabled` has now, or throwing `AbortEventHandlingException`,
- * refuses the write of `access`, and answering with the new value, `null` or `undefined` lets it through.
+ * Fires before a write of `access` that would change `enabled`: a change into or out of `'editable'`. It fires
+ * after `AccessChangingAction`, for the access that would be written. `enabled` is read from `access`, so the
+ * return value cannot set it: returning the current value of `enabled`, or throwing
+ * `AbortEventHandlingException`, cancels the write of `access`; returning the new value, `null` or `undefined`
+ * allows it.
  */
 export declare class EnabledChangingAction extends FieldActionBase {
     constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, newValue: boolean, oldValue: boolean) => boolean);
@@ -511,22 +656,110 @@ export declare class EnabledChangingAction extends FieldActionBase {
 }
 
 /**
- * Where an error comes from. `'validator'` is an error a validator produced, `'server'` one the server returned and
- * `'application'` one the application's own code computed and wrote into `errors`. Any other string is an origin of
- * the application's own.
+ * The content of an error: what failed, the values it failed with, an English sentence describing it, and its
+ * origin. An error the application builds from a server's response has the same content, so a renderer converts
+ * validator and server errors to text with one function.
+ */
+export declare interface ErrorDescription {
+    /** Machine-readable identifier of what failed, in snake_case. */
+    readonly code: string;
+    /** The values of the failure, such as `minValue` for `min_value`. */
+    readonly params: Readonly<Record<string, unknown>>;
+    /** The failure in English, plain text, with `params` substituted. */
+    readonly detail: string;
+    /** The origin of the error; see `ValidationError.origin`. */
+    readonly origin: ErrorOrigin;
+}
+
+/**
+ * The source of an error. `'validator'` is an error a validator produced, `'server'` one the server returned and
+ * `'application'` one the application's code computed and wrote into `errors`. Any other string is an
+ * application-defined origin.
+ *
+ * Every origin but `'validator'` has a rule stating whether its errors count toward validity and when an element
+ * removes them; see `ErrorPolicy`.
  */
 export declare type ErrorOrigin = 'validator' | 'server' | 'application' | (string & {});
 
+/** A rule per origin. `'validator'` has no rule: a validator replaces its own errors and they always count. */
+export declare type ErrorPolicies = Readonly<Partial<Record<Exclude<ErrorOrigin, 'validator'>, ErrorPolicyRule>>>;
+
+/**
+ * Key of the `FieldBase` method that recomputes the validity of every element in its subtree that holds an error
+ * of an origin other than `'validator'`, after the rules over those errors may have changed. `ErrorPolicy` calls
+ * it; the package does not export it.
+ */
+declare const ErrorPoliciesChanged: unique symbol;
+
+/**
+ * The rules of the error origins for the element it is registered on and every element below it. An element takes
+ * the rule of an origin from the nearest `ErrorPolicy` that names it, on itself or on a container above it; an
+ * origin no such policy names takes the rule `setDefaultErrorPolicies` set.
+ *
+ * ```typescript
+ * login.registerAction(new ErrorPolicy({ server: { validEffect: false, removeOn: 'submit' } }));
+ * ```
+ *
+ * Its registration is shared by the element's bindings, as every action's is. Registering or unregistering it
+ * recomputes the validity of the elements below it; an error it now removes stays until the event that removes
+ * it. The constructor throws a TypeError for a rule of `'validator'`, a `validEffect` that is not a boolean, a
+ * `removeOn` that is not an `ErrorRemoval`, and `validEffect: true` with `removeOn: 'submit'`, since such an error
+ * refuses the submit that would remove it. Registering it beside another `ErrorPolicy` that names one of its
+ * origins throws a TypeError.
+ */
+export declare class ErrorPolicy extends FieldActionBase {
+    readonly policies: ErrorPolicies;
+    constructor(policies: ErrorPolicies);
+    static get classIdentifier(): symbol;
+    boundToBinding(binding: FieldBase): void;
+    unregisterFrom(binding: FieldBase): void;
+    private rulesChanged;
+}
+
+/** How the errors of one origin are treated. */
+export declare interface ErrorPolicyRule {
+    /** Whether an error of the origin makes its element, and every container above it, invalid. */
+    readonly validEffect: boolean;
+    /** When an element removes an error of the origin by itself. */
+    readonly removeOn: ErrorRemoval;
+}
+
+/**
+ * When an element removes an error by itself:
+ *
+ * - `'change'`: when the element's value changes. A container's value changes with any member or row below it, and
+ *   when a member or a row is added, removed or written a different `access`.
+ * - `'edit'`: when `touched = true` is written on the element or on an element below it, and the element's value
+ *   differs from the value it held when the error was written.
+ * - `'submit'`: when a `SubmitAction` whose target is the element or a container above it sends the target's value.
+ * - `'never'`: only the code that wrote the error removes it.
+ */
+export declare type ErrorRemoval = 'change' | 'edit' | 'submit' | 'never';
+
+/** The values of `ErrorRemoval`. */
+export declare const errorRemovals: readonly ErrorRemoval[];
+
 export declare class ExecuteAction extends FieldActionBase {
     constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, params: any) => any);
     static get classIdentifier(): symbol;
     execute(field: FieldBase, supr: FieldActionExecute, params: any): any;
+    /**
+     * Whether this handler can run now on `action`. `Action.executable` is false while any of the action's
+     * `ExecuteAction` handlers returns false. The base class returns true; a subclass overrides it with a condition
+     * that a template can bind to, such as the validity of the form a `SubmitAction` sends. The read is reactive where
+     * the condition reads reactive state.
+     */
+    canExecute(action: FieldBase): boolean;
 }
 
+/** Key of the `Action` method that lists its `ExecuteAction` handlers; `Container` calls it, and the package does not
+ * export it. */
+declare const ExecuteHandlers: unique symbol;
+
 /**
- * The extended properties an element carries when nothing states otherwise. It is empty as declared and exists
- * to be augmented: the layer that renders the elements declares what it renders them with, and every element in
- * the application then carries those properties without a type argument at any construction site.
+ * The default type of an element's extended properties. It is declared empty, to be augmented: the rendering
+ * layer declares the properties it renders elements with, and every element in the application then has those
+ * properties without a type argument at any construction site.
  *
  * ```ts
  * declare module '@dynamicforms/vue-forms' {
@@ -538,11 +771,10 @@ export declare class ExecuteAction extends FieldActionBase {
  * }
  * ```
  *
- * The interface is one per application, so two packages that both declare a property of the same name must give
- * it the same type; declaration merging refuses a second declaration that differs.
+ * There is one interface per application, so two packages that declare a property of the same name must give it
+ * the same type; declaration merging rejects a second declaration with a different type.
  *
- * An element that states an X of its own replaces this rather than adding to it, so an element that carries both
- * is `Field<string, Extras & Local>`.
+ * An explicit X type argument replaces this interface, so an element with both is `Field<string, Extras & Local>`.
  */
 export declare interface Extras {
 }
@@ -551,23 +783,29 @@ export declare class Field<T = any, X extends object = Extras> extends FieldBase
     get [Symbol.toStringTag](): string;
     protected get state(): FieldSlots<T>;
     protected get raw(): FieldSlots<T>;
-    /** the value slot itself, without the notifications the value setter carries around a write */
+    /** the value slot itself, without the notifications the value setter sends on a write */
     protected get _value(): T;
     protected set _value(newValue: T);
     constructor(params?: IFieldParams<T, X>);
     /**
-     * Applies the constructor parameters. It is a hook so that a subclass needing different parameter handling
-     * overrides one method instead of redeclaring the constructor - Action does exactly that.
+     * Applies the constructor parameters. A subclass that needs different parameter handling overrides this method
+     * instead of redeclaring the constructor, as Action does.
      *
-     * It is called from this constructor, so it runs before a subclass's own class field initializers, which
-     * only run once super() returns. An override must therefore work off its parameters alone: members the
-     * subclass initializes read as undefined inside it, and anything it writes to such a member is overwritten
-     * the moment the initializer runs.
+     * It is called from this constructor, so it runs before a subclass's class field initializers, which run after
+     * super() returns. An override can therefore use only its parameters: members the subclass initializes are
+     * undefined inside it, and a value it writes to such a member is overwritten when the initializer runs.
      */
     protected init(params?: IFieldParams<T, X>): void;
     get value(): T;
     set value(newValue: T);
+    /** The implementation of `PluginContext.changeInPlace`. */
+    protected [ChangeInPlace](write: () => void, undo: () => void, copy: () => T): void;
     get touched(): boolean;
+    /**
+     * Whether the user has interacted with the field. A rendering layer writes `true` when the user leaves the input;
+     * the write removes the errors whose rule removes them on `'edit'` from the field and the containers above it,
+     * where their values changed since those errors were written (see `ErrorPolicy`).
+     */
     set touched(touched: boolean);
     bind(data?: T, overrides?: IBindParams<T, X>): this;
 }
@@ -577,34 +815,44 @@ export declare abstract class FieldActionBase {
     get classIdentifier(): symbol;
     private readonly executorFn;
     /**
-     * What this action remembers about one of the elements it serves. An action instance is shared - a `List` row
-     * carries the instances the item template carries - so anything an action holds about the element it last ran
-     * over belongs to that element rather than to the action: a verdict, a sequence number, a listener it installed.
-     * The keys are weak, so what an action remembers about a row is released with the row.
+     * The per-element state of this action. An action instance is shared (a `List` row has the same instances as
+     * the item template), so state about the element it runs over is stored per element: a validation result, a
+     * sequence number, a listener it installed. The keys are weak, so the state for a row is released with the row.
      */
     private readonly states;
     constructor(executorFn: ActionExecutor);
     /**
-     * This action's state for `key`, created by `init` the first time it is asked for. The key is the element the
-     * action is running over, or the record that element belongs to where what is remembered is a fact about the
-     * whole record.
+     * Returns this action's state for `key`, created by `init` on first access. The key is the element the action
+     * runs over, or the record that element belongs to if the state concerns the whole record.
      */
     protected state<S>(key: object, init: () => S): S;
+    /**
+     * Drops this action's state for `key`, so the next `state()` call creates it again. A rollback of the operation
+     * that dropped it puts it back.
+     */
+    protected forgetState(key: object): void;
     execute(field: FieldBase, supr: FieldActionExecute, ...params: any[]): any;
     get eager(): boolean;
     /**
-     * Announces that this action now serves `binding`. It runs once per element the action is registered on, the
-     * copies of that element included: a copy takes on the instances it was copied from and each is told about the
-     * copy as it does.
+     * Called when this action is bound to `binding`. It runs once per element the action is registered on, bindings
+     * of that element included: a binding uses the action instances of its declaration, and each is called with the
+     * binding.
      */
     boundToBinding(binding: FieldBase): void;
     /**
-     * Announces that `binding` no longer holds this action, and takes back what running it left there. It names one
-     * element rather than the action as a whole, because the instance goes on serving every other element it was
-     * registered on. It runs inside the operation that drops the registration, so an operation that unwinds puts the
-     * registration and what this took back both back.
+     * Called when `binding` no longer has this action; an override removes what running the action left on it. It
+     * receives one element because the same instance stays registered on other elements. It runs inside the
+     * operation that removes the registration, so a rollback of that operation restores both the registration and
+     * what this method removed.
      */
     unregisterFrom(binding: FieldBase): void;
+    /**
+     * Called when `binding` is reset to a new binding of its declaration: a member of a bound group, or a `List` row
+     * reused for another record. An override drops what it keeps about the element's state before the reset; the
+     * element's eager actions other than the validators run again once the reset holds every new value, before the
+     * baseline is recorded.
+     */
+    resetBinding(binding: FieldBase): void;
 }
 
 export declare type FieldActionExecute<T = any> = (field: FieldBase<T>, ...params: any[]) => any;
@@ -612,29 +860,26 @@ export declare type FieldActionExecute<T = any> = (field: FieldBase<T>, ...param
 export declare abstract class FieldBase<T = any, X extends object = Extras> {
     #private;
     /**
-     * Vue's getTargetType answers INVALID for an object that carries __v_skip, so reactive() hands an element back
-     * unwrapped and no element is ever behind a proxy of its own. isReactive() reads the second flag, and it stays
-     * true because what carries an element's reactivity - its state - is a reactive object.
+     * Vue's getTargetType returns INVALID for an object that has __v_skip, so reactive() returns an element
+     * unwrapped and no element is wrapped in a proxy of its own. isReactive() reads the second flag, which is true
+     * because the element's state, which holds its reactivity, is a reactive object.
      *
-     * Two consequences for a consumer, both silent. watch(field, cb) with a bare element as the source registers
-     * no dependency, because the deep traversal Vue starts for a reactive source stops on __v_skip; the supported
-     * form is watch(() => field.value, cb). And readonly(field) hands the element straight back, so the value it
-     * returns is the element itself and a write through it reaches the field; what a caller hands out instead is
-     * the value, which is frozen, or a computed over it.
+     * Two consequences for a consumer, neither of which raises an error. watch(field, cb) with a bare element as the
+     * source registers no dependency, because Vue's deep traversal of a reactive source stops on __v_skip; use
+     * watch(() => field.value, cb). readonly(field) returns the element itself, so a write through the result
+     * reaches the field; to pass a read-only view, pass the value (which is frozen) or a computed over it.
      */
     get __v_skip(): boolean;
     get __v_isReactive(): boolean;
     /**
-     * Names the element's class, which is what a structural comparison of two elements answers on. An element keeps
-     * its state in private class fields, so a walk over own keys reaches none of it; lodash reads this tag through
-     * Object.prototype.toString before it compares anything, and a tag it does not know ends the comparison there.
-     * Two elements are therefore equal only where they are the same element. What they hold is compared as
-     * isEqual(a.value, b.value).
+     * The tag that a structural comparison of two elements uses. An element keeps its state in private class fields,
+     * so a walk over own keys reaches none of it. lodash reads this tag through Object.prototype.toString before it
+     * compares anything and stops at a tag it does not recognise, so two elements are equal only if they are the
+     * same element. The package's own `isEqual` compares an element by the value it holds.
      *
-     * It is an accessor on the prototype, so an element carries nothing for it, and `Object.prototype.toString`
-     * answers `[object Field]` rather than `[object Object]`. Each class states its own name as a literal: a
-     * minifier renames the class itself, so reading the constructor's name would report whatever the build called
-     * it.
+     * It is an accessor on the prototype, so it adds no own property to an element, and `Object.prototype.toString`
+     * returns `[object Field]` instead of `[object Object]`. Each class declares its name as a literal, because a
+     * minifier renames the class and the constructor's name would be the minified one.
      */
     get [Symbol.toStringTag](): string;
     constructor(slots: ElementSlots<T>);
@@ -647,345 +892,411 @@ export declare abstract class FieldBase<T = any, X extends object = Extras> {
     abstract get touched(): boolean;
     abstract set touched(touched: boolean);
     /**
-     * A new element of this one's class over `data`: same class, same registered actions, same extended properties,
-     * and the change history starting over. It is how a declaration is put to work over a record - every row a
-     * `List` builds is its item template bound to that row's data - and the element it is called on is what the new
-     * one answers `declaration` with.
+     * Returns a new element of this one's class over `data`, with the same registered actions and extended
+     * properties and a new change history. Every row a `List` builds is its item template bound to that row's data.
+     * The new element's `declaration` is the element `bind()` is called on.
      *
-     * `data` of `undefined` is no data supplied and the new element carries what this one holds; an explicit `null`
-     * is data and clears. `overrides` states the rest: `originalValue` is read by key presence, `access` and
-     * `visibility` fall back to this element's, and extended properties it names are written over the ones carried
-     * over. The new element is detached - no `parent`, no `fieldName` - so it is free to be taken by a container.
+     * `data` of `undefined` means no data: the new element holds what this one holds. An explicit `null` is data and
+     * clears the value. In `overrides`, `originalValue` is applied when the key is present, `access` and `visibility`
+     * default to this element's, and the extended properties given are written over the copied ones. The new element
+     * is detached (no `parent`, no `fieldName`), so a container can take it.
      */
     abstract bind(data?: T, overrides?: IBindParams<T, X>): FieldBase<T, X>;
     /**
-     * Exchanges the data this element holds for `data`, in place. The element is the same instance afterwards - its
-     * identity, its actions, its extended properties and its place in whatever container holds it all stand - and it
-     * ends up in the state `bind(data)` would have produced: the values are written, the change history starts over
-     * and the validators run. It is what recycles one element across records, which is what a virtualised renderer
-     * does with the rows it keeps.
+     * Replaces the data this element holds with `data`, in place. The instance, its actions, its extended properties
+     * and its position in its container are unchanged, and the element ends in the state `bind(data)` produces: the
+     * values are written, the change history starts over and the validators run. A virtualised renderer uses it to
+     * reuse one element across records.
+     *
+     * No `ValueChangedAction` fires for the element itself, as for a newly built element. Its members announce their
+     * changes, and a change of validity is announced as usual: a rebound element that is invalid updates the invalid
+     * count of its container. If an open transaction already has a pending value change for the element, the commit
+     * announces it with the value the element had when the transaction opened as the old value.
      *
-     * The element makes no statement of its own about the exchange: no `ValueChangedAction` fires for it, the way
-     * none fires for an element that was just built. Its members do announce theirs, and a verdict that moves is
-     * announced as always - a rebound element that is invalid says so to the container holding it. A change an
-     * open transaction is already owed an announcement for stands: the commit reports the pair measured from
-     * where the element was when the transaction opened.
+     * A member of a `Group` whose key is missing from `data` takes the `originalValue` of the corresponding member of
+     * the group's `declaration`: for a group that is its own declaration, the member's own baseline. A key missing
+     * from the data never takes the value of the previous record.
      *
-     * The data is measured against the element's `declaration`, so a key a record leaves out is taken from the
-     * declaration rather than left as the previous record had it.
+     * The element keeps its `access` and `visibility`. A member reset from an element other than itself (a member of
+     * a bound group, a reused `List` row) takes them from that element, see `resetChild`.
      */
     rebind(data: T): this;
     /** contains original field value as was provided at creation */
     get originalValue(): T;
     set originalValue(newValue: T);
     /**
-     * The extended properties this element carries: what a consumer attached to it beyond the members the class
-     * declares, such as the label, hint or css class a UI layer binds to the input it renders the element with.
-     * The read is tracked, so a template rendering off `field.extra.label` re-renders when the property is written.
+     * The extended properties of this element: properties a consumer attached beyond the members the class declares,
+     * such as the label, hint or css class a UI layer binds to the input it renders for the element. The read is
+     * tracked, so a template that reads `field.extra.label` re-renders when the property is written.
      *
-     * Every property is optional here, whatever `X` states: a parameter object need not carry one and
-     * setExtendedValues writes as few as a caller likes, so a property `X` declares as required is present only
-     * once something has written it.
+     * Every property is optional here, whatever `X` declares: a parameter object need not contain any, and
+     * setExtendedValues can write any subset, so a property `X` declares as required is present only after it has
+     * been written.
      *
-     * The object is frozen and setExtendedValues is the way to change it: it is the object a transaction captured,
-     * and one written in place would leave a rollback with nothing to put back.
+     * The object is frozen; change it with setExtendedValues. A transaction captures this object, so an in-place
+     * write would leave a rollback with no previous state to restore.
      */
     get extra(): Readonly<Partial<X>>;
     /**
-     * Writes extended properties. The values given are merged over the ones the element carries, so a write of one
-     * property leaves the others standing, and the merged set replaces the object the element held.
+     * Writes extended properties. The given values are merged over the existing ones, so a write of one property
+     * keeps the others, and the merged object replaces the one the element held.
      */
     setExtendedValues(values: Partial<X>): void;
     /**
-     * The extended properties a parameter object carries: every key the element does not answer for itself. A key
-     * the element answers for at the time the parameters are applied - `value`, `access`, an accessor a subclass
-     * adds - is the element's own; a key that only Object.prototype answers for is nobody's declaration and counts
-     * as extended, and `validators` and `actions` are neither, since they state what to register on the element.
+     * Returns the extended properties in a parameter object: every key that is not a member of the element. A key
+     * that is a member when the parameters are applied (`value`, `access`, an accessor a subclass adds) belongs to
+     * the element. A key that exists only on Object.prototype counts as extended. `validators` and `actions` are
+     * neither: they name what to register on the element.
      *
-     * A member a subclass declares as a class field is not among the keys the element answers for: class fields are
-     * defined on the instance after the base constructor returns, and the parameters are applied inside it. A
-     * subclass that wants a parameter of its own name assigned to it declares that member as an accessor.
+     * A member a subclass declares as a class field is not a member at this point: class fields are defined on the
+     * instance after the base constructor returns, and the parameters are applied inside it. A subclass that needs a
+     * parameter assigned to a member of the same name declares that member as an accessor.
      */
     protected extendedOf(params: object): Partial<X>;
     /**
-     * Applies a parameter object: the members the element answers for are assigned to the element and the rest
-     * become its extended properties. Assigning a getter-only member throws a TypeError, which is what a caller
-     * naming `valid` or `parent` past the type system gets.
+     * Applies a parameter object: a key that names an accessor of the element is assigned to the element, and every
+     * other key becomes an extended property. A key named like a method or another non-accessor member (`validate`,
+     * `bind`, `settled`) is stored in `extra` and leaves the member as it is. Assigning a getter-only accessor throws a
+     * TypeError, so a parameter object that bypasses the type system and contains `valid` or `parent` throws.
      */
     protected assignParams(params: object): void;
     /**
-     * Takes this element into the record of the open transaction, where one is open. A write of a single slot that
-     * announces nothing calls it instead of opening a transaction of its own: on its own such a write is already
-     * atomic, and inside a transaction it has to be part of what a rollback puts back.
+     * Adds this element to the record of the open transaction, if one is open. A write of a single slot that announces
+     * nothing calls it instead of opening a transaction: outside a transaction such a write is atomic, and inside one
+     * it must be restored by a rollback.
      */
     protected touchState(): void;
     /**
-     * Records the whole of this element's mutable state, so that a rolled-back transaction can put it back exactly
-     * as it found it. The errors array is copied because a validator writes into the array it is handed rather than
-     * replacing it, and a subclass copies whatever else it holds by reference the same way.
+     * Records all of this element's mutable state, so that a rolled-back transaction restores it exactly. The errors
+     * array is copied because a validator modifies the array in place, and a subclass copies any other state it holds
+     * by reference in the same way.
      *
-     * What is not in the snapshot is the action map, which no write touches: an operation that replaces it hands
-     * the transaction its own undo instead, so this stays the one shape every element captures.
+     * The action map is not in the snapshot: no write modifies it, and an operation that replaces it registers its
+     * own undo with the transaction, so every element captures the same shape.
      */
     protected [TxCapture](): TxSnapshot;
     /**
-     * Puts a captured state back. It writes through the tracked view, so an effect that ran on the state the
-     * transaction produced runs again on the state it is being returned to, and only for the slots that differ.
+     * Restores a captured state. It writes through the tracked view, so an effect that ran on the state the
+     * transaction produced runs again on the restored state, for the slots that differ.
      *
-     * The two validation counters are the slots the element keeps: they count runs that are in flight, and a
-     * rollback cannot un-start one. Put back, the counts would no longer match the endValidating calls still to come.
+     * The two validation counters are not restored: they count runs in flight. A rollback cancels the asynchronous
+     * runs the transaction started, and each cancelled run ends its count when its promise settles; restored counts
+     * would not match the endValidating calls still to come.
      */
     protected [TxRestore](snapshot: TxSnapshot): void;
     /**
-     * True while an asynchronous validation is in flight on this element or on anything below it, so a form answers
-     * for the whole tree it holds. The answer is a pair of counters rather than a walk: the element's own runs, and
-     * how many of its children answer the same question with true. A child that starts running while it was idle,
-     * or stops while it was the last one running, moves its container's tally, and a tally that changes the
-     * container's own answer moves the one above it - the transition costs the nesting depth and the read costs
-     * nothing.
+     * True while an asynchronous validation is in flight on this element or on any element below it, so on a form it
+     * covers the whole tree. It is computed from two counters, without a walk: the element's own runs, and the number
+     * of its children whose `validating` is true. A child that becomes validating or stops validating updates its
+     * container's counter, and a change of the container's `validating` updates the counter above it. A transition
+     * costs one step per nesting level; a read costs one counter comparison.
      */
     get validating(): boolean;
-    /** announces the start of one asynchronous validation run; validators pair it with endValidating */
-    beginValidating(): void;
-    /** announces the end of one asynchronous validation run */
-    endValidating(): void;
     /**
-     * Records that a child started or stopped answering `validating` with true, and carries the transition further
-     * up where it changes this element's own answer. Only a `Container` has children, and it implements this; it is
-     * declared here because a child tells its container through it.
+     * Counts one asynchronous validation run as started and returns the function that counts it as ended. The
+     * function ends that run only: a second call does nothing, so `validating` and `settled()` cannot report the end
+     * of a run that is still in flight.
+     */
+    [BeginValidating](): () => void;
+    /**
+     * Records that a child's `validating` became true or false, and passes the transition up if it changes this
+     * element's own `validating`. Only a `Container` has children and implements this; it is declared here because a
+     * child calls it on its container.
      */
     protected childValidatingChanged(started: boolean): void;
     /**
-     * True while an `Action.execute()` at or below this element has yet to settle. An `Action` answers for its own
-     * runs; a container answers for the actions below it; anything else answers false, because an element that is
-     * not an action has nothing to execute.
+     * True while an `Action.execute()` at or below this element has not settled. On an `Action` it covers its own
+     * runs, on a container the actions below it; on any other element it is false.
      *
-     * It states one thing and `validating` states the other, so a form that gates a submit button on the tree being
-     * idle reads both.
+     * It does not include validation; `pending` covers both.
      */
     get busy(): boolean;
     /**
-     * Resolves once nothing at or below this element is running - no asynchronous validation, no `Action.execute()`
-     * that has yet to settle. It is what a submit path awaits instead of polling `validating` and `busy`, and it
-     * resolves at once where nothing is running to begin with.
+     * True while an asynchronous validation or an `Action.execute()` at or below this element has not settled:
+     * `validating || busy`. It is reactive, so a template binds a submit button to it. `settled()` resolves when it
+     * turns false.
+     */
+    get pending(): boolean;
+    /**
+     * Resolves when nothing at or below this element is running: no asynchronous validation and no unsettled
+     * `Action.execute()`, which is when `pending` is false. A submit path awaits it instead of polling `pending`. If
+     * nothing is running, the returned promise is already resolved.
      *
-     * It answers for the moment it resolves and makes no promise about the one after: work started later leaves the
-     * element running again, so a caller that has to act on a settled tree reads what it needs immediately after
-     * awaiting rather than at its leisure.
+     * It covers only the moment it resolves: work started later makes the element run again, so a caller that needs
+     * a settled tree reads what it needs immediately after the await.
      */
     settled(): Promise<void>;
     /**
-     * List of errors. The array handed out is the one the element holds, and a validator writes into it in place,
-     * so a transaction that is open takes the element into its record here: a rollback that put back everything
-     * except the errors would leave a state the form never held.
+     * List of errors. The returned array is the one the element holds, and a validator modifies it in place, so this
+     * getter adds the element to an open transaction's record: otherwise a rollback would restore everything except
+     * the errors.
+     *
+     * The array and its members are Vue proxies, not the raw instances a validator returned: `field.errors[0] ===
+     * myError` is `false` even for the same error. Compare identity with `toRaw()`.
      *
-     * The array and its members are Vue proxies, not the raw instances a validator returned - `field.errors[0] ===
-     * myError` is `false` for the very error that produced it. Unwrapping here would lose the tracked read a
-     * template needs to re-render when a message behind a `Ref` changes; `toRaw()` compares identity instead.
+     * Whether an error of an origin other than `'validator'` counts toward `valid`, and when the element removes it
+     * by itself, is the rule of its origin: see `ErrorPolicy`. An `'edit'` rule compares the value the element holds
+     * against the one it held when the error was written: the value at the assignment of `errors`. For an error added
+     * to the array in place it is the value at the next read of `errors` outside a transaction, and a change of the
+     * element's value before that read counts as a change.
      */
     get errors(): ValidationError[];
     set errors(newValue: ValidationError[]);
+    /** Records the value the element holds as `errorsBaseline` where it holds a ruled error and has none recorded. */
+    private noteErrorsBaseline;
+    /**
+     * The rule of `origin` for this element: the one stated by the nearest `ErrorPolicy` naming it, on this element or
+     * on a container above it, and otherwise the default. The walk reads `parent` through the tracked view, so a
+     * validity computed over it follows the element into another container.
+     */
+    private ruleOf;
+    /** This element and every container above it, nearest first. */
+    private selfAndAbove;
+    /** Whether `errors`, held by this element, leave it valid: none of them counts toward validity. */
+    protected ownErrorsValid(errors: readonly ValidationError[]): boolean;
+    /**
+     * Removes the ruled errors whose rule `removes` accepts and returns whether it removed any. The caller has added
+     * the element to the transaction and recomputes its validity.
+     */
+    private removeErrors;
+    /**
+     * Called when `touched = true` is written on this element: on it and on every container above it, the errors whose
+     * rule removes them on `'edit'` are removed where the element's value differs from the one recorded when they
+     * were written.
+     */
+    protected editConcluded(): void;
+    /** Removes, on this element and every element below it, the errors whose rule removes them on `'submit'`. */
+    [RemoveErrorsOnSubmit](): void;
+    /**
+     * Recomputes the validity of every element at or below this one that holds a ruled error, after the rules over
+     * those errors may have changed.
+     */
+    [ErrorPoliciesChanged](): void;
     /**
      * The container that holds this element: the Group it is a member of, or the List whose row it is, and
-     * undefined while no container holds it. The container writes it; everyone else reads it. The read is tracked,
-     * so an effect rendering off the link - `v-if="field.parent"` - re-runs when a container takes the element or
-     * releases it.
+     * undefined while no container holds it. Only the container writes it. The read is tracked, so an effect that
+     * reads it (`v-if="field.parent"`) re-runs when a container takes or releases the element.
      *
-     * The type is `Container`, which names no members: a sibling lookup states which container it expects, either
-     * with `field.parent instanceof Group` or with a cast where the structure guarantees it.
+     * The type is `Container`, which declares no members: a sibling lookup narrows it, either with
+     * `field.parent instanceof Group` or with a cast where the structure guarantees the type.
      */
     get parent(): Container | undefined;
     /**
-     * The same link at the type the internals reach through. The hooks a child tells its container things through -
-     * childValidatingChanged, childValidityChanged - are declared here, and a protected member is reachable only
-     * through the class that declares it; `Container` overrides them, so the link is read as a `FieldBase`.
+     * The same link, typed as `FieldBase` for internal calls. The hooks a child calls on its container
+     * (childValidatingChanged, childValidityChanged) are declared here, and a protected member is reachable only
+     * through the class that declares it; `Container` overrides them.
      */
     private get container();
     /** when member of a Group, fieldName specifies the name of this field. Written by the group, read-only after */
     get fieldName(): string | undefined;
     /**
      * The element this one was declared as: itself for an element built from parameters, and the element it was
-     * bound from for a binding - transitively, so a binding of a binding names the same one. Every row a `List`
-     * builds from an item template is a binding of it, so a row's member and the template's member it stands for
-     * answer with the same element, and an action registered on the template can tell the two apart.
+     * bound from for a binding, transitively, so a binding of a binding has the same declaration. Every row a `List`
+     * builds from its item template is a binding of it, so a row's member and the corresponding item template member
+     * have the same `declaration`, and an action registered on the item template can distinguish the two.
      */
     get declaration(): FieldBase;
     /** The elements this one holds: a Group's members, a List's rows, none for a leaf. */
     protected get members(): FieldBase[];
     /**
-     * Every element in this element's subtree, this element included, that was declared as `declaration`. It answers
-     * the question a shared action asks when the record it changed in is not the record its targets live in - a form
-     * field that every row of a list reacts to - and it costs the subtree, so it is the path taken only when the
-     * cheaper one, resolving within a single record, does not apply.
+     * Returns every element in this element's subtree, this element included, whose declaration is `declaration`. A
+     * shared action uses it when the change happened in a different record than its targets (a form field that every
+     * row of a list reacts to). It walks the subtree, so it is used only when resolution within a single record does
+     * not apply.
      */
     bindingsOf(declaration: FieldBase): FieldBase[];
     /** set while an eager pass over this element is waiting for the record the element belongs to */
     protected _recordPending?: boolean;
     /**
-     * States that an eager pass over this element reached an element it needs and did not find it, because the
-     * record this element belongs to was not assembled at the time: a `List` row is built member by member and its
-     * members are bound before any of them holds the row, so a validator comparing two of them runs before the
-     * row exists. The container that finishes the record runs the pass again, and a pass that still reaches
-     * nothing says so again, so the next container above answers for it.
+     * Marks that an eager pass over this element did not find an element it needs, because the record this element
+     * belongs to was not assembled yet: a `List` row is built member by member and its members are bound before the
+     * row holds them, so a validator comparing two of them runs before the row exists. The container that completes
+     * the record runs the pass again; a pass that still finds nothing marks the element again, and the next container
+     * above runs it.
      */
     markRecordIncomplete(): void;
     /**
-     * Runs the eager passes outstanding in `element`'s subtree, now that the record it belongs to is assembled. A
-     * container calls it where it has just made a record complete: a Group that has written its members, and a
-     * List that has taken a row, which is what gives the row's fields the form above it.
+     * Runs the pending eager passes in `element`'s subtree, once the record it belongs to is assembled. A container
+     * calls it after it completes a record: a Group after it has written its members, and a List after it has taken a
+     * row, which connects the row's elements to the form above it.
      */
     protected completeRecords(element?: FieldBase): void;
-    /** Runs this element's eager actions over the value it holds and re-forms the verdict they reach. */
+    /** Runs this element's eager actions over the value it holds and recomputes its validity. */
     private rerunEagerActions;
     /**
-     * The map an element that was declared rather than bound registers its actions in, absent while it has registered
-     * none. A binding holds no map of its own: `boundActions` reads the one its declaration holds.
+     * The map of actions registered on a declaration; undefined until one is registered. A binding has no map of its
+     * own: its slot holds the same map as its declaration.
      */
     protected _actions?: ActionsMap;
     /**
-     * The actions this element answers to, absent where nothing is registered. A binding holds the very map its
-     * declaration holds rather than a copy of it, so the slot is read directly: what a trigger costs is one property
-     * read, and a rule registered on a `List`'s item template reaches every row through the map they share - the
-     * rows built before the registration as much as the ones built after.
+     * The actions registered for this element; undefined if none are registered. A binding holds its declaration's
+     * map itself, not a copy, so a trigger reads one property, and a rule registered on a `List`'s item template
+     * reaches every row through the shared map, including rows built before the registration.
      */
     protected get boundActions(): ActionsMap | undefined;
     /** Records that `binding` was made from this element, so a later registration can reach it. */
     protected noteBinding(binding: FieldBase): void;
-    /**
-     * The bindings made from this element that are still alive, and this element itself. The dead references are
-     * dropped as they are found, which is what keeps the set from growing over the life of a long-lived declaration.
-     */
+    /** The live bindings made from this element's declaration and the declaration; removes the dead references. */
     protected get boundElements(): FieldBase[];
     /**
-     * The map registrations go into: the declaration's, since that is where behaviour lives. The map is made on the
-     * first registration and handed to every binding already made from the declaration, so all of them go on reading
-     * one map through a slot of their own.
+     * The map registrations go into: the declaration's. The map is created on the first registration and assigned to
+     * every binding already made from the declaration, so all of them read one map through their own slot.
      */
     protected get actions(): ActionsMap;
     /**
-     * Counts the writes that have changed the value of this element or of anything below it. A container reads it
-     * before answering from its value cache, and the read is an ordinary tracked one, so an effect that took a
-     * cached value still re-runs when a descendant is written.
+     * Counts the writes that have changed the value of this element or of any element below it. A container reads it
+     * before returning its cached value, and the read is tracked, so an effect that read a cached value re-runs when
+     * a descendant is written.
      */
     protected get valueVersion(): number;
     /**
-     * Marks the value of this element and of every ancestor as superseded. It walks the parent chain, so it costs
-     * the nesting depth: an ancestor rebuilds its value the next time one is asked of it, instead of being walked
-     * here for a reader that may never come. The walk also brings each element into the open transaction, so a
-     * rollback puts the versions back and no reader is left holding a cache the tree no longer supports.
+     * Marks the value of this element and of every ancestor as outdated. It walks the parent chain only (one step per
+     * nesting level); an ancestor rebuilds its value on the next read. The walk adds each element to the open
+     * transaction, so a rollback restores the versions and no cached value outlives the state it was built from.
      */
     protected bumpValueVersion(): void;
     /**
-     * States that this element's value changed and that every container above it therefore holds a different value
-     * too. Nothing is announced here: the transaction works out at commit which of the elements enrolled actually
-     * ends up holding a different value, and announces those once each.
+     * Marks that this element's value changed, and with it the value of every container above it. Nothing is
+     * announced here: at commit the transaction determines which enrolled elements hold a different value and
+     * announces each of them once.
+     *
+     * Every value change of an element passes through here, so this is where the element removes the errors whose
+     * rule removes them on `'change'`, and records that its value changed where it holds a ruled error with no value
+     * recorded to compare against. The removal is part of the transaction and a rollback restores the errors.
      *
-     * `force` states that the caller already knows this element's value changed - one item more or fewer is a
-     * different list whatever the items compare as - so the commit announces it without composing a comparison.
+     * `force` means the caller has established that the value changed (a list with one item more or fewer is a
+     * different list whatever the items compare as), so the commit announces it without a comparison.
      */
     protected propagateValueChanged(force?: boolean): void;
+    /** What a change of the element's value does to its ruled errors; see `propagateValueChanged`. */
+    private errorsAfterChange;
     /**
-     * The last step of a construction: it runs inside the transaction the construction is, with the parameters
-     * applied and the value in place, before the element records what it was built as.
+     * The last step of a construction: it runs inside the construction's transaction, with the parameters applied and
+     * the value in place, before the element records its initial state.
      *
-     * A subclass overrides it to complete what the element was built with. What it writes here is part of the
-     * construction rather than a change of it: the element announces no ValueChangedAction, and what the hook
-     * leaves is what its eager actions and its validators run over, once. An element whose parameters named no
-     * `originalValue` is baselined on the value the hook left and so starts unchanged; one that named a baseline is
-     * measured against it, as any element is. A `Field` writes `_value`: the value setter states a change, and
-     * this is not one.
+     * A subclass overrides it to complete the element. What it writes here is part of the construction, not a
+     * change: the element announces no ValueChangedAction, and its eager actions and validators run once over the
+     * state the hook leaves. An element whose parameters contain no `originalValue` takes the value the hook left as
+     * its `originalValue` and starts unchanged; one whose parameters contain `originalValue` is compared against it.
+     * A `Field` writes `_value` here, because the value setter records a change.
      *
-     * A container completes itself through its members, and a member carries a construction of its own: the write
-     * reaches it as any later one would, so the member announces it and reports itself changed. A member that is to
-     * start unchanged is baselined here as well - `this.fields.x.originalValue = this.fields.x.value`.
+     * A container completes itself through its members, and each member has already been constructed: the write
+     * reaches it as a regular change, so the member announces it. A `Group` constructed with a value records what each
+     * member holds after this hook as its baseline; without a value the member reports itself changed. To have a
+     * member start unchanged in both cases, set its baseline here as well:
+     * `this.fields.x.originalValue = this.fields.x.value`.
      *
-     * `params` is the parameter object the constructor received, where it received one.
+     * `params` is the parameter object the constructor received, if any.
      */
     protected constructed(params?: object): void;
     /**
-     * Re-reads what the next announcements will report as replaced. A contribution is composed only where something
-     * listens for it, so the copy is re-read here; a leaf records what it holds at every announcement, so that copy
-     * is always current, and a container that skipped composing what nobody was listening for re-reads its own too.
+     * Re-reads the old value the next announcements will report. A contribution is composed only when something
+     * listens for it, so the stored copy is re-read here. A leaf records its value at every announcement, so that
+     * copy is always current; a container, which composes its held value only for a listener, re-reads that too.
      */
     protected refreshPreviousValue(): void;
     /**
-     * The verdict validate() records and announces: this element's own errors plus the tally of children that
-     * reported themselves invalid, so a container forms it without walking its members. `valid` is the read path
-     * and answers over the live errors arrays instead; the two differ only for an error written into a member
-     * without a validate() call, which is the documented cost of pushing errors by hand.
+     * The validity validate() records and announces: computed from this element's own errors and the count of invalid
+     * children, so a container computes it without walking its members. `valid` reads the live errors arrays instead;
+     * the two differ only for an error written into a member without a validate() call, which is the documented
+     * limitation of writing errors by hand.
      */
     protected get countedValid(): boolean;
     /**
-     * Makes this element the container of `child`: it installs the back-reference, records the name a Group holds
-     * the child under, and takes the child into the invalid tally. An element belongs to one container at a time,
-     * so a child that already carries the link is refused; releaseChild() takes the link away again, and an element
-     * released that way can be handed on. The child's state is unreachable from outside FieldBase, so a container
-     * writes the two slots through here rather than on the child.
+     * Makes this element the container of `child`: it sets the back-reference, records the name a Group holds the
+     * child under, and adds the child to the invalid count. An element belongs to one container at a time, so a
+     * child that already has a parent throws a TypeError; releaseChild() removes the link, after which the element
+     * can be taken by another container. A container cannot take itself or a container above it, which also throws a
+     * TypeError: the parent links would form a cycle, and a walk up them would not end. The child's state is private
+     * to FieldBase, so a container writes the two slots through this method.
      */
     protected takeChild(child: FieldBase, fieldName?: string): void;
-    /** Takes a child into this element's invalid tally; a container calls it once the child's parent link exists. */
+    /** Adds a child to this element's invalid count; a container calls it after setting the child's parent link. */
     protected adoptChild(child: FieldBase): void;
     /**
-     * Drops a child out of this element's invalid tally and takes its back-reference away. An element keeps no link
-     * to a container that no longer holds it: it would go on moving that container's tally, and the link is what
-     * stands in the way of the element being taken by another container.
+     * Removes a child from this element's invalid count and clears its back-reference. With the link left in place,
+     * the element would keep updating that container's invalid count and could not be taken by another container.
      */
     protected releaseChild(child: FieldBase): void;
     /**
-     * Brings this element to the state a fresh binding of `source` carrying `value` would be in: `value` is written
-     * where the caller supplied one and `source`'s own value where it did not, the change history - originalValue,
-     * touched - starts over and the errors are dropped and re-established by the validators. A container that reuses
-     * an element at a position it already holds calls it, so the element is indistinguishable from one built for
-     * that position.
+     * Sets this element to the state of a new binding of `source` with `value`: `value` is written if supplied, and
+     * `source`'s value otherwise; the change history (originalValue, touched) starts over, and the errors are cleared
+     * and set again by the validators. A container that reuses an element at a position calls it through
+     * `resetChild`, which also writes the flags, inside `asReset`, which applies the rules before the baseline is
+     * final, so the element is in the state of one built for that position; extended properties are kept.
      */
     protected resetTo(source: FieldBase, value: any): void;
-    /** Resets a member. It is what lets a container reach the reset of a child whose class it does not know. */
+    /**
+     * Resets a member. A container calls it to reset a child of any class. A child reset from an element other than
+     * itself (a member of a bound group, a reused `List` row) also takes `source`'s `access` and `visibility`, and its
+     * eager actions run again once the record is complete, so the conditional rules apply over the new record. A child
+     * that is its own source (a member of a declared group) keeps its flags.
+     */
     protected resetChild(child: FieldBase, source: FieldBase, value: any): void;
     /**
-     * Records a child's new verdict in this element's tally. Only a `Container` has children, and it implements
-     * this; it is declared here for the reason `childValidatingChanged` is.
+     * Runs `reset`, which resets elements to new records through `resetTo`, as one reset. Once every element holds
+     * its new values, the rules of each reset element (its eager actions other than the validators) run over them, and
+     * each records its baseline again, so `originalValue` includes what the rules changed: a member a conditional
+     * access enables is in its container's baseline. A reset inside a reset is part of the outer one.
+     */
+    protected asReset(reset: () => void): void;
+    /**
+     * Records what every element below this one holds as its baseline, each after its own members. A binding, and a
+     * group constructed with a value, call it once built, so a member written by the construction is not a change.
+     */
+    protected baselineMembers(): void;
+    /**
+     * Records what the element holds as its baseline at the end of a reset. A container also records it as the
+     * value its listeners last heard: the container that reset it announces the change.
+     */
+    protected recordBaseline(): void;
+    /**
+     * Records a child's new validity in this element's invalid count. Only a `Container` has children and implements
+     * this; it is declared here for the same reason as `childValidatingChanged`.
      */
     protected childValidityChanged(nowValid: boolean): void;
     /**
-     * How a rendering layer shows this element. It is presentation alone: what the element sends and whether it is
-     * validated are its `access`, and no visibility changes either.
+     * How a rendering layer shows this element. It affects presentation only: what the element sends and whether it
+     * is validated are determined by `access`, and visibility changes neither.
      */
     get visibility(): Visibility;
     set visibility(newValue: Visibility);
     /**
      * What this element accepts and what it sends: `'editable'` and `'readonly'` send its value, `'disabled'` sends
      * nothing and `'disabled-null'` sends `null`, and only `'editable'` accepts input. The validators run over what
-     * the element sends and only where it is sent at all, as `effectiveAccess` states, so a switch of access runs
-     * them again here and below.
+     * the element sends, and only where it is sent at all (see `effectiveAccess`), so a change of access that changes
+     * what an element sends runs them again on that element, this one and the ones below it. A change between
+     * `'editable'` and `'readonly'` changes what the element accepts, not what it sends, and runs nothing.
      */
     get access(): Access;
     set access(newValue: Access);
     /**
-     * The access this element has once the containers above it are taken into account. A container that sends nothing
-     * or `null` in place of what it holds sends none of its members, so below a `'disabled'` or `'disabled-null'`
-     * container every element is `'disabled'`; below a `'readonly'` one an `'editable'` element is `'readonly'`.
-     * Anywhere else it is the element's own access.
+     * The access of this element after the containers above it are applied. A container that sends nothing or `null`
+     * sends none of its members, so below a `'disabled'` or `'disabled-null'` container every element is
+     * `'disabled'`; below a `'readonly'` one an `'editable'` element is `'readonly'`. Otherwise it is the element's
+     * own access.
      *
-     * It is what decides whether the element's validators run: an element that is `'disabled'` here is sent nowhere,
-     * so its validators reach no verdict and it carries none of their errors. Anywhere else they run over what the
-     * element sends - its value, or `null`.
+     * It determines whether the element's validators run: an element whose effective access is `'disabled'` is not
+     * sent, so its validators produce no result and it has none of their errors. Otherwise they run over what the
+     * element sends: its value, or `null`.
      */
     get effectiveAccess(): Access;
     /**
-     * Whether `effectiveAccess` is `'disabled'`, read off the untracked state. A validator asks it on every run, where
-     * nothing renders off the answer and a tracked walk up the containers would cost every write a read per level.
+     * Whether `effectiveAccess` is `'disabled'`, read from the untracked state. A validator reads it on every run,
+     * where nothing renders from the result and a tracked walk up the containers would add a tracked read per level
+     * to every write.
      */
     [SentNowhere](): boolean;
     /**
-     * True where `access` is `'editable'`: the element accepts input. It reads `access` and nothing else, and it is a
-     * statement about input rather than about data - `'readonly'` is not enabled and still sends its value. What an
-     * element sends is read from `access`.
+     * True if `access` is `'editable'`: the element accepts input. It reads only `access` and concerns input, not
+     * data: a `'readonly'` element is not enabled and still sends its value. What an element sends is read from
+     * `access`.
      */
     get enabled(): boolean;
     /**
-     * True where `effectiveAccess` is `'editable'`: this element and every container above it accept input. A
-     * rendering layer binds one read instead of walking the parent chain: a container that is not editable states
-     * that its section cannot be edited, and the inputs rendered from the members inside it read that here.
+     * True if `effectiveAccess` is `'editable'`: this element and every container above it accept input. A rendering
+     * layer reads this instead of walking the parent chain; the inputs of members inside a container that is not
+     * editable read false here.
      */
     get effectiveEnabled(): boolean;
     /** The effective access of this element and of every element below it, read before a change that may move it. */
@@ -993,131 +1304,136 @@ export declare abstract class FieldBase<T = any, X extends object = Extras> {
     /** The effective access of every element below this one, read before a change that may move it. */
     private effectiveAccessBelow;
     /**
-     * Runs the validators again on every element whose effective access moved since `before` was read: one that stops
-     * being sent drops their errors, and one that starts being sent is checked over what it now sends.
+     * Runs the validators again on every element whose effective access changed what it sends since `before` was
+     * read: an element that is no longer sent loses their errors, and one that is now sent is validated over what it
+     * sends.
      */
     private revalidateWhereChanged;
     /**
-     * What this element contributes to its container's `value` or `fullValue`: its own value, `null` in its place, or
-     * nothing. It is the one place the rule is stated - every container composes its values by asking it.
+     * What this element sends to its container's `value` or `fullValue`: its own value, `null`, or nothing. Every
+     * container composes its values through this method.
      *
-     * `fullValue` states everything the form holds, so every element contributes its value there. `value` states
-     * what the form sends, and `access` decides it: `'disabled'` leaves the element out and `'disabled-null'` sends
-     * `null`, whatever a container holds below it.
+     * `fullValue` contains everything the form holds, so every element sends its value there. `value` contains what
+     * the form sends, determined by `access`: `'disabled'` omits the element and `'disabled-null'` sends `null`,
+     * whatever a container holds below it.
      */
     protected serializesAs(purpose: 'value' | 'fullValue'): 'value' | 'null' | 'omit';
-    /** What `child` contributes to this container, asked the way `childComposesValue` asks what it is. */
+    /** What `child` sends to this container; a protected-access bridge like `childComposesValue`. */
     protected childSerializesAs(child: FieldBase, purpose: 'value' | 'fullValue'): 'value' | 'null' | 'omit';
     /**
      * What this element sends to its container's `value`: its value where its access sends it, `null` for
-     * `'disabled-null'`, and `undefined` for `'disabled'`, whose key or row is left out. It is what the element's
-     * validators run over and what `ContributionChangedAction` reports.
+     * `'disabled-null'`, and `undefined` for `'disabled'`, whose key or row is omitted. The element's validators run
+     * over it, and `ContributionChangedAction` reports it.
      */
     get contribution(): unknown;
     /**
-     * What `ValueChangedAction` reports this element as holding: its value. A container holds every member's value
-     * whatever the member sends, so it answers with its `fullValue`.
+     * The value `ValueChangedAction` reports for this element: its value. A container holds every member's value
+     * whatever the member sends, so on a container it is its `fullValue`.
      */
     protected get holding(): any;
     /**
-     * Whether the container holding this element counts its verdict: every element that sends something, `null`
-     * included. A `'disabled'` element sends nothing, so it is not counted - an error written into it by hand no more
-     * than one from a validator, which does not run there.
+     * Whether the container holding this element counts its validity: true for every element that sends something,
+     * `null` included. A `'disabled'` element sends nothing, so it is not counted, neither for an error written by
+     * hand nor for one from a validator (validators do not run on it).
      */
     private get countsInContainer();
     /**
-     * Carries a change of what this element sends: the element is enrolled so the commit measures its contribution
-     * and re-forms its verdict, the container's value is built again, and an element that is invalid enters or leaves
-     * the container's tally as it starts or stops being counted.
+     * Processes a change of what this element sends: the element is enrolled so the commit compares its contribution
+     * and recomputes its validity, the container's value is rebuilt, and an invalid element is added to or removed
+     * from the container's invalid count as it starts or stops being counted.
      */
     private contributionChanged;
     /**
-     * True for an element whose value is composed of its members'. The commit builds such a value only where
-     * something receives it, compares it by content rather than by identity, and runs the element's own validators
-     * with the announcement: a container's validators read the composed value, which exists only once the members
-     * have been written. A leaf's validators have run at the write instead, so its announcement carries no eager
-     * pass of its own.
+     * True for an element whose value is composed of its members' values. The commit builds such a value only if
+     * something receives it, compares it by content (not identity), and runs the element's own validators with the
+     * announcement: a container's validators read the composed value, which exists only after the members have been
+     * written. A leaf's validators run at the write, so its announcement runs no eager pass.
      */
     protected get composesValue(): boolean;
     /**
-     * Whether `child` composes its value from members of its own. It is what lets a container tell a nested
-     * container from a leaf without knowing the classes below it, the way `resetChild` reaches a reset it does not
-     * know the shape of.
+     * Whether `child` composes its value from its own members. A container uses it to distinguish a nested container
+     * from a leaf without knowing the child's class, as with `resetChild`.
      */
     protected childComposesValue(child: FieldBase): boolean;
     /**
-     * Announces what this element holds and what it sends, as they became over the transaction. Each pair carried is
-     * (now, at the last announcement), so a value that went A -> B -> A within the transaction says nothing, and the
-     * events an operation states rather than an element's state - an item added, an item removed - are emitted first,
-     * in the order the operations happened.
+     * Announces what this element holds and what it sends at the end of the transaction. Each pair is (now, at the
+     * last announcement), so a value that went A -> B -> A within the transaction is not announced. Events that
+     * describe an operation (an item added, an item removed) are emitted first, in the order the operations happened.
      *
-     * A container's validators read what it sends, which is composed here and nowhere else, so they run first, where
-     * that moved; a leaf's have run at the write. `ValueChangedAction` reports what the element holds, and
-     * `ContributionChangedAction` what it sends to its container.
+     * A container's validators read what it sends, which is composed here, so they run first, if it changed; a
+     * leaf's ran at the write. `ValueChangedAction` reports what the element holds, and `ContributionChangedAction`
+     * what it sends to its container.
      */
     protected [TxAnnounceValue](tx: Transaction, dirty: boolean, force: boolean, structural?: TxStructuralEvent[]): void;
     /**
-     * Records what this element holds and sends as what was last announced, so the commit that follows reports no
-     * change of either. A construction calls it over the state it ends on, and so does an element brought to the
-     * state a fresh binding would be in.
+     * Records what this element holds and sends as last announced, so the following commit announces no change of
+     * either. A construction calls it over its final state, as does `rebind()`.
      */
     protected recordAnnounced(): void;
     /**
-     * Forms the verdict this element ends the transaction with and announces a transition of it. The container is
-     * told first, so a handler reads a tally that already includes this verdict, and it is enrolled in the same
-     * transaction: its own verdict is composed of its members', so a member that moves without a value change - an
-     * asynchronous validator, an error pushed in by hand - is what makes the container re-form its own. The
-     * transaction settles the deepest element first, so a container is reached only once its members have decided.
+     * Computes the validity this element ends the transaction with and announces a change of it. The container is
+     * updated first, so a handler reads an invalid count that already includes this element, and the container is
+     * enrolled in the same transaction: its validity depends on its members', so a member whose validity changes
+     * without a value change (an asynchronous validator, an error written by hand) makes the container recompute its
+     * own. The transaction settles the deepest element first, so a container is settled after its members.
      */
+    /**
+     * Announces the net change of access, enabled and visibility over the transaction: `AccessChangedAction` and
+     * `EnabledChangedAction` where the access differs from the one before the transaction's first write of it, and
+     * `VisibilityChangedAction` likewise. A value that went back to where it started announces nothing.
+     */
+    protected [TxAnnounceFlags](): void;
     protected [TxSettleValidity](tx: Transaction): void;
     validate(revalidate?: boolean): void;
+    /**
+     * True while no error of the element counts toward validity: every error of origin `'validator'` counts, and an
+     * error of another origin counts where its rule's `validEffect` is true (see `ErrorPolicy`).
+     */
     get valid(): boolean;
     get fullValue(): T;
     get isChanged(): boolean;
     /**
-     * Brings a fresh element into the state a binding of `source` is in: it records what it was declared as, takes
-     * on the extended properties and the actions `source` carries, and runs the eager ones over the value it was
-     * built with. The extended properties `overrides` states are written over the ones `source` carries, and they
-     * are in place before the eager pass, so an action reading one sees what the binding ends up carrying. The
-     * actions are the very instances `source` holds - what a binding takes on is data, not behaviour - and each is
-     * told about this element as it is taken on, so an action serving several bindings knows all of them.
+     * Sets up a new element as a binding of `source`: it records the declaration, copies the extended properties of
+     * `source`, uses the actions `source` has, and runs the eager ones over the value it was built with. Extended
+     * properties in `overrides` are written over the copied ones before the eager pass, so an action that reads one
+     * sees the binding's final value. The actions are the same instances `source` holds, and each is bound to this
+     * element (`boundToBinding`), so an action serving several bindings has a reference to each of them.
      */
     protected boundFrom(source: FieldBase<any, X>, newValue: any, oldValue: any, overrides?: object): void;
     /**
-     * Registers the actions a constructor received in its parameters: registration without the eager trigger,
-     * because a constructor ends with a single this.actions.triggerEager(...) over the finished value, and an
-     * eager action registered here would otherwise also run once per registration, over a half-built field.
+     * Registers the actions a constructor received in its parameters, without the eager trigger: a constructor ends
+     * with a single this.actions.triggerEager(...) over the finished value. With the trigger, an eager action would
+     * also run once per registration, over a partially built field.
      */
     protected registerInitialActions(actions: FieldActionBase[]): void;
     registerAction(action: FieldActionBase): this;
     /**
-     * Registers `action` so that `before` wraps it: `before` reaches it through the `supr` it is handed, instead of
-     * ending the run there. It is how an action is added to a chain someone else built and still sits inside a
-     * handler already registered, which registration order alone cannot arrange. `before` has to be registered on
-     * this element under the same identifier.
+     * Registers `action` so that `before` wraps it: `before` calls it through the `supr` argument. This adds an
+     * action to an existing chain inside a handler that is already registered, which registration order alone cannot
+     * do. `before` must be registered on this element under the same identifier.
      */
     registerActionBefore(action: FieldActionBase, before: FieldActionBase): this;
     /**
-     * Drops `action` from this element and answers whether it held it. The instance goes on serving every other
-     * element it was registered on: what is dropped is this element's registration, not the action. A validator
-     * withdraws the errors it put on this element as it goes, so the verdict the element reports is the one the
-     * validators it still holds reach.
+     * Unregisters `action` from this element and returns whether it was registered. The registration is shared with
+     * the element's declaration and every binding made from it, so the action is removed from all of them; elements
+     * of other declarations that the same instance is registered on keep it. A validator removes the errors it put on
+     * the elements it is removed from, so their validity reflects only the remaining validators.
      */
     unregisterAction(action: FieldActionBase): boolean;
     /**
-     * Records that `action` is now registered on this element, and that a rollback has to take that back. The
-     * registration is not one of the state slots the snapshot covers, so it hands its own undo in.
+     * Registers `action` on the declaration, binds it to the existing bindings and registers an undo for a rollback.
+     * The registration is not in the state slots the snapshot covers, so it registers its own undo, before any call
+     * that can throw: a registration that fails part way is undone with the transaction.
      */
-    private registered;
+    private register;
+    /**
+     * Asks the actions of `actions` to release themselves if abandoned (see `ReleaseIfAbandoned`), if a minute or more
+     * has passed since the last time. A map is checked only when an action is registered on it, with no timer.
+     */
+    private releaseAbandoned;
     triggerAction<T2 extends FieldActionBase>(actionClass: (abstract new (...args: any[]) => T2) & {
         classIdentifier: symbol;
     }, ...params: any[]): any;
-    /**
-     * Generation counter of the validators attached to this field. A Validator reads it when a run starts and drops
-     * a result whose epoch no longer matches, so a validation still in flight when clearValidators() is called
-     * cannot push an error onto a field that no longer has the validator that produced it.
-     */
-    get validationEpoch(): number;
     clearValidators(): void;
 }
 
@@ -1128,23 +1444,23 @@ declare interface FieldSlots<T = any> extends ElementSlots<T> {
 }
 
 /**
- * What Group.fullValue reads back. The indexed access reads each field's fullValue getter, so a nested group
- * contributes its own full structure rather than the partial one its `value` builds. Every member is present
- * whatever its access.
+ * The type of Group.fullValue. The indexed access reads each element's fullValue getter, so a nested group has its
+ * full structure, not the partial one its `value` builds. Every member is present whatever its access, except an
+ * `Action`, which holds no data.
  */
 export declare type FieldsToFullValues<T extends GenericFieldsInterface> = {
-    [K in keyof T]: T[K]['fullValue'];
+    [K in DataKeys<T>]: T[K]['fullValue'];
 };
 
 /**
- * Converts a field structure into the matching value structure. The indexed access reads each field's value
- * getter, so a nested Group contributes its own value structure and a List contributes its row array; inferring
- * from FieldBase<infer U> instead would pick up the value setter, which is deliberately wider than the getter on
- * Group. Every member may be `null`, because a member whose access is `'disabled-null'` contributes `null` in place
- * of its value.
+ * Converts a field structure into the matching value structure. The indexed access reads each element's value
+ * getter, so a nested Group sends its own value structure and a List sends its row array; inferring from
+ * FieldBase<infer U> would use the value setter, which on Group accepts a wider type than the getter returns.
+ * Every member may be `null`, because a member whose access is `'disabled-null'` sends `null` in place of its
+ * value. An `Action` member sends nothing and has no key.
  */
 export declare type FieldsToValues<T extends GenericFieldsInterface> = {
-    [K in keyof T]: T[K]['value'] | null;
+    [K in DataKeys<T>]: T[K]['value'] | null;
 };
 
 declare namespace Form {
@@ -1157,6 +1473,15 @@ declare namespace Form {
         visibilityValues,
         defaultVisibility,
         isVisibility,
+        configureDevtools,
+        describeState,
+        DevtoolsOptions,
+        DevtoolsRegistration,
+        hideState,
+        StateDescription,
+        installPlugin,
+        Plugin_2 as Plugin,
+        PluginContext,
         transaction,
         TransactionControl,
         FieldActionBase,
@@ -1167,6 +1492,16 @@ declare namespace Form {
         EnabledChangedAction,
         EnabledChangingAction,
         ExecuteAction,
+        RejectAction,
+        CommandTarget,
+        SubmitAction,
+        CommandException,
+        SubmitFailedException,
+        SubmitRefusalReason,
+        SubmitRefusedException,
+        SubmitOptions,
+        SubmitResult,
+        TargetedExecuteAction,
         VisibilityChangedAction,
         VisibilityChangingAction,
         ValidChangedAction,
@@ -1183,7 +1518,6 @@ declare namespace Form {
         ActionValue,
         Action,
         NullableAction,
-        MessagesWidget,
         Container,
         Field,
         NullableField,
@@ -1206,54 +1540,27 @@ declare namespace Form {
         ListValue,
         ListValueInput,
         ListFullValue,
+        ListItemInput,
         List,
         NullableList,
+        ErrorPolicies,
+        ErrorPolicy,
+        ErrorPolicyRule,
+        ErrorRemoval,
+        errorRemovals,
+        setDefaultErrorPolicies,
         Validators,
-        buildErrorMessage,
-        translatedMessage,
-        strings,
-        translateStrings,
-        isSimpleComponentDef,
-        isCallableFunction,
-        MdString,
-        SimpleComponentDef,
-        ClassType,
-        ClassTypes,
-        RenderContentNonCallable,
-        RenderContentCallable,
-        RenderContent,
-        RenderContentRef,
         ErrorOrigin,
+        ErrorDescription,
         ValidationError,
-        ValidationErrorText,
-        ValidationErrorRenderContent,
-        RenderableValue,
         view,
         View
     }
 }
 export default Form;
 
-export declare const forms: {
-    install(app: any, options?: Partial<FormsConfig>): void;
-};
-
-/**
- * Global configuration for @dynamicforms/vue-forms.
- *
- * The configuration is module-global: `setConfig` and the plugin's `install` write the single record this module
- * holds, so in a process running several Vue apps the configuration applied last is the one all of them read.
- */
-export declare interface FormsConfig {
-    /** Whether the built-in validators phrase their error messages as `MdString` markdown instead of plain text. */
-    useMarkdownInValidators: boolean;
-}
-
 export declare type GenericFieldsInterface = Record<string, FieldBase>;
 
-/** The current configuration. The object is the module's own record, and reading it again reports later writes. */
-export declare function getConfig(): FormsConfig;
-
 export declare class Group<T extends GenericFieldsInterface = GenericFieldsInterface, X extends object = Extras> extends Container<GroupValue<T>, X> {
     get [Symbol.toStringTag](): string;
     protected get state(): GroupSlots<GroupValue<T>>;
@@ -1261,90 +1568,108 @@ export declare class Group<T extends GenericFieldsInterface = GenericFieldsInter
     private readonly _fields;
     constructor(fields: T, params?: IFieldParams<GroupValueInput<T>, X>);
     /**
-     * The name array is copied as well: a rollback puts back the set of members the group held, not the array it
-     * went on to hold.
+     * Gives every member `data` contains its part of `data` as its baseline, and so on through the groups below it;
+     * null gives each member null.
+     */
+    private baselineMembersFrom;
+    /**
+     * The name array is copied as well, so a rollback restores the set of members the group held before the
+     * transaction.
      */
     protected [TxCapture](): TxSnapshot;
     /**
-     * The copy of a built value that serves as a baseline. The value getter hands out one object per version, and
-     * a baseline holding that same object would report every value as its own original.
+     * A copy of a built value, used as a baseline. The value getter returns one object per version, and a baseline
+     * holding that same object would make every value equal to its original.
      */
     private static baseline;
     /**
-     * Takes `field` into this group under `fieldName`. The group ends up holding it exactly as it holds a field the
-     * constructor was given: the field carries the back-reference and the name, its verdict counts towards the
-     * group's, and a rule of the field's that names another member of the form reaches it here.
+     * Adds `field` to this group under `fieldName`, in the same state as an element passed to the constructor: the
+     * element has the back-reference and the name, its validity counts towards the group's, and a rule of the element
+     * that refers to another element of the form is resolved here.
      *
-     * The change is announced through the ordinary path, so a group whose value the new field adds to says so once
-     * the transaction closes, and its verdict is re-formed over the members it now holds. The baseline behind
-     * `isChanged` is not rewritten: a group that gains a field holds something its original value does not carry,
-     * and reports itself changed until `originalValue` is written.
+     * The change is announced through the regular path: the group announces its new value when the transaction
+     * closes, and its validity is recomputed over its current members. The baseline behind `isChanged` is not
+     * rewritten: a group that gains an element holds a value its original value does not contain, and reports itself
+     * changed until `originalValue` is written.
      *
-     * @throws Error where this group already holds a field under `fieldName`.
-     * @throws TypeError where `field` already belongs to a container - pass a `bind()` of it instead.
+     * @throws Error if this group already holds an element under `fieldName`.
+     * @throws TypeError if `field` already belongs to a container; pass a `bind()` of it instead.
      */
     addField(fieldName: string, field: FieldBase): this;
     /**
-     * Takes the field held under `fieldName` out of this group and hands it back, answering undefined where the
-     * group holds no field of that name. The field is released whole: the back-reference and the name are gone, its
-     * verdict and its runs in flight no longer count towards the group's, and it is free to be taken by another
-     * container. What it holds - its value, its errors, the change history behind `isChanged` - is its own to report.
+     * Removes the element held under `fieldName` from this group and returns it, or returns undefined if the group
+     * holds no element of that name. The back-reference and the name are cleared, its validity and its runs in
+     * flight no longer count towards the group's, and another container can take it. It keeps its value, its errors
+     * and the change history behind `isChanged`.
      *
-     * The change is announced through the ordinary path, so the group's value and verdict settle over the members it
-     * has left. The baseline behind `isChanged` is not rewritten, the same way it is not on `addField`.
+     * The change is announced through the regular path, so the group's value and validity are recomputed over the
+     * remaining members. The baseline behind `isChanged` is not rewritten, as with `addField`.
      */
     removeField(fieldName: string): FieldBase | undefined;
     /**
-     * Writes one entry of the member map. The map is typed by the fields interface, which names the members a group
-     * of that type holds and no others, so both here and in dropEntry it is reached as the plain record it is.
+     * Writes one entry of the member map. The map is typed by the fields interface, which lists only the members of
+     * that group type, so here and in dropEntry it is cast to a plain record.
      */
     private static setEntry;
-    /** Drops one entry out of the member map. */
+    /** Removes one entry from the member map. */
     private static dropEntry;
+    /** Replaces the entries of the member map with `entries`, in their order. */
+    private static restoreEntries;
     private static isValidFields;
+    /**
+     * Builds a group from plain data, so that its `fullValue` is `data`: a plain object becomes a `Group`, an array a
+     * `List` without an item template (whose rows are built by the same rule), and any other value a `Field`, at every
+     * level.
+     */
     static createFromFormData(data: Record<string, any> | null): Group;
     field<K extends keyof T>(fieldName: K): T[K] | null;
     /**
-     * The typed map of this group's members. What it hands out is a view over the map the group holds: reading it
-     * reaches the members themselves, and every write to it is refused - addField() and removeField() are what
-     * change the set. The view is built the first time something asks for it.
+     * The typed map of this group's members. It is a view over the map the group holds: a read returns the members
+     * themselves, and every write throws a TypeError (use addField() and removeField()). The view is created on the
+     * first read.
      *
-     * Reading through it is a tracked read of the set of members, so a template rendering off `group.fields`
-     * re-renders when a field is added or removed; what a member itself holds is tracked by that member.
+     * A read through it is a tracked read of the set of members, so a template that reads `group.fields` re-renders
+     * when an element is added or removed; each member tracks its own state.
      */
     get fields(): T;
     protected get members(): FieldBase[];
     protected get children(): readonly FieldBase[];
     get value(): GroupValue<T>;
     /**
-     * Writes the members that the given value carries. The members are written one by one and the group says
-     * nothing in between: the transaction the assignment runs in measures the group's own value and its own verdict
-     * once, over the finished set, and announces each at most once.
+     * Writes the members whose keys the given value contains. The members are written one by one and the group
+     * announces nothing in between: the transaction compares the group's value and validity once, after all members
+     * are written, and announces each at most once.
      */
     private assignMembers;
     set value(newValue: GroupValueInput<T>);
     /**
-     * Members are reset one by one rather than assigned as a whole value: the value setter writes only the keys the
-     * value carries, while a member the value leaves out has to end up holding what the template gives it. `source`
-     * supplies that per member, so a group reset from the template it was bound from matches a fresh binding of it.
+     * Members are reset one by one, not assigned as a whole value: the value setter writes only the keys the value
+     * contains, while a member missing from the value must take its value from `source`. `source` supplies it per
+     * member, so a group reset from the declaration it was bound from matches a new binding of it.
      */
     protected resetTo(source: FieldBase, value: any): void;
+    protected recordBaseline(): void;
     /**
-     * Everything the group holds: every member's `fullValue`, whatever the member's access. Where `value` states what
-     * the group sends, this states what it holds, and it is what a binding of the group carries.
+     * Everything the group holds: every member's `fullValue`, whatever the member's access. `value` is what the group
+     * sends; `fullValue` is what it holds, and a binding of the group copies it.
      */
     get fullValue(): FieldsToFullValues<T>;
     /**
-     * States that `res` was built from the members handed to it. A subclass whose constructor takes something other
-     * than `(fields, params)` - one that composes its own members and passes them to super - never sees them, and
-     * would answer with a binding carrying the declaration's data instead of the record's. That is a difference no
-     * reader would find, so it is refused here rather than returned.
+     * Throws a TypeError if `res` was not built from the members passed to it. A subclass whose constructor does not
+     * take `(fields, params)` (one that composes its own members and passes them to super) ignores them and would
+     * return a binding with the declaration's data instead of the record's. The difference would not be visible, so
+     * it throws here.
      */
     private static assertTookFields;
     bind(data?: GroupValueInput<T>, overrides?: IBindParams<GroupValueInput<T>, X>): Group<T, X>;
     /**
-     * A record need not name every member: a key it leaves out is taken from the declaration, the same way a member
-     * the constructor is given no value for takes the one it was declared with.
+     * `data` with every key it leaves out filled in with the baseline of the corresponding member, as `rebind` fills
+     * it; null and an action, which holds no data, stay as they are.
+     */
+    private withBaselines;
+    /**
+     * A record need not contain every member: a member whose key is missing takes the `originalValue` of the
+     * corresponding member of the group's declaration, and for a group that is its own declaration, its own baseline.
      */
     rebind(data: GroupValueInput<T>): this;
 }
@@ -1356,30 +1681,32 @@ declare type GroupData<F extends GenericFieldsInterface> = {
     -readonly [K in keyof F as F[K] extends Container ? never : K]: Slot<F[K]>;
 };
 
-/** what a Group holds beyond the container slots: the names of its members, in the order it took them */
+/** what a Group holds beyond the container slots: the names of its members, in the order they were added */
 declare interface GroupSlots<T = any> extends ContainerSlots<T> {
     /**
-     * The names the group holds its members under. The member map itself is a plain object beside the state, so
-     * this array is what a reader inside an effect depends on: a member added or removed re-runs the effect, and a
-     * rolled-back transaction puts the set back with the rest of the slots.
+     * The names the group holds its members under. The member map is a plain object outside the reactive state, so
+     * a reader inside an effect depends on this array: adding or removing a member re-runs the effect, and a rollback
+     * restores the names with the other slots.
      */
     fieldNames: string[];
 }
 
 /**
- * What Group.value reads back: the values of the members that serialize, and `{}` where none does. Every key is
- * optional, because a member whose access is `'disabled'` is left out of the object the group builds.
+ * The type of Group.value: the values of the members that send something, and `{}` if none does. Every key is
+ * optional, because a member whose access is `'disabled'` is omitted from the object the group builds.
  */
 export declare type GroupValue<T extends GenericFieldsInterface> = Partial<FieldsToValues<T>>;
 
-/** what Group.value and the Group constructor accept: keys left out are simply not assigned, and null clears */
+/** what Group.value and the Group constructor accept: missing keys are not assigned, and null clears */
 export declare type GroupValueInput<T extends GenericFieldsInterface> = Partial<FieldsToValues<T>> | null;
 
+/** Leaves `element` out of the devtools, or lists it again with `hidden` false. Does nothing in production. */
+export declare function hideState(element: FieldBase, hidden?: boolean): void;
+
 /**
- * What bind() accepts beside the data it binds: the three members a binding takes over from the element it was
- * bound from, and the extended properties. What is left out is left out because a binding cannot honour it -
- * `validators` and `actions` are carried from the declaration rather than supplied, and `touched` and `errors`
- * are what the binding establishes for itself as it validates.
+ * What bind() accepts in addition to the data: the three members a binding otherwise copies from the element it
+ * is bound from, and the extended properties. `validators` and `actions` are omitted because a binding uses the
+ * declaration's, and `touched` and `errors` because the binding sets them itself as it validates.
  */
 export declare type IBindParams<T = any, X extends object = Extras> = Partial<Pick<IFieldConstructorParams<T>, 'originalValue' | 'access' | 'visibility'>> & Partial<NoInfer<X>>;
 
@@ -1391,9 +1718,9 @@ export declare interface IFieldConstructorActionsList {
 /**
  * Parameters accepted by field constructors and by bind overrides.
  *
- * Only writable members are listed. valid, validating, busy, fullValue, isChanged, enabled and effectiveEnabled are
- * getter-only, so assigning them throws a TypeError. So are parent and fieldName: a container writes the slots
- * behind them when it takes an element, and nobody else can, which is why the type rejects them.
+ * Only writable members are listed. valid, validating, busy, pending, fullValue, isChanged, enabled and
+ * effectiveEnabled are getter-only, so assigning them throws a TypeError. So are parent and fieldName: only a
+ * container writes the slots behind them, when it takes an element, so the type rejects them.
  */
 export declare type IFieldConstructorParams<T = any> = {
     value: T;
@@ -1405,49 +1732,54 @@ export declare type IFieldConstructorParams<T = any> = {
 } & IFieldConstructorActionsList;
 
 /**
- * What an element's constructor accepts: the parameters the element answers for itself, together with the
- * extended properties its X parameter declares.
+ * What an element's constructor accepts: the element's own parameters and the extended properties its X parameter
+ * declares.
  *
- * X is left out of inference, so an element carries what its X states - `Extras` where no type argument replaces
- * it - and a parameter object naming anything else is rejected as an excess property.
+ * X is excluded from inference, so an element has the properties X declares (`Extras` if no type argument is
+ * given), and a parameter object with any other key is rejected as an excess property.
  *
- * The two halves are made partial separately. `Partial<A & X>` is a mapped type over an intersection, which is
- * what T is inferred through, and inference through it answers with one constituent of a union rather than the
- * union: `new Field({ value: someStringOrNumber })` would be a Field<string>.
+ * The two parts are made partial separately. With `Partial<A & X>`, T would be inferred through a mapped type over
+ * an intersection, which infers one member of a union instead of the union: `new Field({ value:
+ * someStringOrNumber })` would be a Field<string>.
  */
 export declare type IFieldParams<T = any, X extends object = Extras> = Partial<IFieldConstructorParams<T>> & Partial<NoInfer<X>>;
 
 declare class InAllowedValues<T = any> extends Validator {
-    constructor(allowedValues: AllowedValues<T>, message?: RenderContentRef);
+    constructor(allowedValues: AllowedValues<T>, options?: ValidationErrorOptions);
 }
 
-/** Answers whether `value` is one of the four accesses. */
-export declare function isAccess(value: unknown): value is Access;
+/**
+ * Installs `plugin` for every element, including the ones already built: a hook runs on the next write. A plugin
+ * installed twice runs twice. Returns a function that uninstalls it; values stored while it was installed are kept
+ * as they are. Where `setup` throws, the plugin is not installed and the exception is rethrown.
+ */
+export declare function installPlugin(plugin: Plugin_2): () => void;
 
-export declare function isCallableFunction(msg?: RenderContentRef): msg is RenderContentCallable;
+/** Returns whether `value` is one of the four accesses. */
+export declare function isAccess(value: unknown): value is Access;
 
 /**
- * Structural equality that treats a `FieldBase` as what it holds. `isEqual(fieldA, fieldB)` and
- * `isEqual(list.items, other.items)` compare values the way `isEqual(fieldA.value, fieldB.value)` already does,
- * without a call site having to unwrap every element by hand.
- *
- * Two `FieldBase` operands skip `isEqualWith`'s dispatch and compare `.value` directly — about 40% faster than
- * routing the same comparison through the customizer, measured comparing two single-field elements.
+ * Whether `value` is empty: `null`, `undefined`, an empty string, an empty array, an empty `Map` or `Set`, or a
+ * plain object (one without a prototype included) with no own keys. Every built-in validator except `Required` and
+ * `CompareTo` passes an empty value, so a field that may stay empty carries only the other validators, and a field
+ * that may not adds `Required`.
  */
-export declare function isEqual(a: unknown, b: unknown): boolean;
+declare function isEmptyValue(value: unknown): boolean;
 
 /**
- * Type guard to check if content is a custom component definition
- * @param msg - Content to check
- * @returns True if content is a custom component definition
+ * Structural equality that compares a `FieldBase` by the value it holds. `isEqual(fieldA, fieldB)` and
+ * `isEqual(list.items, other.items)` compare values as `isEqual(fieldA.value, fieldB.value)` does, without
+ * unwrapping each element at the call site.
+ *
+ * Two `FieldBase` operands are compared by `.value` directly, without the `isEqualWith` customizer dispatch.
  */
-export declare function isSimpleComponentDef(msg?: RenderContentRef): msg is SimpleComponentDef;
+export declare function isEqual(a: unknown, b: unknown): boolean;
 
-/** Answers whether `value` is one of the four visibilities. */
+/** Returns whether `value` is one of the four visibilities. */
 export declare function isVisibility(value: unknown): value is Visibility;
 
 declare class LengthInRange extends Validator {
-    constructor(minLength: number, maxLength: number, message?: RenderContentRef);
+    constructor(minLength: number, maxLength: number, options?: ValidationErrorOptions);
 }
 
 export declare class List<R extends FieldBase = Group, X extends object = Extras> extends Container<ListValue<R>, X> {
@@ -1457,11 +1789,11 @@ export declare class List<R extends FieldBase = Group, X extends object = Extras
     private _itemTemplate?;
     constructor(itemTemplate?: undefined, params?: IFieldParams<ListValueInput<R>, X>);
     constructor(itemTemplate: R, params?: IFieldParams<ListValueInput<R>, X>);
-    /** The row array is copied as well: a rollback puts back the set the list held, not the array it went on to hold. */
+    /** The row array is copied as well, so a rollback restores the rows the list held before the transaction. */
     protected [TxCapture](): TxSnapshot;
     /**
-     * The copy of a built value that serves as a baseline. The value getter hands out one array per version, and a
-     * baseline holding that same array would report every value as its own original.
+     * A copy of a built value, used as a baseline. The value getter returns one array per version, and a baseline
+     * holding that same array would make every value equal to its original.
      */
     private static baseline;
     private processSetValueItem;
@@ -1471,64 +1803,84 @@ export declare class List<R extends FieldBase = Group, X extends object = Extras
      */
     private static elementFor;
     /**
-     * Builds the item that fills a gap left by an insert beyond the end of the list: the item template bound to its
-     * own values, or, where the list has no template, an empty element of the kind `item` is built into.
+     * Builds an item that fills a gap left by an insert beyond the end of the list: the item template bound to its
+     * own values, or, if the list has no item template, an empty element of the kind `item` is built into.
      */
     private createPaddingItem;
-    /** Records that the set of rows changed, so `items` rebuilds the frozen array it hands out at the next read. */
+    /** Records that the set of rows changed, so `items` rebuilds its frozen array at the next read. */
     private rowsChanged;
-    /** True where `next` is a different set of rows than `previous`: another count, or another row at a position. */
+    /** True if `next` is a different set of rows than `previous`: a different count, or a different row at a position. */
     private static rowsDiffer;
+    /**
+     * Installs the rows `newValue` describes. With `announce`, a row that leaves the list is announced with a
+     * `ListItemRemovedAction` and a row that enters it with a `ListItemAddedAction`; a row reused at its position is
+     * neither. The construction installs its rows without announcing them.
+     */
     private setValueInternal;
     get value(): ListValue<R>;
     set value(newValue: ListValueInput<R>);
     /**
-     * The rows are taken from `source` where the caller supplied no value of its own, so a list nested in a row that
-     * a whole-list assignment reuses ends up holding what the template gives it rather than what it held before.
+     * If no value is supplied, the rows are taken from `source`, so a list nested in a row reused by a whole-list
+     * assignment ends up with the item template's rows, not its previous ones.
      */
     protected resetTo(source: FieldBase, value: any): void;
+    protected recordBaseline(): void;
     bind(data?: ListValueInput<R>, overrides?: IBindParams<ListValueInput<R>, X>): List<R, X>;
+    /**
+     * The rows, read so that the caller depends on the set of rows: the read of `rowsVersion` is tracked, and the
+     * array itself is held outside Vue's reactivity. A reactive array would route every element a `splice()` shifts
+     * through the proxy, so inserting or removing a row would cost a proxied write per row after it. Every change
+     * of the set of rows increments `rowsVersion`.
+     */
+    private get rows();
     protected get members(): FieldBase[];
     protected get children(): readonly FieldBase[];
     /**
-     * The full value of every row. Where `value` states what the list sends, this states what the list holds: every
-     * row whatever its access, and a group row carrying every field of its own. It is what a binding or a reset
-     * carries.
+     * The full value of every row. `value` is what the list sends; `fullValue` is what the list holds: every row
+     * whatever its access, and every field of a group row. A binding or a reset copies it.
      */
     get fullValue(): ListFullValue<R>;
     /**
-     * How many rows this list holds. The read is tracked, so a template rendering off it re-renders as rows come and
-     * go.
+     * The number of rows this list holds. The read is tracked, so a template that reads it re-renders when rows are
+     * added or removed.
      */
     get length(): number;
     /**
-     * The rows this list holds, oldest position first. The array is a frozen copy: it states what the list held at
-     * the read and nothing writes back through it - `push`, `insert`, `remove` and `clear` are what change the set -
-     * so a caller may hold on to it. The rows in it are the live elements, so reading one reports what it holds now.
+     * The rows this list holds, in position order. The array is a frozen copy of the rows at the time of the read and
+     * cannot be written through (`push`, `insert`, `remove` and `clear` change the rows), so a caller may keep it. The
+     * rows in it are the live elements, so a row read from it returns its current state.
      *
-     * The copy is built once per change of the set and handed to every reader until the next one: a write inside a
-     * row changes what the list serializes without changing which rows it holds, and the array a reader took stays
-     * the same one across such a write.
+     * The copy is built once per change of the set of rows and returned to every reader until the next change: a
+     * write inside a row changes what the list sends without changing which rows it holds, and the array stays the
+     * same across such a write.
      */
     get items(): readonly R[];
     get(index: number): R | undefined;
-    push(item: any): number;
+    push(item: ListItemInput<R>): number;
     pop(): R | undefined;
     remove(index: number): R | undefined;
-    insert(item: any, index: number): number;
-    /** Drops every row this list holds out of its tally, so a row that changes its verdict later is not counted. */
+    insert(item: ListItemInput<R>, index: number): number;
+    /** Releases every row from this list, so a later validity change of a row does not affect its invalid count. */
     private releaseRows;
+    /**
+     * Puts the rows in the order `rows` gives, in place: `rows` holds the same rows as the list, in a new order. The
+     * set of rows does not change, so no `ListItemAddedAction` or `ListItemRemovedAction` fires; the value changes and
+     * is announced. The view of a list calls it for `sort()` and `reverse()`; the package does not export the key.
+     */
+    [ReorderRows](rows: readonly R[]): void;
     clear(): void;
+    /** Takes `null` as well as an array of rows: `rebind(null)` empties the list. */
+    rebind(data: ListValueInput<R>): this;
 }
 
-/** the array a list's view is: every read an array has, and the mutations taken as the list's own operations */
+/** the type of a list's view: every array read, and the mutations performed as the list's own operations */
 declare type ListData<R extends FieldBase> = Omit<Slot<R>[], 'push' | 'unshift' | 'splice' | 'fill' | 'copyWithin'> & {
     push(...items: RowInput<R>[]): number;
     unshift(...items: RowInput<R>[]): number;
     splice(start: number, deleteCount?: number, ...items: RowInput<R>[]): Slot<R>[];
 };
 
-/** what List.fullValue reads back: the full value of every row, whatever its access */
+/** the value of List.fullValue: the full value of every row, whatever its access */
 export declare type ListFullValue<R extends FieldBase = Group> = R['fullValue'][];
 
 export declare class ListItemAddedAction extends FieldActionBase {
@@ -1537,6 +1889,9 @@ export declare class ListItemAddedAction extends FieldActionBase {
     execute(field: FieldBase, supr: FieldActionExecute, item: any, index: number): void;
 }
 
+/** What `push()` and `insert()` take: the data a row is built from, or an element. */
+export declare type ListItemInput<R extends FieldBase> = R['value'] | R;
+
 export declare class ListItemRemovedAction extends FieldActionBase {
     constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, item: any, index: number) => void);
     static get classIdentifier(): symbol;
@@ -1547,18 +1902,18 @@ export declare class ListItemRemovedAction extends FieldActionBase {
 declare interface ListSlots<R extends FieldBase = Group> extends ContainerSlots<ListValue<R>> {
     rows: R[] | null;
     /**
-     * Counts the changes to the set of rows. `items` rebuilds the frozen array it hands out when it moves, and
-     * only then: a write inside a row changes what the list serializes without changing which rows it holds.
+     * Counts the changes to the set of rows. `items` rebuilds its frozen array only when this changes: a write
+     * inside a row changes what the list sends without changing which rows it holds.
      */
     rowsVersion: number;
-    /** the frozen array `items` last handed out, together with the rows version it was built from */
+    /** the frozen array `items` last returned, and the rows version it was built from */
     cachedItems: readonly R[] | null;
     cachedItemsVersion: number;
 }
 
 /**
- * What a List of R reads back: the value of each row it sends, `null` for a row whose access is `'disabled-null'`,
- * and `[]` while it sends none
+ * The value of a List of R: the value of each row it sends, `null` for a row whose access is `'disabled-null'`,
+ * and `[]` if it sends no rows
  */
 export declare type ListValue<R extends FieldBase = Group> = (R['value'] | null)[];
 
@@ -1566,30 +1921,19 @@ export declare type ListValue<R extends FieldBase = Group> = (R['value'] | null)
 export declare type ListValueInput<R extends FieldBase = Group> = ListValue<R> | null;
 
 declare class MaxLength extends Validator {
-    constructor(maxLength: number, message?: RenderContentRef);
+    constructor(maxLength: number, options?: ValidationErrorOptions);
 }
 
 declare class MaxValue<T = any> extends Validator {
-    constructor(maxValue: T, message?: RenderContentRef);
-}
-
-/**
- * Marks content for markdown rendering
- */
-export declare class MdString extends String {
-    plugins?: any[];
-    options?: any;
-    constructor(value: string, options?: any, plugins?: any[]);
+    constructor(maxValue: T, options?: ValidationErrorOptions);
 }
 
-export declare const MessagesWidget: DefineComponent<Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
-
 declare class MinLength extends Validator {
-    constructor(minLength: number, message?: RenderContentRef);
+    constructor(minLength: number, options?: ValidationErrorOptions);
 }
 
 declare class MinValue<T = any> extends Validator {
-    constructor(minValue: T, message?: RenderContentRef);
+    constructor(minValue: T, options?: ValidationErrorOptions);
 }
 
 export declare type NullableAction = Action | null;
@@ -1603,8 +1947,8 @@ export declare type NullableList = List | null;
 export declare type OperandType = any | Statement | FieldBase;
 
 /**
- * Operators provides us a functionality for backend to send us complex condition upon which we send
- * dynamic visibility prop for form input fields
+ * The operators of a `Statement`. A backend can send a condition composed of them, which sets the visibility of
+ * form elements.
  */
 export declare enum Operator {
     NOT = 0,
@@ -1627,107 +1971,165 @@ export declare enum Operator {
 
 export declare namespace Operator {
     export function fromString(operator: string): Operator;
+    /** `mode` as an operator: a number that is an operator value, or a name `fromString()` parses; else throws. */
     export function fromAny(mode: any): Operator;
+    /** Whether `operator` is an operator or the name of one; an unknown name is not, and does not throw. */
     export function isDefined(operator: number | string): boolean;
+    /** Whether `operator` is a logic operator (`NOT` … `NOR`) rather than a comparison. */
     export function isLogicOperator(operator: Operator): boolean;
 }
 
 declare class Pattern extends Validator {
-    constructor(pattern: RegExp, message?: RenderContentRef);
-}
-
-declare interface Props {
-    message: string | ValidationError[];
-    classes?: ClassTypes;
+    constructor(pattern: RegExp, options?: ValidationErrorOptions);
 }
 
 /**
- * A value, renderable three different ways (plain text, markdown, component) - alias for ValidationErrorRenderContent
+ * A plugin. Every hook is optional. The value hooks of the installed plugins run as a pipeline in the order of
+ * installation: the first receives the value being written, each following one receives the previous one's result,
+ * and the last result is stored.
  */
-export declare class RenderableValue extends ValidationErrorRenderContent {
+declare interface Plugin_2 {
+    /** Called once by `installPlugin()`, with the context the plugin's other hooks use. */
+    setup?(context: PluginContext): void;
+    /**
+     * Called on every write of the value a `Field` holds: construction, the `value` setter and `rebind()`. A rollback
+     * restores the stored value without calling it. `ValueChangedAction` and `field.value` receive the stored value.
+     */
+    onSetValue?(value: unknown, element: FieldBase): unknown;
+    /** Called on every write of `originalValue` of any element, a container's included. */
+    onSetOriginalValue?(value: unknown, element: FieldBase): unknown;
+    /**
+     * Called at the start of every element's construction, before its parameters are applied. `binding` is true for
+     * an element `bind()` builds, a row of a `List` included. The hooks run in the order of installation.
+     */
+    onElementCreated?(element: FieldBase, binding: boolean): void;
+    /**
+     * Called when a container takes `element` as its member, once the transaction that took it commits. Not called
+     * where the transaction is rolled back.
+     */
+    onElementAdopted?(element: FieldBase): void;
+    /** Called after every committed transaction, once its changes are announced. Not called after a rollback. */
+    onCommit?(): void;
+}
+export { Plugin_2 as Plugin }
+
+/** What `installPlugin()` passes to a plugin's `setup()`. */
+export declare interface PluginContext {
+    /**
+     * Makes a write into the value a field holds a change of the field. It opens a transaction, or joins the open one,
+     * and in it:
+     *
+     * 1. where this is the first such write since the field's last announcement, records `copy()` as the old value;
+     * 2. calls `write()`;
+     * 3. registers `undo()` for a rollback;
+     * 4. runs the field's validators and enrols the field, so the commit fires `ValueChangedAction` with the value
+     *    the field holds and the recorded old value.
+     *
+     * `element` is a `Field`; any other element throws a `TypeError`.
+     */
+    changeInPlace(element: FieldBase, write: () => void, undo: () => void, copy: () => unknown): void;
+    /**
+     * True for an element that is part of another element's definition: a binding (an element built by `bind()`,
+     * such as a row of a `List`) or a `List`'s item template.
+     */
+    isInternal(element: FieldBase): boolean;
 }
 
 /**
- * Type for different renderable content formats: plain string, markdown, or custom component
+ * Puts `target` back to its baseline: on `execute()` it calls `target.rebind(target.originalValue)`, which sets the
+ * value to `originalValue`, resets `touched` and revalidates, then calls the next handler in the chain and returns
+ * its result.
+ *
+ * `canExecute()` is true while the target exists, whatever its validity.
  */
-export declare type RenderContent = RenderContentNonCallable | RenderContentCallable;
-
-export declare type RenderContentCallable = () => RenderContentNonCallable;
-
-export declare type RenderContentNonCallable = string | MdString | SimpleComponentDef;
+export declare class RejectAction extends TargetedExecuteAction {
+    protected readonly target: CommandTarget;
+    constructor(target: CommandTarget);
+    canExecute(action: FieldBase): boolean;
+}
 
 /**
- * Type for different renderable content formats (supporting references): plain string, markdown, or custom component
+ * Key of the `FieldBase` method that removes, in its subtree, the errors whose rule removes them on `'submit'`.
+ * `SubmitAction` calls it; the package does not export it.
  */
-export declare type RenderContentRef = RenderContent | Ref<RenderContent>;
+declare const RemoveErrorsOnSubmit: unique symbol;
+
+/** Key of the `List` method that reorders the rows in place; `view()` calls it, and the package does not export it. */
+declare const ReorderRows: unique symbol;
 
 declare class Required_2 extends Validator {
     constructor(options?: RequiredOptions);
-    constructor(message?: RenderContentRef, options?: RequiredOptions);
 }
 
-/** How the value is read before its length is taken. */
-declare interface RequiredOptions {
+/** How the value is read before its length is measured, and the error's code and detail. */
+declare type RequiredOptions = ValidationErrorOptions & {
     /**
-     * Whether a string is trimmed before it is measured, so that whitespace alone is no value. Defaults to true.
-     * Set it to false where the spaces are part of what the field holds.
+     * Whether a string is trimmed before it is measured, so that whitespace alone counts as no value. Defaults to
+     * true. Set it to false if spaces are part of the field's value.
      */
     trim?: boolean;
-}
+};
 
-/** what a list's view takes as a row: the data a row is built from, an element, or the view of one */
+/** what a list's view accepts as a row: the data a row is built from, an element, or the view of one */
 declare type RowInput<R extends FieldBase> = R['value'] | R | View<R>;
 
-/** asked by a validator before it runs: whether the element is sent nowhere, read without tracking */
+/** read by a validator before it runs: whether the element is not sent at all, read without tracking */
 declare const SentNowhere: unique symbol;
 
-/** Writes the members `newConfig` names and leaves the rest as they stand. */
-export declare function setConfig(newConfig: Partial<FormsConfig>): void;
-
 /**
- * Interface for custom component content definition
+ * Sets the rules of the origins in `policies` for every element without an `ErrorPolicy` that names them. An origin
+ * not in `policies` keeps its rule. The built-in rules are `{ validEffect: true, removeOn: 'edit' }` for `'server'`
+ * and `{ validEffect: true, removeOn: 'never' }` for every other origin.
+ *
+ * Returns a function that restores the rules in force before the call. `valid` reflects a change at once; the
+ * validity an element announces through `ValidChangedAction` is recomputed at its next validity change, so the
+ * defaults are set before forms are built. Throws a TypeError for a rule `ErrorPolicy` refuses.
  */
-export declare interface SimpleComponentDef {
-    componentName: string;
-    componentProps?: Record<any, any>;
-    componentVHtml?: string;
-}
+export declare function setDefaultErrorPolicies(policies: ErrorPolicies): () => void;
 
-/** a member of the form in the shape a view hands it out: the view of a container, the value of anything else */
+/** the type a view returns for a member: the view of a container, the value of any other element */
 declare type Slot<E> = E extends Container ? View<E> : E extends FieldBase ? E['value'] : never;
 
+/** What an application states about an element for the devtools. */
+export declare interface StateDescription {
+    /** The name the devtools show; defaults to the element's class and a number. */
+    name?: string;
+    /** The file the element is defined in; defaults to the file of the code that constructed it. */
+    file?: string;
+}
+
 export declare class Statement {
     private readonly operand1;
     private readonly operator;
     private readonly operand2;
     /**
      * An operand is a nested `Statement`, a `FieldBase` whose value is compared, or a literal. `undefined` and a
-     * function are neither: they are what a misspelled field name and a field accessor handed over uncalled answer
-     * with, and a statement built from one compares nothing and never fires. The position names which of the two
-     * operands is at fault, so the error points at the place the name was written.
+     * function are not operands: they result from a misspelled field name and from an accessor passed without being
+     * called, and a statement built from one would compare nothing and never fire. The error message includes the
+     * operand's position.
      */
     private static validateOperand;
     /**
-     * `NOT` reads one operand, so it is stated with one. Every other operator compares two and takes both, and so
-     * does an operator held in a variable - `Operator.fromString()` answers with the type rather than with the
-     * constant, and the compiler cannot tell from it which of the two forms is meant.
+     * `NOT` reads one operand, so it takes one. Every other operator compares two and takes both, as does an operator
+     * held in a variable: `Operator.fromString()` returns the type, not the constant, so the compiler cannot
+     * determine which of the two forms applies.
      *
-     * @throws TypeError where an operand the statement reads is undefined or a function.
+     * @throws TypeError if an operand the statement reads is undefined or a function.
      */
     constructor(operand1: OperandType, operator: Operator.NOT);
     constructor(operand1: OperandType, operator: Operator, operand2: OperandType);
     /**
-     * The value an operand contributes. A field operand names a field of the record the statement is evaluated in:
-     * the same statement over a `List` reads row 3's field while row 3 is the record, and a field belonging to no
-     * record of the statement's own - a form field above the list - is read where it stands. A record that does not
-     * hold the field yet contributes undefined, which is what a half-built row answers with.
+     * Returns the value of an operand. A field operand refers to the corresponding element of the record the
+     * statement is evaluated in: the same statement over a `List` reads row 3's element when row 3 is the record, and
+     * an element outside the statement's records (a form field above the list) is read directly. If the record does
+     * not hold the element yet (a partially built row), the value is undefined.
      */
     private static valueOf;
     get operand1Value(): any;
     get operand2Value(): any;
     /**
-     * The result of the statement, over the record `scope` belongs to where one is given and over the fields the
-     * statement was built from where it is not.
+     * The result of the statement, over the record `scope` belongs to if given, and over the elements the statement
+     * was built from otherwise.
      */
     evaluate(scope?: FieldBase): boolean;
     /**
@@ -1737,151 +2139,221 @@ export declare class Statement {
     collectFields(): Set<FieldBase>;
 }
 
-export declare const strings: {
-    Required: string;
-    MinValue: string;
-    MaxValue: string;
-    ValueInRange: string;
-    MinLength: string;
-    MaxLength: string;
-    LengthInRange: string;
-    Pattern: string;
-    InAllowedValues: string;
-    ValidationFailed: string;
-};
+/**
+ * Sends the value of `target` to `handler`. On `execute()` it:
+ *
+ * 1. waits until `target.validating` is false, so a validation started in the same event is finished. It does not
+ *    await `target.settled()`: the action is `busy` while it runs, so the target is `pending` until it returns;
+ * 2. where `target.valid` is false, ends with a `SubmitRefusedException` with `reason` `'invalid'`, which
+ *    `execute()` resolves with;
+ * 3. removes, from the target and every element below it, the errors whose rule removes them on `'submit'` (see
+ *    `ErrorPolicy`);
+ * 4. where the target's `access` is `'editable'` and `lock` is not false, sets it to `'readonly'`;
+ * 5. calls `handler(target.value, target)` and awaits it;
+ * 6. where the result is not `undefined` and `rebind` is not false, calls `target.rebind(result)`;
+ * 7. sets the target's `access` back to `'editable'` where step 4 set it and it is still `'readonly'`, whether the
+ *    handler succeeded or failed;
+ * 8. calls the next handler in the chain and returns a `SubmitResult`: the action, the value sent and the value
+ *    `handler` returned.
+ *
+ * A second `execute()` while a submit of the same action is running is refused with a `SubmitRefusedException`
+ * with `reason` `'running'`.
+ *
+ * A `handler` that throws or rejects ends the submit with a `SubmitFailedException` whose `cause` is the error;
+ * `execute()` resolves with it and the target is not changed. Mapping a server's field errors to the fields is the
+ * handler's: it writes them to `field.errors` before it throws.
+ *
+ * The resolved value is `SubmitResult<R> | CommandException`. `execute()` is typed `Promise<any>`, because the
+ * chain may hold other handlers; the caller states the type where it awaits the result.
+ *
+ * `'readonly'` sends and validates the target as `'editable'` does, so its `value`, `valid` and `isChanged` do not
+ * change and no validator runs because of the lock; the members inherit it through `effectiveAccess`, so every
+ * input below the target is not enabled while the handler runs. The rebind in step 6 replaces the target's value
+ * with the result, so a change written to the target by code while the handler runs is lost and `isChanged` is
+ * false afterwards. `busy` and `pending` report the running submit.
+ *
+ * `canExecute()` is true while the target is valid and not `pending`, so `Action.executable` disables a submit
+ * button while the form is invalid or a validation is running.
+ */
+export declare class SubmitAction<R = any> extends TargetedExecuteAction {
+    protected readonly target: CommandTarget;
+    constructor(target: CommandTarget, handler: (value: any, target: FieldBase) => R | Promise<R>, options?: SubmitOptions);
+    canExecute(action: FieldBase): boolean;
+}
+
+/** The `CommandException` a `SubmitAction` ends with when its handler throws or rejects; `cause` is what it threw. */
+export declare class SubmitFailedException extends CommandException {
+    constructor(cause: unknown);
+}
+
+/** How a `SubmitAction` treats its target. */
+export declare interface SubmitOptions {
+    /**
+     * Whether a result other than `undefined` is written back with `target.rebind(result)`, which makes it the new
+     * baseline: `isChanged` is false, `touched` is false and the errors are revalidated. Defaults to true.
+     */
+    rebind?: boolean;
+    /**
+     * Whether an `'editable'` target is `'readonly'` while the handler runs, so no input reaches it during the
+     * submit. Defaults to true.
+     */
+    lock?: boolean;
+}
+
+/** Why a `SubmitAction` refused to submit: the target is invalid, or a submit of the same action is running. */
+export declare type SubmitRefusalReason = 'invalid' | 'running';
+
+/**
+ * The `CommandException` a `SubmitAction` ends with when it refuses to submit and does not call the handler;
+ * `reason` states why.
+ */
+export declare class SubmitRefusedException extends CommandException {
+    readonly reason: SubmitRefusalReason;
+    constructor(reason: SubmitRefusalReason);
+}
+
+/** What `execute()` of an action with a `SubmitAction` resolves with after a successful submit. */
+export declare interface SubmitResult<R = any> {
+    /** The action that ran the submit. */
+    action: FieldBase;
+    /** The value passed to the handler: the target's `value`. */
+    sent: unknown;
+    /** The value the handler returned. */
+    received: R;
+}
+
+/** An `ExecuteAction` that works on a target element; `Container.confirm()` and `reject()` find it by its target. */
+export declare abstract class TargetedExecuteAction extends ExecuteAction {
+    protected abstract readonly target: CommandTarget;
+    /** The element this handler works on when it runs on `action`, or undefined where the callback returns none. */
+    targetFor(action: FieldBase): FieldBase | undefined;
+}
 
 declare class Transaction {
     private readonly participants;
-    /** what a rollback has to put back beyond the state slots, newest last */
+    /** what a rollback restores beyond the state slots, newest last */
     private readonly undo;
-    /** what the commit has to do once the change stands, in the order it was handed in */
+    /** work the commit runs after the change is complete, in registration order */
     private readonly settled;
-    /** true once the transaction has been unwound, which is what tells a run started inside it to say nothing */
+    /** true once the transaction has been rolled back; a run started inside it then announces nothing */
     private unwound;
-    /** the depth the announcement in progress is working at, -1 while none is */
+    /** the depth the current announcement pass is processing, -1 while no pass runs */
     private passDepth;
-    /** set while a pass is running and an element it has already passed the depth of gets enrolled */
+    /** set when, during a pass, an element is enrolled at or below the depth being processed */
     private restartPass;
-    /** true for a transaction that was rolled back rather than committed */
+    /** true for a transaction that was rolled back */
     get rolledBack(): boolean;
     private participant;
     /**
-     * Records the state of an element the first time the transaction modifies it. The whole of the mutable state
-     * goes into the snapshot rather than the part being written: a rollback that restored some of it would leave
-     * the element in a state the form never held.
+     * Records the state of an element the first time the transaction modifies it. The snapshot contains all of the
+     * mutable state, not only the part being written: a partial restore would leave the element in a state the form
+     * never had.
      */
     touch(element: FieldBase): void;
-    /** Enrols an element as one whose value the commit has to announce. `force` skips the comparison. */
+    /** Enrols an element whose value the commit announces. `force` skips the comparison. */
     markValueChanged(element: FieldBase, force: boolean): void;
-    /** Enrols an element as one whose verdict the commit has to re-form. */
+    /** Enrols an element whose access or visibility changed; the commit announces the net change. */
+    markFlagsDirty(element: FieldBase): void;
+    /** Enrols an element whose validity the commit recomputes. */
     markValidityDirty(element: FieldBase): void;
     /**
-     * Queues an event that states an operation rather than a state. Added and removed items have no net over a
-     * transaction, so they are neither compared nor coalesced: the commit emits them in the order they happened.
+     * Queues an event that describes an operation, not a state. Added and removed items have no net result over a
+     * transaction, so they are neither compared nor merged: the commit emits them in the order they happened.
      */
     recordStructural(element: FieldBase, event: TxStructuralEvent): void;
-    /** True where the commit still owes this element a value announcement. */
+    /** True if the commit has a pending value announcement for this element. */
     willAnnounceValue(element: FieldBase): boolean;
     /**
-     * Registers what a rollback has to put back beyond the element's state slots. The snapshot covers the slots,
-     * which is everything an ordinary write touches; an operation that replaces something else the element carries
-     * hands its own undo in here rather than making every snapshot carry the thing.
+     * Registers an undo step for state outside the element's state slots. The snapshot covers the slots, which is
+     * everything a regular write modifies; an operation that replaces anything else registers its own undo here, so
+     * the snapshot does not have to include it.
      */
     whenRolledBack(work: () => void): void;
     /**
-     * Registers work that runs once the transaction has committed, and not at all where it is rolled back. It is
-     * how an operation defers a step that cannot be taken back - cancelling work in flight, for one - until the
-     * change it belongs to actually stands.
+     * Registers work that runs after the transaction commits, and not at all if it is rolled back. An operation uses
+     * it to defer a step that cannot be undone (for example, cancelling work in flight) until its change is
+     * committed. The work runs after the transaction is closed, so a write it makes opens a transaction of its own.
      */
     whenCommitted(work: () => void): void;
     /**
-     * Notes that an element at or below the depth the pass in progress is working at has been enrolled. The pass
-     * then gives up the rest of its batch and is started again over what is now owed, so the newcomer is reached
-     * before the containers above it: an element a handler writes must still be announced before the container
-     * whose composed value carries that write. The depth is only measured while a pass is running - outside one
-     * there is nothing the answer would change.
+     * Records that an element at or below the depth of the running pass has been enrolled. The pass then stops and
+     * restarts over the pending entries, so the new element is processed before the containers above it: an element
+     * a handler writes is announced before the container whose composed value includes that write. The depth is
+     * computed only while a pass runs; outside a pass it has no effect.
      */
     private noteDepth;
     /**
-     * Puts every element the transaction modified back as it found it. Nothing is announced: from an observer's
-     * point of view the transaction never happened. What a rollback cannot take back are side effects - a handler
-     * that called a server during the transaction already did.
+     * Restores every element the transaction modified to its state before the transaction. Nothing is announced, so
+     * an observer sees no change. A rollback does not undo side effects, such as a server call a handler made during
+     * the transaction.
      */
     rollback(): void;
     /**
-     * Announces what the transaction did. Values first and verdicts after, because a container's validators run
-     * with its value announcement and the verdict they reach is what the validity pass then reports. Both passes
-     * run deepest first - field, then row, then list - which is the order the change travelled in.
+     * Announces the transaction's changes: access, enabled and visibility first, then values, then validity, because
+     * a container's validators run with its value announcement and the validity pass reports their result. Every pass
+     * runs deepest first (field, then row, then list), the order in which the change propagates.
      *
-     * A handler may write while the commit runs; its writes join this transaction, so both passes repeat until
-     * nothing is left dirty.
+     * A handler may write while the commit runs; its writes join this transaction, so the passes repeat until nothing
+     * is dirty.
      */
     commit(): void;
     /**
-     * The dirty participants a pass has to visit, one bucket per nesting depth; ties keep the order they were
-     * enrolled in. A nesting depth is a small integer, so the elements go into buckets rather than through a
-     * comparison sort: a whole-list assignment enrols one participant per field, and ordering those by comparison
-     * would cost more than the announcement it orders.
+     * Runs the work registered with whenCommitted, then the `onCommit` hooks. It is called after the transaction is
+     * closed, so a write made here opens a transaction of its own and is announced, and an exception does not roll
+     * back the committed change. Every step runs; the first exception thrown is rethrown after the last one.
+     */
+    settle(): void;
+    /**
+     * The dirty participants a pass visits, one bucket per nesting depth; within a depth they keep enrolment order.
+     * A nesting depth is a small integer, so bucketing replaces a comparison sort: a whole-list assignment enrols one
+     * participant per field, and a comparison sort of those would cost more than the announcement itself.
      */
     private buckets;
     /**
-     * Runs one pass over the dirty participants, deepest bucket first; the caller repeats it until it answers
-     * false. The buckets are taken once, and the pass gives up as soon as a handler enrols an element at or below
-     * the depth being drained: that element is not in the bucket being walked, and going on would reach the
-     * containers above it first. The caller's next pass takes fresh buckets and finds it at its own depth.
+     * Runs one pass over the dirty participants, deepest bucket first; the caller repeats it until it returns false.
+     * The buckets are built once, and the pass stops as soon as a handler enrols an element at or below the depth
+     * being processed: that element is not in the current bucket, and continuing would process the containers above
+     * it first. The caller's next pass builds new buckets that include it at its depth.
      */
     private pass;
     private announceValues;
+    private announceFlags;
     private settleValidity;
 }
 
 /**
- * Runs `fn` as one atomic change. The writes it makes land in the elements as they are made and the events they
- * produce are announced once, at the end, over the net result.
+ * Runs `fn` as one atomic change. Its writes are applied to the elements immediately, and the resulting events are
+ * announced once, at the end, for the net result.
  *
- * A call made while a transaction is already open joins it: nothing is committed until the outermost call
- * returns. A throw out of `fn` rolls the whole transaction back and rethrows, and `tx.rollback()` rolls it back
- * without an error, in which case the call answers undefined.
+ * A call made while a transaction is open joins it: nothing is committed until the outermost call returns. An
+ * exception thrown from `fn` rolls back the whole transaction and is rethrown; `tx.rollback()` rolls it back
+ * without an error, and the call returns undefined.
  *
  * The handle `fn` receives is usable only for the duration of that call; calling it afterwards throws a TypeError.
  *
- * @throws TypeError immediately if `fn` returns a thenable - a transaction cannot cross an await.
+ * @throws TypeError immediately if `fn` returns a thenable: a transaction cannot span an await.
  */
 export declare function transaction<R>(fn: (tx: TransactionControl) => R): R | undefined;
 
 export declare interface TransactionControl {
     /**
-     * Undoes everything the transaction has done and ends it, announcing nothing. It unwinds from the point of
-     * the call, so nothing after it runs. There are no savepoints: a nested call rolls back the whole transaction
-     * it joined, not its own part of it.
+     * Undoes everything the transaction has done and ends it, announcing nothing. It unwinds from the point of the
+     * call, so no code after it runs. There are no savepoints: a nested call rolls back the whole transaction it
+     * joined, not only its own part.
      *
-     * @throws TypeError where the transaction the handle belongs to has already closed.
+     * @throws TypeError if the transaction the handle belongs to has already closed.
      */
     rollback(): never;
 }
 
-/** A built-in validator's default message, translated and reactive to a later `translateStrings` call. */
-export declare function translatedMessage(key: keyof typeof strings): ComputedRef<string | MdString>;
-
-export declare const translateStrings: (cb: TranslateStringsCallback<    {
-Required: string;
-MinValue: string;
-MaxValue: string;
-ValueInRange: string;
-MinLength: string;
-MaxLength: string;
-LengthInRange: string;
-Pattern: string;
-InAllowedValues: string;
-ValidationFailed: string;
-}>) => void;
+declare const TxAnnounceFlags: unique symbol;
 
 declare const TxAnnounceValue: unique symbol;
 
 /**
- * The protocol a transaction drives its participants through. The four members are symbol-keyed so that they
- * carry no name a consumer could reach or collide with, and they live on the prototype, so no walker over an
- * element's own keys sees them either.
+ * The protocol a transaction uses to call its participants. The members are symbol-keyed, so a consumer cannot
+ * reach them by name or collide with them, and they are on the prototype, so a walk over an element's own keys
+ * does not find them.
  */
 declare const TxCapture: unique symbol;
 
@@ -1890,20 +2362,19 @@ declare const TxRestore: unique symbol;
 declare const TxSettleValidity: unique symbol;
 
 /**
- * A transaction is the unit an observer sees a change in. Every mutating operation runs inside one: where the
- * caller opens none, the operation is the transaction, so a single write is atomic without anything having to be
- * remembered at the call site.
+ * A transaction is the unit in which an observer sees a change. Every mutating operation runs inside one: if the
+ * caller has not opened one, the operation is its own transaction, so a single write is atomic without any action
+ * at the call site.
  *
- * Writes land in the element straight away and only the announcement waits. At commit the net transitions are
- * measured against the state the elements last announced and each is announced once, so a value that goes A -> B
- * -> A within one transaction says nothing. Validators run while the transaction is open, because the verdict
- * they reach is what the commit announces; every other action fires at commit.
+ * Writes are applied to the element immediately; only the announcement is deferred. At commit the net changes are
+ * compared against the state the elements last announced and each is announced once, so a value that goes
+ * A -> B -> A within one transaction is not announced. Validators run while the transaction is open, because the
+ * commit announces their result; every other action fires at commit.
  *
- * A transaction may not cross an await: transaction() throws when the callback returns a thenable. Two
- * overlapping transactions therefore cannot exist, and an asynchronous validator settling later opens one of its
- * own at that moment.
+ * A transaction cannot span an await: transaction() throws when the callback returns a thenable. Two overlapping
+ * transactions therefore cannot exist, and an asynchronous validator that settles later opens its own transaction.
  */
-/** the slots of one element as they stood when the transaction first modified it */
+/** the slots of one element as they were when the transaction first modified it */
 declare type TxSnapshot = Record<string, any>;
 
 /** a ListItemAddedAction or ListItemRemovedAction waiting for the commit that will emit it */
@@ -1916,75 +2387,55 @@ declare interface TxStructuralEvent {
 }
 
 /**
- * Base validation error class with component rendering capabilities
+ * An error on an element. It is data: the library does not render it. A renderer chooses the text for `code` and
+ * `params` and falls back to `detail`.
  */
-export declare class ValidationError {
-    code?: string | undefined;
+export declare class ValidationError implements ErrorDescription {
+    readonly code: string;
+    readonly params: Readonly<Record<string, unknown>>;
+    readonly detail: string;
     private readonly statedOrigin?;
     /**
-     * @param code Machine-readable identifier of what failed, in kebab-case. Every validator this library ships states
-     * one, so code that reacts to a particular failure does not have to match the message text, which is translated
-     * and configurable. It is optional: an error built by hand carries whatever its author gives it, or nothing.
-     * @param statedOrigin Where the error comes from, where its author states it; see `origin`.
+     * @param code Machine-readable identifier of what failed, in snake_case.
+     * @param params The values of the failure, such as `minValue` for `min_value`.
+     * @param detail The failure in English, plain text. Stored as given.
+     * @param statedOrigin The origin of the error, if its author sets it; see `origin`.
      */
-    constructor(code?: string | undefined, statedOrigin?: ErrorOrigin | undefined);
+    constructor(code: string, params: Readonly<Record<string, unknown>>, detail: string, statedOrigin?: ErrorOrigin | undefined);
     /**
-     * Where the error comes from: the origin its author stated, and otherwise `'validator'` for an error a validator
-     * produced - a validator stamps every error it hands a field - and `'application'` for one written into `errors`
-     * by any other code. It is what a rendering layer reads to decide when to show the error, and what code reads to
-     * withdraw the errors of one origin and leave the rest.
+     * The origin its author set. Otherwise `'validator'` for an error a validator produced (a validator stamps every
+     * error it puts on a field) and `'application'` for one written into `errors` by any other code.
      */
     get origin(): ErrorOrigin;
     /**
-     * True where `other` is an error of this class that renders exactly as this one does and reports the same code.
-     * Two runs of one validator over an unchanged value produce two instances of one message, and this is what lets
-     * the validator hand the field back the instance it already holds rather than a fresh one: an equal error is not
-     * a new error, and nothing re-renders over a verdict that did not move.
-     *
-     * The comparison is over what renders - the component, its bindings, its body and the classes - because that is
-     * what a reader of `field.errors` sees. A structural comparison of the errors themselves answers nothing useful:
-     * `ValidationErrorRenderContent` holds a Vue `computed`, and two of those are never structurally equal.
+     * True if `other` has the same class, code, params, detail and stated origin. If a new run produces an error for
+     * which this is true, the validator keeps the instance the field already holds, so an unchanged error is not
+     * replaced in `field.errors`.
      */
     sameAs(other: ValidationError): boolean;
-    get componentName(): string;
-    get componentBindings(): {};
-    get componentBody(): string;
-    get extraClasses(): ClassTypes;
 }
 
 /**
- * Validation error that supports multiple content types (plain text, markdown, component)
+ * The `code` and `detail` a built-in validator uses on its error in place of its own. A `detail` requires a `code`:
+ * a renderer chooses the text by the code, so a detail under the validator's own code is not shown where the
+ * renderer has a text for that code.
  */
-export declare class ValidationErrorRenderContent extends ValidationError {
-    classes: ClassTypes;
-    private text;
-    private textType;
-    constructor(text: RenderContentRef, classes?: ClassTypes, code?: string, origin?: ErrorOrigin);
-    get resolvedText(): RenderContentNonCallable;
-    get getTextType(): "string" | "md" | "component";
-    get componentName(): string;
-    get componentBindings(): Record<any, any>;
-    get componentBody(): string;
-    get extraClasses(): ClassTypes;
-}
-
-/**
- * Simple text-only ValidationError
- */
-export declare class ValidationErrorText extends ValidationError {
-    text: string;
-    classes: ClassTypes;
-    constructor(text: string, classes?: ClassTypes, code?: string, origin?: ErrorOrigin);
-    get componentName(): string;
-    get componentBody(): string;
-    get extraClasses(): ClassTypes;
-}
+declare type ValidationErrorOptions = {
+    /** The error's `code`. Defaults to the validator's own, such as `required`. */
+    code?: string;
+    detail?: never;
+} | {
+    /** The error's `code`. */
+    code: string;
+    /** The error's English `detail`, plain text. `{name}` placeholders are replaced with the error's `params`. */
+    detail?: string;
+};
 
 /**
- * What a validator does with a value. `signal` aborts when the verdict this call would reach stops counting - a
- * newer run over the same field, a field the validator was taken off once that removal stands, a transaction that
- * was unwound - so an asynchronous check hands it to the work it commissions and stops paying for an answer nobody
- * will read. A function that has nothing to cancel ignores it.
+ * The validation of a value. `signal` aborts when the result of this call will no longer be applied: a newer run
+ * over the same field, the validator's removal from the field once that removal is committed, a rolled-back
+ * transaction. An asynchronous check passes it to the work it starts, so that work is cancelled. A function with
+ * nothing to cancel ignores it.
  */
 declare type ValidationFunction<T = any> = (newValue: T, oldValue: T, field: FieldBase<T>, signal: AbortSignal) => ValidationFunctionResult | Promise<ValidationFunctionResult>;
 
@@ -2002,52 +2453,54 @@ declare class Validator<T = any> extends ValueChangedAction {
      */
     constructor(validationFn: ValidationFunction<T>);
     /**
-     * Returns the error instance this validator owns and may later withdraw: the argument itself when it carries no
-     * ownership stamp or already carries this validator's, a copy of it when it belongs to another validator. The
-     * stamp is not configurable, so an instance one validator owns can never be reassigned to another; the copy is
-     * what makes an error instance shareable between validators, and it keeps the prototype and every own property,
-     * including the non-enumerable ones, so it renders exactly like the instance it was made from.
+     * Returns the error instance this validator owns and may later remove: the argument itself if it has no
+     * ownership stamp or already has this validator's, and a copy if it belongs to another validator. The stamp is
+     * not configurable, so an instance owned by one validator cannot be reassigned to another; the copy allows one
+     * error instance to be shared between validators, and keeps the prototype and every own property, including the
+     * non-enumerable ones, so it renders like the original.
      */
     private claim;
     static get classIdentifier(): symbol;
     get eager(): boolean;
     /**
-     * Takes this validator off `field`: the errors it put there are withdrawn and the verdict is re-formed over what
-     * the validators the field still holds have to say. Withdrawing them is what keeps a field from staying invalid
-     * on an error no validator is left to take back.
+     * Removes this validator from `field`: the errors it put there are removed and validity is recomputed over the
+     * remaining validators. Otherwise the field would stay invalid on an error no validator removes.
      *
-     * A run in flight over the field is cancelled once the removal stands, and not before: a transaction that
-     * unwinds puts the validator and its epoch back, and the run it never cancelled goes on to reach the verdict the
-     * field is then owed. Cancelling it as the removal is made would leave the field reporting itself valid over a
-     * value nothing checked, on the strength of a transaction that never happened.
+     * A run in flight over the field is cancelled when the removal is committed, not earlier: a rollback restores the
+     * validator, and the run, still active, then applies its result. Cancelling at the removal would leave the field
+     * valid over an unchecked value after a rollback. A run started after the removal, by registering the validator
+     * again in the same transaction, is not cancelled.
      */
     unregisterFrom(field: FieldBase): void;
     /**
-     * Cancels the asynchronous run in flight over `field`, where there is one. It is called once the field has
-     * stopped holding this validator: the field's validation epoch has moved on by then, so the run's verdict is
-     * already dropped and the signal it handed its check aborts with it.
+     * Cancels the asynchronous run in flight over `field`, if any. It is called once the validator's removal from the
+     * field is committed: the run number advances, so the run's result is discarded and its signal aborts. The other
+     * validators of the field keep their runs.
      */
     protected abandonRun(field: FieldBase): void;
     /**
-     * What this validator remembers about one of the fields it validates. One instance may be registered on several
-     * fields - every row of a list carries the instances the item template carries - so each field has a record of
-     * its own. A subclass that remembers more widens the record by overriding `newBindingState`.
+     * The validator's state for one of the fields it validates. One instance may be registered on several fields
+     * (every row of a list has the same instances as the item template), so each field has its own state. A subclass
+     * extends it by overriding `newBindingState`.
      */
     protected bindingState(field: FieldBase<any>): ValidatorBindingState;
     /**
-     * The record a field starts with. `run` is the sequence number of the newest run over that field: every
-     * execution takes the next one and a result is applied only while its number is still the newest, so a slow run
-     * cannot overwrite the verdict of a faster one that started after it.
+     * The initial state for a field. `run` is the sequence number of the newest run over that field: every execution
+     * takes the next number and a result is applied only while its number is the newest, so a slow run cannot
+     * overwrite the result of a faster one that started after it.
      */
     protected newBindingState(): ValidatorBindingState;
-    protected replacePlaceholdersFunction(text: RenderContentRef, replace: Record<string, any>): RenderContentRef;
-    protected replacePlaceholders(text: RenderContentRef, replace: Record<string, any>): RenderContentRef;
+    /**
+     * Returns the error a built-in validator reports: `code` and `detail` from `options` if set, the validator's own
+     * otherwise, with `params` substituted into the detail.
+     */
+    protected errorFor(options: ValidationErrorOptions | undefined, code: string, detail: string, params: Record<string, unknown>): ValidationError;
 }
 
-/** What a validator remembers about one field it is registered on; a subclass widens it. */
+/** The validator's state for one field it is registered on; a subclass extends it. */
 declare interface ValidatorBindingState {
     run: number;
-    /** cancels the asynchronous run in flight over the field, absent while no run is waiting for its verdict */
+    /** cancels the asynchronous run in flight over the field; undefined while no run is pending */
     abandon?: () => void;
 }
 
@@ -2060,9 +2513,11 @@ export declare namespace Validators {
         Required_2 as Required,
         RequiredOptions,
         Pattern,
+        isEmptyValue,
         ValidationFunctionResult,
         ValidationFunction,
         ValidatorBindingState,
+        ValidationErrorOptions,
         Validator,
         MinValue,
         MaxValue,
@@ -2086,39 +2541,38 @@ export declare class ValueChangedAction<T = any> extends FieldActionBase {
 }
 
 declare class ValueInRange<T = any> extends Validator {
-    constructor(minValue: T, maxValue: T, message?: RenderContentRef);
+    constructor(minValue: T, maxValue: T, options?: ValidationErrorOptions);
 }
 
 /**
- * An element seen as its data: the members of a group, or the rows of a list, as plain properties, and the element
- * itself as `$`. See `view()`.
+ * An element presented as its data: the members of a group, or the rows of a list, as plain properties, and the
+ * element itself as `$`. See `view()`.
  */
 export declare type View<E extends FieldBase> = (E extends Group<infer F, any> ? GroupData<F> : E extends List<infer R, any> ? ListData<R> : unknown) & {
     readonly $: E;
 };
 
 /**
- * The element seen as its data. A group's members and a list's rows are plain properties of the view - a field as
- * its value, a container as its own view - and `$` is the element itself: `view.$.valid`,
+ * Returns the element presented as its data. A group's members and a list's rows are plain properties of the view
+ * (a field as its value, a container as its own view), and `$` is the element itself: `view.$.valid`,
  * `view.$.access = 'readonly'`, `view.$.registerAction(...)`.
  *
- * A member reads what the element holds, by the rule `fullValue` follows: every member is there whatever its access,
- * so a disabled field reads and writes like any other. Every read goes
- * through the element's tracked state, so an effect reading `view.address.city` re-runs when that field changes and
- * not when another one does.
+ * A member reads what the element holds, as in `fullValue`: every member is present whatever its access, so a
+ * disabled field reads and writes like any other. Every read goes through the element's tracked state, so an
+ * effect that reads `view.address.city` re-runs when that field changes and not when another one does.
  *
  * A list's view is an array: it reads like one, and `push`, `pop`, `shift`, `unshift`, `splice`, `sort` and
- * `reverse` are carried out as the list's own operations, so every row keeps its element and its state.
+ * `reverse` are performed as the list's own operations, so every row keeps its element and its state.
  *
- * One element has one view: `view(element) === view(element)`, and `view()` of a view hands it back.
+ * One element has one view: `view(element) === view(element)`, and `view()` of a view returns the same view.
  */
 export declare function view<V extends View<any>>(of: V): V;
 
 export declare function view<E extends FieldBase>(element: E): View<E>;
 
 /**
- * How a rendering layer shows a form element. It is presentation alone: what an element sends and whether it is
- * validated are its `access`, and no visibility changes either.
+ * How a rendering layer shows a form element. It affects presentation only: what an element sends and whether it
+ * is validated are determined by `access`, and visibility changes neither.
  *
  * - `'full'`: rendered and shown
  * - `'invisible'`: rendered and keeps its space in the layout, but is not painted (`visibility: hidden`)
@@ -2143,3 +2597,15 @@ export declare class VisibilityChangingAction extends FieldActionBase {
 export declare const visibilityValues: readonly Visibility[];
 
 export { }
+
+
+declare module '@vue/reactivity' {
+    /**
+     * An element carries __v_skip, so ref() and reactive() hold it as it is. Listing it here makes their types do the
+     * same: `ref([action])` is a `Ref<Action[]>` and `reactive({ form }).form` is the form's own type, where Vue's
+     * unwrapping would otherwise produce a structural copy of the class without its non-public members.
+     */
+    interface RefUnwrapBailTypes {
+        dynamicformsElement: FieldBase<any, any>;
+    }
+}