@optionfactory/fml 9.0.0-rc28 → 9.0.0-rc29

package/dist/ful.d.mts

@@ -361,7 +361,9 @@ declare class Bindings {
      * alone and a composite field named for a prefix catches the problems of its
      * subtree. Each control of that name gets `setCustomValidity(reason, rest)`,
      * `rest` being the remainder of the path (`''` on an exact match) that a
-     * composite can use to route the problem to an inner control.
+     * composite can use to route the problem to an inner control. Several
+     * problems reaching one control with the same `rest` are joined one per
+     * line into a single call.
      *
      * A control counts only when it can show a problem, through a
      * `setCustomValidity` of its own: a form-associated element that has none is
@@ -376,7 +378,8 @@ declare class Bindings {
      * Each `ful-field-error` of the form gets `aria-live="off"` when
      * `scrollOnError` is set, since focusing the field announces its error, and
      * `aria-live="polite"` otherwise. With `scrollOnError` and at least one
-     * problem, the topmost `:invalid` control is focused.
+     * problem, the topmost `:invalid` control is focused; a `<fieldset>`
+     * matching `:invalid` for the controls it holds is not a candidate.
      *
      * A banner or `ful-field-error` belongs to the nearest enclosing form, so
      * those of a nested form are left alone.
@@ -403,9 +406,12 @@ declare class Bindings {
  *
  * The claim setters, the validity protocol and the aria wiring all act on the
  * pieces, so a field with no native control returns a focusable piece of its
- * own chrome as the control. The claim getters and `focus()` are the only
- * members that tolerate a not yet rendered element; the other members need the
- * pieces and so work only after the render.
+ * own chrome as the control. The claims, `value` and `focus()` are the
+ * members that tolerate a not yet rendered element: before the render the
+ * `value` getter answers what the rendered field would answer from its current
+ * declared state, and a value written then is held and applied by the render
+ * (see `_holdValue`). The other members need the pieces and so work only after
+ * the render.
  *
  * The inner controls carry `form=""`, so the host is the only element the form
  * sees. Enter pressed in an inner `<input>` of any type but `file`, `button`,
@@ -517,11 +523,35 @@ declare class Field extends ParsedElement {
      * @returns {boolean}
      */
     _interactive(): boolean;
+    /**
+     * Upgrades as `ParsedElement.upgrade` does, then writes the value held by
+     * `_holdValue`, if any, through the `value` setter: the value written
+     * before the render wins over the declared one.
+     * @returns {Promise<void>} rejecting with what the render threw
+     */
+    upgrade(): Promise<void>;
+    /**
+     * Keeps a value written before the field has its control, for a subclass's
+     * `value` setter to call in place of writing it: the upgrade writes it
+     * through the setter once the field has rendered, over the declared one.
+     * The `value` attribute is left alone, so a reset still restores it.
+     * @param {any} value
+     */
+    _holdValue(value: any): void;
+    /**
+     * The value a subclass's `value` getter shapes before the field has its
+     * control: the one `_holdValue` kept, else the declared `value` attribute
+     * read through its mapper.
+     * @returns {any}
+     */
+    _heldValue(): any;
     /**
      * The field's value, `null` when empty. Every concrete field overrides the
      * pair with its own semantics; the form extraction, `values =` assignment,
      * the `change` detail and `formResetCallback` all go through it. The base
-     * pair reads `undefined` and ignores writes.
+     * pair reads `undefined` and ignores writes. A concrete field answers and
+     * takes its value before the render too, through `_heldValue` and
+     * `_holdValue`.
      * @type {any}
      */
     get value(): any;
@@ -766,7 +796,7 @@ declare class Form extends ParsedElement {
     connectedCallback(): void;
     disconnectedCallback(): void;
     /**
-     * Runs the submit pipeline, with the spinner up for its whole length:
+     * Runs the submit pipeline, with the spinner up until its outcome:
      *
      * 1. builds the loader: the component the `loader` attribute names
      *    (`loaders:form` by default), called as `create(form)`
@@ -783,8 +813,8 @@ declare class Form extends ParsedElement {
      * 6. has the loader `submit` the request and `transform` the response
      * 7. under `track-changes`, commits the values extracted at step 2 (see
      *    `commit`): an edit made while the submit was in flight stays unsaved
-     * 8. fires `submit:success` with `{ submitter, values, request, response }`,
-     *    `response` being the transformed one
+     * 8. releases the spinner and fires `submit:success` with `{ submitter,
+     *    values, request, response }`, `response` being the transformed one
      *
      * Anything thrown from step 1 on, a missing loader or a throwing mapper
      * included, fires `submit:failure` with `{ submitter, values, request,
@@ -793,6 +823,11 @@ declare class Form extends ParsedElement {
      * `console.warn`. The `values` of both outcome events are the extracted
      * ones, not a replacement a `submit` listener put on its detail.
      *
+     * The form settles before either outcome event (0016): its listeners see
+     * the spinner released and the buttons no longer held off, the problems of
+     * a `Failure` already shown, and the submit no longer in flight, so one
+     * of them may submit again.
+     *
      * A call while a submit is in flight returns at once, doing nothing.
      * @param {HTMLElement} [submitter] the button that submitted, if any; it is
      * the only button whose name and value are submitted
@@ -813,8 +848,9 @@ declare class Form extends ParsedElement {
     save(submitter?: HTMLElement): Promise<boolean>;
     /**
      * Resets the native form, each field returning to its default value. Under
-     * `track-changes` every control counts as edited: the form is dirty if the
-     * defaults differ from what was last committed.
+     * `track-changes` a reset, this one or a native reset button's, counts
+     * every control as edited: the form is dirty if the defaults differ from
+     * what was last committed.
      */
     reset(): void;
     /**
@@ -977,8 +1013,12 @@ declare class Input extends Field {
      * `v-type="number"`, where text that does not decode is answered as it is.
      * Writing `null`, `undefined` or `''` empties the control; anything else is
      * written as its string, replacing whatever was being typed, as a native
-     * control's value does. Answers a `string`, a `number` or `null`; typed
-     * `any` because subclasses answer other values.
+     * control's value does, and is not an edit: a date or time control that
+     * has the focus reports no `change` for it when it is left. Answers a
+     * `string`, a `number` or `null`; typed `any` because subclasses answer
+     * other values. Before the render the same shaping reads the value last
+     * written, or the `value` attribute, as its text, and a write is held for
+     * the render to apply.
      * @type {any}
      */
     get value(): any;
@@ -1098,7 +1138,9 @@ declare class InputInstant extends Input {
     static observed: string[];
     _type(): string;
     /**
-     * The entered time as a UTC ISO instant.
+     * The entered time as a UTC ISO instant. Before the render it answers the
+     * value last written, or the `value` attribute, as the rendered field
+     * would, and a write is held for the render to apply.
      * @returns {string|null} null when empty or when the input holds text that does not parse
      */
     get value(): string | null;
@@ -1206,7 +1248,7 @@ declare class InputFile extends Input {
     /** @param {boolean} v */
     set multiple(v: boolean);
     /**
-     * The selected files, after the constraints.
+     * The selected files, after the constraints; none before the render.
      * @returns {FileList}
      */
     get files(): FileList;
@@ -1228,13 +1270,14 @@ declare class InputFile extends Input {
     set file(v: File | null | undefined);
     /**
      * The names of the selected files: an array when `multiple`, otherwise the
-     * one name or null.
+     * one name or null. Before the render no file is selected yet.
      * @returns {string[]|string|null}
      */
     get value(): string[] | string | null;
     /**
      * Empties the selection for a falsy value and ignores any other, since a
-     * file name cannot select a file.
+     * file name cannot select a file. Before the render there is nothing to
+     * empty, so it does nothing.
      * @param {any} v
      */
     set value(v: any);
@@ -1338,7 +1381,8 @@ declare class Anchors {
      *   which light dismiss then closes with no script of your own. The popover
      *   is given the generated id when it has none. A `button` or `input`
      *   invoker gets a `popovertarget` naming it; any other element toggles it
-     *   on click and on the Enter and Space keys
+     *   on click and on the Enter and Space keys; a click on it while the
+     *   popover is open closes the popover rather than opening it again
      * @param {boolean} [options.expanded] sets the invoker's `aria-expanded` to
      *   `false` at once and keeps it in step with the popover's `toggle` events
      * @param {boolean} [options.stretch] in the script placement, sizes the
@@ -1428,7 +1472,8 @@ declare class RemoteLoader {
      */
     prefetch(): Promise<void>;
     /**
-     * The entries whose key loosely equals one of the keys, in vocabulary order.
+     * The entries whose key reads as the same text as one of the keys, in
+     * vocabulary order.
      * @param {...any} keys
      * @returns {Promise<SelectEntry[]>}
      * @throws when the fetch fails, or when an invalidation supersedes it
@@ -1503,7 +1548,8 @@ declare class InMemoryLoader {
      */
     invalidate(): Promise<void>;
     /**
-     * The entries whose key loosely equals one of the keys, in vocabulary order.
+     * The entries whose key reads as the same text as one of the keys, in
+     * vocabulary order.
      * @param {...any} keys
      * @returns {SelectEntry[]}
      */
@@ -1635,14 +1681,16 @@ declare class Dropdown extends ParsedElement {
     }): void;
     /**
      * Picks the highlighted row, or the first enabled one when none is: hides
-     * the dropdown and dispatches `change`. Does nothing when no row is enabled.
+     * the dropdown and dispatches `change`. Does nothing when the highlighted
+     * row is disabled, when no row is enabled, or while a search is loading
+     * and the rows are hidden.
      */
     acceptSelection(): void;
     /**
      * Renders the entries as rows and highlights the first one whose key is
      * picked, else the row the template marked `selected`, else the first
      * enabled row. A row is marked `picked` and
-     * `aria-selected="true"` when its key loosely equals one of the keys, and
+     * `aria-selected="true"` when its key reads as the same text as one of the keys, and
      * `aria-disabled="true"` when its `metadata.disabled` is truthy, titled with
      * `metadata.reason`. No entries shows the empty state instead of the menu.
      * @param {SelectEntry[]} values
@@ -1675,7 +1723,8 @@ declare class Dropdown extends ParsedElement {
     show(loader: () => SelectEntry[] | Promise<SelectEntry[]>, keys?: any[]): Promise<void>;
     /**
      * Moves the highlight to the next or previous enabled row when the dropdown
-     * is shown, staying put at the edge, and shows it otherwise.
+     * is shown, staying put at the edge and while a search is loading, and
+     * shows it otherwise.
      * @param {boolean} forward
      * @param {() => SelectEntry[]|Promise<SelectEntry[]>} loader used only to show
      * @param {any[]} [keys] the keys currently selected, used only to show
@@ -1684,13 +1733,15 @@ declare class Dropdown extends ParsedElement {
      */
     moveOrShow(forward: boolean, loader: () => SelectEntry[] | Promise<SelectEntry[]>, keys?: any[]): Promise<void>;
     /**
-     * Highlights the first enabled row, or the last one.
+     * Highlights the first enabled row, or the last one. Does nothing while a
+     * search is loading and the rows are hidden.
      * @param {boolean} first
      */
     jump(first: boolean): void;
     /**
      * Moves the highlight by as many enabled rows as the menu shows at once,
      * one when that cannot be measured, stopping at the last enabled row.
+     * Does nothing while a search is loading.
      * @param {boolean} forward
      */
     page(forward: boolean): void;
@@ -1780,12 +1831,14 @@ declare class Select extends Field {
      * another control needs when that control changes. A key the loader no
      * longer knows is dropped from the selection, so a value invalidated by the
      * change does not survive it, and one it still knows keeps its place with a
-     * fresh label. The badges and items follow, and no `change` is dispatched.
+     * fresh label. The badges and items follow, an open dropdown runs its
+     * search again, and no `change` is dispatched.
      *
      * Where the vocabulary lives at a different address, write `src` or call
      * `reconfigure`, which build the loader for the new url and reload.
      * @returns {Promise<void>}
-     * @throws what the loader's invalidate, prefetch or key lookup throws
+     * @throws what the loader's invalidate, prefetch, key lookup or search
+     * throws
      */
     reload(): Promise<void>;
     /**
@@ -1852,20 +1905,23 @@ declare class Select extends Field {
     get query(): string;
     /**
      * Selects the keys, coerced by `k-type`: a key, an array of keys, or null or
-     * undefined for none. The empty string is a key like any other. The keys
-     * are applied at once, each labeled by itself until the loader's `exact`
+     * undefined for none. The empty string is a key like any other, and a
+     * single select keeps only the first key. The keys are applied at once, each labeled by itself until the loader's `exact`
      * answers; a key it does not answer is then dropped, a key removed in the
      * meantime stays removed, and a later assignment wins over the late answer.
      * A failed lookup keeps the keys and surfaces as an unhandled rejection.
      * No `change` is dispatched. A key containing a
      * comma, which the value attribute cannot carry, is kept and warned about
-     * once per element.
+     * once per element. Before the render the write is held for the render to
+     * apply, over the `value` attribute, which it leaves alone.
      * @param {any} vs
      */
     set value(vs: any);
     /**
      * The selected keys, in selection order, for a multiple select; the one
-     * key, or null, for a single one.
+     * key, or null, for a single one. Before the render it answers the keys
+     * last written, or the `value` attribute, coerced and cut to one key as the
+     * rendered select would.
      * @returns {any}
      */
     get value(): any;
@@ -1876,14 +1932,32 @@ declare class Select extends Field {
      * @returns {SelectEntry|SelectEntry[]|null}
      */
     get entry(): SelectEntry | SelectEntry[] | null;
+    /**
+     * The field's disabled claim; turning it on while the dropdown is open
+     * closes it and drops a pending search.
+     * @type {boolean}
+     */
+    get disabled(): boolean;
+    set disabled(v: boolean);
+    /**
+     * The field's readonly claim; turning it on while the dropdown is open
+     * closes it and drops a pending search.
+     * @type {boolean}
+     */
+    get readonly(): boolean;
+    set readonly(v: boolean);
     /**
      * Whether the select holds several keys: `value` and `entry` answer arrays,
      * the input stays empty and the selection shows as removable badges in the
-     * control.
+     * control. Before the render it answers the `multiple` attribute.
      * @returns {boolean}
      */
     get multiple(): boolean;
-    /** @param {boolean} v */
+    /**
+     * Turning it off keeps only the first selected key; either way the badges,
+     * the items and the input follow at once.
+     * @param {boolean} v
+     */
     set multiple(v: boolean);
     /**
      * Whether the selection shows as the `items` list below the control instead
@@ -1899,10 +1973,10 @@ declare class Select extends Field {
  * a radio input carrying its attributes, labelled by its content; every
  * `input-*` attribute on the group is forwarded onto each radio as well. The
  * default slot is the `<legend>`, and `header` and `footer` slots frame the
- * list. The radios share a name of their own (derived from `name`, or minted
- * when there is none) and carry `form=""`, so the group is the only element
- * the form sees. A radio's native `change` is stopped and republished as the
- * group's own.
+ * list. The radios share a name of their own, minted afresh for each group
+ * (from `name` when there is one) so that same-named groups stay apart, and
+ * carry `form=""`, so the group is the only element the form sees. A radio's
+ * native `change` is stopped and republished as the group's own.
  *
  * The host carries the `radiogroup` role, `aria-readonly`, `aria-required`,
  * `aria-invalid` and the description. The disabled and readonly claims act on
@@ -1930,7 +2004,10 @@ declare class RadioGroup extends Field {
      * The value of the checked radio, `null` when none is. Under
      * `type="boolean"` it answers `true` for a radio whose value is `true` and
      * `false` for any other. Writing a value checks the radio carrying it, and
-     * writing `null` or a value no radio carries clears the selection.
+     * writing `null` or a value no radio carries clears the selection. Before
+     * the render it answers the value last written, or the `value` attribute,
+     * when a `ful-radio` carries it, and a write is held for the render to
+     * apply.
      * @type {string | boolean | null}
      */
     get value(): string | boolean | null;
@@ -1961,7 +2038,9 @@ declare class Checkbox extends Field {
     }): any;
     /**
      * Whether the box is checked. The `value` attribute is read with the `bool`
-     * mapper, where only the text `true` means checked.
+     * mapper, where only the text `true` means checked. Before the render it
+     * answers the value last written, or the `value` attribute, and a write is
+     * held for the render to apply.
      * @type {boolean}
      */
     get value(): boolean;
@@ -2223,12 +2302,17 @@ declare class TableLoader {
  * for it. Without it the table shows an initial panel until `load`,
  * `reload` or `resetWithFilter` is called.
  *
- * Inside the table a `page:requested` loads that page with the current size,
+ * Inside the table, and not inside a `ful-table` nested in it, a
+ * `page:requested` loads that page with the current size,
  * sort and filters; a `sort:requested` loads the current page with the new
  * sort (none for a `null` order) and, once that load is the one showing, sets
  * the order of the sorter that asked and clears the others; a `submit:success`
  * of the filter form loads the first page with the submitted request as the
- * filters. The loads these start, and the autoload, are not awaited by
+ * filters. The first load goes through the filter form too: `reload`, and so
+ * `autoload`, submits it (see `reload`), so a `submit` listener rewriting
+ * `detail.request` shapes every load alike. The filters a page, a sort or a size change carries are those of
+ * the last load asked for, whether it is still running, loaded or failed, so
+ * they are the ones the filter form shows. The loads these start, and the autoload, are not awaited by
  * anything: a failure shows the error panel and its rejection is unhandled.
  */
 declare class Table extends ParsedElement {
@@ -2262,10 +2346,12 @@ declare class Table extends ParsedElement {
      *
      * The reload is not awaited: a failure shows the error panel and its
      * rejection is unhandled.
-     * @param {number|null|undefined} value absent or null is the default of
-     * ten, so removing the attribute restores it
+     * @param {number|string|null|undefined} value a number or a string of
+     * one, such as a select's value; absent or null is the default of ten,
+     * so removing the attribute restores it, and a value that is not a
+     * number is ignored
      */
-    set pageSize(value: number | null | undefined);
+    set pageSize(value: number | string | null | undefined);
     /**
      * The url the loader asks for rows, reflected as the `src` attribute.
      * @returns {string|null}
@@ -2320,14 +2406,21 @@ declare class Table extends ParsedElement {
     }): Promise<void>;
     /**
      * Loads the last request that loaded, or, before any has, the first page
-     * with the declared size and sort and the values of the filters slot. A
-     * size written through `pageSize` since then replaces the page with the
-     * first one at that size.
+     * with the declared size and sort. A size written through `pageSize` since
+     * then replaces the page with the first one at that size.
+     *
+     * Before any load has loaded, a table with a `filters` slot submits its
+     * filter form instead, so the first request goes through the same
+     * `submit` listeners as the later ones, and the load its `submit:success`
+     * starts is the one awaited. A filter submit that is cancelled, fails or
+     * is dropped for one in flight loads nothing, and the promise resolves.
      * @returns {Promise<void>} as `load`
      */
     reload(): Promise<void>;
     /**
-     * Asks the loader for a page and shows it.
+     * Asks the loader for a page and shows it. Its filters are, from now on,
+     * the ones a page, a sort or a size change carries, even while it runs
+     * or once it failed.
      *
      * While the load runs the table carries `aria-busy="true"`, and the rows
      * already shown stay; the spinner panel shows only when there are none.
@@ -2335,7 +2428,8 @@ declare class Table extends ParsedElement {
      * panel shows for an answer with no rows (the `empty` slot rendered with
      * `schema`, `pageRequest`, `filterRequest` and `pageResponse` in scope),
      * the request becomes the one
-     * `reload` repeats, `aria-busy` is removed and `load:success` is
+     * `reload` repeats; once the elements of the rows and of the empty panel
+     * have rendered, `aria-busy` is removed and `load:success` is
      * dispatched (bubbling, not cancelable) with `detail` set to
      * `{ pageRequest, sortRequest, filterRequest, response }`. A page beyond
      * the last one the answer reports is not shown: the last page is loaded
@@ -2349,7 +2443,9 @@ declare class Table extends ParsedElement {
      * returned promise rejects with the same error.
      *
      * A load started after this one supersedes it: when this one's answer or
-     * failure arrives it changes nothing, dispatches nothing and resolves.
+     * failure arrives it changes nothing, dispatches nothing and resolves;
+     * superseded while its rows render, it leaves them to the newer load and
+     * dispatches nothing.
      * @param {TablePageRequest} pageRequest
      * @param {TableSortRequest|null} sortRequest
      * @param {Record<string, any>} filterRequest
@@ -2543,7 +2639,8 @@ declare class CompareFilter extends Input {
      * The operators the menu offers, narrowed to the vocabulary: an empty list,
      * or one where no name is known, offers all of it. A single operator pins
      * the button, and an assigned tuple then carries that operator whatever it
-     * names. An assignment made before the upgrade is held narrowed and
+     * names. When the operator shown leaves the list, the first listed one is
+     * shown. An assignment made before the upgrade is held narrowed and
      * answered back until the render, when the `operators` attribute is applied
      * over it, an absent attribute meaning the whole vocabulary. Assignments are
      * ignored while the `operator` attribute fixes the operator.
@@ -2556,17 +2653,27 @@ declare class CompareFilter extends Input {
      * The filter's tuple, `[operator, operand]` or `[operator, from, to]` for
      * BETWEEN, each operand converted by `_serialize` (an ISO instant for the
      * instant filter). Null while any operand the operator uses is empty.
+     * Before the render it answers the tuple last written, or the `value`
+     * attribute, as the rendered filter would show it.
      * @returns {any[]|null}
      */
     get value(): any[] | null;
     /**
-     * Shows a tuple: the operator it names, unless a pinned or fixed operator
-     * replaces it, and its operands, an operand missing from a shorter tuple
+     * Shows a tuple: the operator it names, or the first allowed one where the
+     * whitelist, a pin or a fixed operator does not allow it, and its operands, an operand missing from a shorter tuple
      * leaving its input empty. Null or undefined empties both operands and
-     * keeps the operator.
+     * keeps the operator. Before the render the tuple is held for the render
+     * to apply, over the `value` attribute, which it leaves alone.
      * @param {any[]|null|undefined} v
      */
     set value(v: any[] | null | undefined);
+    /**
+     * The tuple `_tuple` answers once `_applyTuple(v)` has shown `v`, read
+     * from the declared `operator` and `operators` in place of the menu.
+     * @param {any[]|null|undefined} v
+     * @returns {any[]|null}
+     */
+    _shownTuple(v: any[] | null | undefined): any[] | null;
     _tuple(): any[] | null;
     _applyTuple(v: any): void;
     _showOperator(operator: any): void;
@@ -2577,7 +2684,7 @@ declare class CompareFilter extends Input {
      * them rather than as serialized: a date filter describes what is in its
      * control, not the ISO string it sends. Null while every one of those
      * operands is empty, so a BETWEEN with one bound answers that bound while
-     * its value is still null.
+     * its value is still null, and before the filter has rendered.
      * @returns {FilterCriterion|null}
      */
     get criterion(): FilterCriterion | null;
@@ -2657,7 +2764,9 @@ declare class TextFilter extends CompareFilter {
     set sensitivities(declared: string[] | null);
     /**
      * The tuple with the sensitivity after the operator, `[operator,
-     * sensitivity, ...operands]`. Null while any operand the operator uses is empty.
+     * sensitivity, ...operands]`. Null while any operand the operator uses is
+     * empty. Before the render it answers the tuple last written, or the
+     * `value` attribute, as the rendered filter would show it.
      * @returns {any[]|null}
      */
     get value(): any[] | null;
@@ -2665,7 +2774,8 @@ declare class TextFilter extends CompareFilter {
      * Shows a tuple as the compare filter does, reading the sensitivity at
      * index 1. A sensitivity the whitelist does not allow leaves the current
      * one in place. Null or undefined empties the operands and keeps the
-     * operator and the sensitivity.
+     * operator and the sensitivity. Before the render the tuple is held, as
+     * on the compare filters.
      * @param {any[]|null|undefined} v
      */
     set value(v: any[] | null | undefined);
@@ -2719,7 +2829,8 @@ declare class BooleanFilter extends Field {
     /**
      * The operators the menu offers, narrowed to EQ and NEQ: an empty list, or
      * one where no name is known, offers both, and a single one pins the
-     * button. Held before the upgrade and replaced by the `operators` attribute
+     * button. When the operator shown leaves the list, the first listed one is
+     * shown. Held before the upgrade and replaced by the `operators` attribute
      * at the render, as on the compare filters.
      * @returns {string[]|undefined} undefined before the upgrade when nothing was assigned
      */
@@ -2729,14 +2840,17 @@ declare class BooleanFilter extends Field {
     /** @returns {string[]} */
     _vocabulary(): string[];
     /**
-     * `[operator, token]`, the token being 'true' or 'false'; null while the value menu is on any.
+     * `[operator, token]`, the token being 'true' or 'false'; null while the
+     * value menu is on any. Before the render it answers the tuple last
+     * written, or the `value` attribute, as the rendered filter would show it.
      * @returns {string[]|null}
      */
     get value(): string[] | null;
     /**
-     * Shows a tuple: its operator, unless a pinned operator replaces it, and its
-     * token, a missing token meaning any. Null or undefined sets the value menu
-     * back to any and keeps the operator.
+     * Shows a tuple: its operator, or the first allowed one where the whitelist
+     * does not allow it, and its token, a missing token meaning any. Null or undefined sets the value menu
+     * back to any and keeps the operator. Before the render the tuple is held,
+     * as on the compare filters.
      * @param {any[]|null|undefined} v
      */
     set value(v: any[] | null | undefined);
@@ -2747,7 +2861,7 @@ declare class BooleanFilter extends Field {
     formResetCallback(): void;
     /**
      * The operator and the localized word the value menu shows, not the token.
-     * Null while the value menu is on any.
+     * Null while the value menu is on any, and before the filter has rendered.
      * @returns {FilterCriterion|null}
      */
     get criterion(): FilterCriterion | null;
@@ -2775,7 +2889,8 @@ declare class InFilter extends Select {
      * The chosen keys as an array, a single choice included, led by the
      * declared `operator` when there is one. Null while nothing is chosen, so
      * that a table drops the filter instead of sending an empty set that
-     * matches nothing.
+     * matches nothing. Before the render it answers the keys the select answers
+     * then.
      * @returns {any[]|null}
      */
     get value(): any[] | null;
@@ -2783,13 +2898,14 @@ declare class InFilter extends Select {
      * Selects the keys of an array or a single bare key; a leading element equal
      * to the declared `operator` is dropped first, so the filter takes back what
      * it answered. A single select takes the first key. Null or undefined clears
-     * the selection.
+     * the selection. Before the render the keys are held, as the select holds
+     * them.
      * @param {any} v
      */
     set value(v: any);
     /**
      * The declared operator, or null, and the labels of the chosen entries. Null
-     * while nothing is chosen.
+     * while nothing is chosen, as before the filter has rendered.
      * @returns {FilterCriterion|null}
      */
     get criterion(): FilterCriterion | null;
@@ -2931,7 +3047,8 @@ declare class Dialog extends ParsedElement {
      * the body and `first` true only on the first answered request), so a
      * listener can fill the body. A failed request is painted into the body
      * and does not reject. On a dialog already open nothing is shown or
-     * requested, and the call waits for the same ending as the calls before it.
+     * requested, and the call waits for the same ending as the calls before it;
+     * one the page moved while open, which is no longer modal, opens anew.
      * @returns {Promise<DialogOutcome>} resolving on close, or on removal from
      * the document with a dismissal
      */
@@ -3126,9 +3243,11 @@ declare class Drawer extends ParsedElement {
      * the content section and `first` true only on the first answered request),
      * so a listener can fill the content. A failed request is painted into the
      * content section and does not reject. On a drawer already open nothing is
-     * shown or requested, except that one sliding out stops and stays open, and
-     * the call waits for the same ending as the calls before it, which is how
-     * a caller learns the outcome of the opening an `update()` made.
+     * shown or requested, except that one sliding out stops and stays open,
+     * forgetting the result it was closing with, and the call waits for the
+     * same ending as the calls before it, which is how a caller learns the
+     * outcome of the opening an `update()` made. One the page moved while open,
+     * which is no longer modal, opens anew.
      * @returns {Promise<{ dismissed: boolean, result: string|null, response: any }>} resolving on
      * close, or on removal from the document with a dismissal
      */
@@ -3186,6 +3305,10 @@ declare class Menu extends ParsedElement {
     #private;
     /** @type {string[]} */
     static attributes: string[];
+    /** Upgrades the menu, and has a shared one that came back follow the presses on its invoker again. */
+    connectedCallback(): void;
+    /** Stops a shared menu following the presses while it is out of the document. */
+    disconnectedCallback(): void;
     /**
      * Gives the menu the `menu` role and an empty `popover` attribute unless
      * it already has one, and marks the items. With `for`, read here once, it
@@ -3475,7 +3598,8 @@ declare class Wizard extends ParsedElement {
      * @returns {Promise<any[] | undefined> | undefined} a promise resolving to
      * the answers once they are delivered, or to undefined when nobody
      * listened; undefined when the section is already current, and undefined
-     * with a warning when no section carries `ref`
+     * with a warning when no section carries `ref` or the one carrying it has
+     * no step paired with it
      * @throws what the entered section's delivery rejected with, as the rejection
      * of the returned promise, after its error is painted in the section
      */
@@ -3488,7 +3612,7 @@ declare class Wizard extends ParsedElement {
      * @returns {Promise<any[] | undefined> | undefined} a promise resolving to
      * the answers, or to undefined when nobody listened or the delivery failed
      * (its error painted in the section); undefined, with a warning, when `ref`
-     * names no section
+     * names no section or one with no step paired with it
      */
     refresh(ref: string | Element): Promise<any[] | undefined> | undefined;
 }