@fusion.dev/helix-headless 0.166.0 → 0.167.0

package/custom-elements.json

@@ -11952,6 +11952,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -11973,7 +12017,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -11982,6 +12026,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -12464,21 +12522,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -13630,6 +13673,60 @@
         }
       ]
     },
+    {
+      "kind": "javascript-module",
+      "path": "src/canvas/arrange.ts",
+      "declarations": [
+        {
+          "kind": "function",
+          "name": "arrangement",
+          "return": {
+            "type": {
+              "text": "Map<string, { x: number; y: number }>"
+            }
+          },
+          "parameters": [
+            {
+              "name": "nodes",
+              "type": {
+                "text": "readonly CanvasNode[]"
+              }
+            },
+            {
+              "name": "edges",
+              "type": {
+                "text": "readonly CanvasEdge[]"
+              }
+            },
+            {
+              "name": "options",
+              "default": "{}",
+              "type": {
+                "text": "CanvasArrangeOptions"
+              }
+            },
+            {
+              "name": "snap",
+              "optional": true,
+              "type": {
+                "text": "number"
+              }
+            }
+          ],
+          "description": "Where each card goes, by id, so that no two cards overlap.\n\n**Layers where there are connections.** A card goes one layer past the\nfurthest card that points to it, a connection that would close a loop is\nread as pointing back, and the cards in each layer are ordered by where\nthe cards they connect to sit, so connections cross less. **A grid where\nthere are none**, in reading order, about as many columns as rows.\n\nA group is placed as one box and carries the cards inside it, so a card\nstays in its group. What is arranged starts where the board's top left\ncorner was, and every place lands on a multiple of `snap` where it is set."
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "arrangement",
+          "declaration": {
+            "name": "arrangement",
+            "module": "src/canvas/arrange.ts"
+          }
+        }
+      ]
+    },
     {
       "kind": "javascript-module",
       "path": "src/canvas/describe.ts",
@@ -15342,6 +15439,85 @@
         }
       ]
     },
+    {
+      "kind": "javascript-module",
+      "path": "src/canvas/paste.ts",
+      "declarations": [
+        {
+          "kind": "function",
+          "name": "parseCanvas",
+          "return": {
+            "type": {
+              "text": "CanvasDocument | undefined"
+            }
+          },
+          "parameters": [
+            {
+              "name": "text",
+              "type": {
+                "text": "string"
+              }
+            }
+          ],
+          "description": "A JSON Canvas document read from pasted text, or nothing where the text is\nnot one: any text that does not parse, or a node without an id, a type and\na box. An edge whose ends are not both among the nodes is left out."
+        },
+        {
+          "kind": "function",
+          "name": "pasteInto",
+          "return": {
+            "type": {
+              "text": "CanvasDocument"
+            }
+          },
+          "parameters": [
+            {
+              "name": "document",
+              "type": {
+                "text": "CanvasDocument"
+              }
+            },
+            {
+              "name": "nodes",
+              "type": {
+                "text": "readonly CanvasNode[]"
+              }
+            },
+            {
+              "name": "taken",
+              "type": {
+                "text": "ReadonlySet<string>"
+              }
+            },
+            {
+              "name": "step",
+              "type": {
+                "text": "number"
+              },
+              "description": "How far each move is, in the document's own units."
+            }
+          ],
+          "description": "The document a paste adds to a board that already holds `nodes` and the\nconnections named in `taken`.\n\n**Every id is made new where the board has it**, by a count after it, and\nthe connections follow their cards to the new ids. **The cards move clear\nof what they were copied from**: a step down and to the right, and another\nwhile any pasted card would still sit where a card already is, so a second\npaste lands beside the first. Cards from another board, where nothing sits,\nstay where they were."
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "parseCanvas",
+          "declaration": {
+            "name": "parseCanvas",
+            "module": "src/canvas/paste.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "pasteInto",
+          "declaration": {
+            "name": "pasteInto",
+            "module": "src/canvas/paste.ts"
+          }
+        }
+      ]
+    },
     {
       "kind": "javascript-module",
       "path": "src/canvas/root/canvas-document.ts",
@@ -15771,7 +15947,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "A board of cards and connectors, drawn by Helix. On a canvas every position\nis data that someone placed, so drawing is arithmetic over rectangles with no\nlayout to compute. `Map` takes a slotted map, because another renderer draws\nits tiles.\n\nThe format is [JSON Canvas](https://jsoncanvas.org), an open format. Each\nnode has an `x`, `y`, `width`, `height`, and a type. Each edge names the two\nnodes it joins and the sides it leaves and arrives on. A card belongs to a\ngroup when it sits inside the group's bounds.\n\nThe cards are text in the DOM, so a screen reader can read them. The family\nadds a reading order and states each card's connections as text. `order` sets\nthe reading order:\n- `spatial` bands the cards into rows.\n- `edges` follows the arrows, starting from the cards that nothing points to.\n\n**Cards move by default.** The board writes the new `x` and `y` onto the\ncard, the way an input writes its own value, and dispatches two events:\n- `helix-before-move` for every step. Cancel it to hold the positions in your\n  own state and apply them yourself.\n- `helix-move` once the move is finished.\n\nA resize dispatches the same pair with a size. Set `readonly` on the board to\nkeep every card in place, such as on a published board. Set `readonly` on one\ncard or connection to keep only that one in place.\n\nSet `snap` to a length in the document's units, such as `32`, and a card\nthat is moved or resized lands on a multiple of it. Carrying a card, a\ncorner, a connection, or the selection box near the edge of the board moves\nthe board under it, so a card can be taken to a place off screen in one\ndrag. A connection let go within 20 pixels of a card arrives at it. A\ndouble click on the empty board zooms in about that point, and Shift with a\ndouble click zooms out.\n\nKeyboard behavior:\n- One card holds the board's tab stop.\n- The arrow keys move through the cards in reading order. The card you land\n  on scrolls into view, and its connections are announced with it.\n- The card you land on is selected. Control or Command with an arrow key,\n  Home, or End moves without changing the selection, and Space adds the card\n  to the selection or takes it out, so you can select cards that are not\n  next to each other.\n- Shift with an arrow key moves the card: by 16 units, or to the next\n  multiple of `snap` where it is set. Alt with an arrow key resizes it from\n  its bottom right corner the same way.\n- The connections leaving a card are stops of their own, straight after it.\n  Enter on one moves to the card it arrives at.\n- What a key changes that a reader cannot see is said: where a card moved\n  to, its new size, how many cards are selected, and the zoom. A selected\n  card or connection says so when a reader arrives on it.\n- Control or Command with C copies the selected cards, and the connections\n  between them, as a JSON Canvas document in text, which another board or\n  an app that reads the format takes. A paste is your page's: listen for\n  `paste` on the board, read the text with `fromJsonCanvas`, and add the\n  cards it holds.\n- Control or Command with Z undoes the last move or resize the board made,\n  and with Shift, or Control with Y, makes it again. `undo()` and `redo()`\n  do the same from a script. Each asks with `helix-before-move` and tells\n  with `helix-move`, as a move does, so a board that holds its positions in\n  your state is undone through your state.\n\nEvery drag also works with clicks, as WCAG 2.5.7 requires for a pointer that\ncannot hold a button down. Click a selected card's move handle, a corner, a\ncard's connection point, or the end of a selected connection to pick it up.\nIt follows the pointer with no button held, and the next click puts it down\nwhere a drag would have. On touch, the next tap sets where it lands. Escape,\nor a press outside the board, puts it back. So a finger connects two cards\nwith three taps: the card, one of its points, and the card to connect to.\n\nConnecting and removing dispatch requests, and your code applies them:\n- Drawing from a card's handle to another card, or pressing C on one card and\n  Enter on another, dispatches `helix-connect`.\n- Delete on a card or a connection dispatches `helix-remove`. The event names\n  every connection that removing the card would leave without an end.\n\nOnce your page removes what Delete asked for, focus moves to the next stop,\nto the one before where it was the last, and to the board where none is\nleft. A focused card your page removes for its own reasons hands focus on\nthe same way, unless the reader has already moved focus somewhere else.\n\nThe board applies a move itself, because the card already exists. A\nconnection is a new element, and React discards an element the board adds to\nits markup on the next render, so you write the connection.\n\n**`edgeRoute` draws the connections' lines your own way**: a function from\nwhere a line leaves and arrives, and the sides it does, to its SVG path, for\na route such as one that bends around the cards between. What it returns\nis the line drawn, the line pressed and focused, and the one an arrowhead\nsits at the end of. Nothing back draws the board's own.\n\nAdd `minimap` to `controls` for a picture of the whole board in a corner:\neach card as a box, and a frame around what is on screen. A press or a drag\non it brings that place to the middle of the view. It is for a pointer, and\na screen reader skips it: the arrow keys and `show()` reach every card.\n\nCards and connections are `helix-canvas-node` and `helix-canvas-edge`\nelements, so they are in the served markup whichever renderer wrote them. The\nlibrary fetches nothing, and an array passed to an element is missing from\nthe first paint of a server-rendered React page. `fromJsonCanvas` turns a\nJSON Canvas document into their props, and `toJsonCanvas()` writes a board\nback out.",
+          "description": "A board of cards and connectors, drawn by Helix. On a canvas every position\nis data that someone placed, so drawing is arithmetic over rectangles with no\nlayout to compute. `Map` takes a slotted map, because another renderer draws\nits tiles.\n\nThe format is [JSON Canvas](https://jsoncanvas.org), an open format. Each\nnode has an `x`, `y`, `width`, `height`, and a type. Each edge names the two\nnodes it joins and the sides it leaves and arrives on. A card belongs to a\ngroup when it sits inside the group's bounds.\n\nThe cards are text in the DOM, so a screen reader can read them. The family\nadds a reading order and states each card's connections as text. `order` sets\nthe reading order:\n- `spatial` bands the cards into rows.\n- `edges` follows the arrows, starting from the cards that nothing points to.\n\n**Cards move by default.** The board writes the new `x` and `y` onto the\ncard, the way an input writes its own value, and dispatches two events:\n- `helix-before-move` for every step. Cancel it to hold the positions in your\n  own state and apply them yourself.\n- `helix-move` once the move is finished.\n\nA resize dispatches the same pair with a size. Set `readonly` on the board to\nkeep every card in place, such as on a published board. Set `readonly` on one\ncard or connection to keep only that one in place.\n\nSet `snap` to a length in the document's units, such as `32`, and a card\nthat is moved or resized lands on a multiple of it. Carrying a card, a\ncorner, a connection, or the selection box near the edge of the board moves\nthe board under it, so a card can be taken to a place off screen in one\ndrag. A connection let go within 20 pixels of a card arrives at it. A\ndouble click on the empty board zooms in about that point, and Shift with a\ndouble click zooms out.\n\nKeyboard behavior:\n- One card holds the board's tab stop.\n- The arrow keys move through the cards in reading order. The card you land\n  on scrolls into view, and its connections are announced with it.\n- The card you land on is selected. Control or Command with an arrow key,\n  Home, or End moves without changing the selection, and Space adds the card\n  to the selection or takes it out, so you can select cards that are not\n  next to each other.\n- Shift with an arrow key moves the card: by 16 units, or to the next\n  multiple of `snap` where it is set. Alt with an arrow key resizes it from\n  its bottom right corner the same way.\n- The connections leaving a card are stops of their own, straight after it.\n  Enter on one moves to the card it arrives at.\n- What a key changes that a reader cannot see is said: where a card moved\n  to, its new size, how many cards are selected, and the zoom. A selected\n  card or connection says so when a reader arrives on it.\n- Control or Command with C copies the selected cards, and the connections\n  between them, as a JSON Canvas document in text, which another board or\n  an app that reads the format takes.\n- Control or Command with V pastes a JSON Canvas document: the board adds\n  its cards and connections, a step down and to the right of any card they\n  would sit on, and selects them. It asks with `helix-before-paste` first.\n  A page that renders its cards from its own state cancels it and adds the\n  detail's document to that state, through `fromJsonCanvas`. `paste()` does\n  the same from a script.\n- Control or Command with Z undoes the last move or resize the board made,\n  and with Shift, or Control with Y, makes it again. `undo()` and `redo()`\n  do the same from a script. Each asks with `helix-before-move` and tells\n  with `helix-move`, as a move does, so a board that holds its positions in\n  your state is undone through your state.\n\n**`arrange()` moves every card so that none overlaps another**, in layers\nthat follow the arrows, or in a grid on a board with no connections. The\ncards glide for as long as the board's own transition, and `undo()` puts\nthem back.\n\nEvery drag also works with clicks, as WCAG 2.5.7 requires for a pointer that\ncannot hold a button down. Click a selected card's move handle, a corner, a\ncard's connection point, or the end of a selected connection to pick it up.\nIt follows the pointer with no button held, and the next click puts it down\nwhere a drag would have. On touch, the next tap sets where it lands. Escape,\nor a press outside the board, puts it back. So a finger connects two cards\nwith three taps: the card, one of its points, and the card to connect to.\n\nConnecting and removing dispatch requests, and your code applies them:\n- Drawing from a card's handle to another card, or pressing C on one card and\n  Enter on another, dispatches `helix-connect`.\n- Delete on a card or a connection dispatches `helix-remove`. The event names\n  every connection that removing the card would leave without an end.\n\nOnce your page removes what Delete asked for, focus moves to the next stop,\nto the one before where it was the last, and to the board where none is\nleft. A focused card your page removes for its own reasons hands focus on\nthe same way, unless the reader has already moved focus somewhere else.\n\nThe board applies a move itself, because the card already exists. A\nconnection is a new element, and React discards an element the board adds to\nits markup on the next render, so you write the connection.\n\n**`edgeRoute` draws the connections' lines your own way**: a function from\nwhere a line leaves and arrives, and the sides it does, to its SVG path, for\na route such as one that bends around the cards between. What it returns\nis the line drawn, the line pressed and focused, and the one an arrowhead\nsits at the end of. Nothing back draws the board's own.\n\nAdd `minimap` to `controls` for a picture of the whole board in a corner:\neach card as a box, and a frame around what is on screen. A press or a drag\non it brings that place to the middle of the view. It is for a pointer, and\na screen reader skips it: the arrow keys and `show()` reach every card.\n\nCards and connections are `helix-canvas-node` and `helix-canvas-edge`\nelements, so they are in the served markup whichever renderer wrote them. The\nlibrary fetches nothing, and an array passed to an element is missing from\nthe first paint of a server-rendered React page. `fromJsonCanvas` turns a\nJSON Canvas document into their props, and `toJsonCanvas()` writes a board\nback out.",
           "name": "HelixHeadlessCanvas",
           "cssProperties": [
             {
@@ -15990,6 +16166,19 @@
                 "module": "src/mixins/mixin-viewport/mixin-viewport.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "arrangedLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Cards arranged'",
+              "description": "What screen readers hear after `arrange()` moves the cards.",
+              "attribute": "arranged-label",
+              "helix": {
+                "words": true
+              }
+            },
             {
               "kind": "field",
               "name": "comesFromLabel",
@@ -16165,6 +16354,19 @@
               "attribute": "order",
               "reflects": true
             },
+            {
+              "kind": "field",
+              "name": "pastedLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'{count, plural, one {# card pasted} other {# cards pasted}}'",
+              "description": "What screen readers hear after a paste, with `{count}` for the cards pasted.",
+              "attribute": "pasted-label",
+              "helix": {
+                "words": true
+              }
+            },
             {
               "kind": "field",
               "name": "path",
@@ -16212,6 +16414,19 @@
                 "words": true
               }
             },
+            {
+              "kind": "field",
+              "name": "removedLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'{count, plural, one {Asked to remove {name}.} other {Asked to remove # items.}}'",
+              "description": "What screen readers hear when Delete asks to remove what is selected, with\n`{count}` for how many cards and connections, and `{name}` for the one\nwhere there is one.",
+              "attribute": "removed-label",
+              "helix": {
+                "words": true
+              }
+            },
             {
               "kind": "field",
               "name": "resizedLabel",
@@ -17795,6 +18010,76 @@
               "readonly": true,
               "description": "A copy on the board with cards selected writes them, and the connections\nbetween them, as a JSON Canvas document in text. Not from a field a card\nholds, nor over text a reader selected, which are the platform's to copy."
             },
+            {
+              "kind": "field",
+              "name": "handlePaste",
+              "privacy": "private",
+              "readonly": true,
+              "description": "A paste on the board of a JSON Canvas document, the text a copy writes,\nadds its cards and connections. Not into a field a card holds, nor onto a\n`readonly` board, nor text that is not a board, which are the platform's."
+            },
+            {
+              "kind": "method",
+              "name": "paste",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "document",
+                  "type": {
+                    "text": "CanvasDocument | string"
+                  }
+                }
+              ],
+              "description": "Adds the cards and connections of a JSON Canvas document, as a paste does,\nand selects the cards. Ids the board already holds are given a count after\nthem, and the cards move a step down and to the right while they would sit\non cards already there.\n\nAsks with `helix-before-paste` first: cancel it to add the detail's\ndocument to your own state. Returns whether the board added the cards:\nfalse on a `readonly` board, for text that is not a board, or when the\nrequest was refused.",
+              "type": {
+                "text": "paste(document: CanvasDocument | string) => boolean"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "gliding",
+              "type": {
+                "text": "{ frame: number; to: MoveDetail['nodes'] } | undefined"
+              },
+              "privacy": "private",
+              "description": "The glide `arrange()` started, while it runs."
+            },
+            {
+              "kind": "method",
+              "name": "settle",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Ends a glide where it was going."
+            },
+            {
+              "kind": "method",
+              "name": "arrange",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "options",
+                  "default": "{}",
+                  "type": {
+                    "text": "CanvasArrangeOptions"
+                  }
+                }
+              ],
+              "description": "Moves the cards so that none overlaps another: in layers that follow the\nconnections, or in a grid where there are none. A group moves as one box\nwith its cards. Each place lands on a multiple of `snap` where it is set.\n\nAsks with `helix-before-move` first and tells with `helix-move`, as a\nmove does, so `undo()` puts every card back. The cards glide to their\nplaces for as long as the board's plane takes to glide, and land at once\nwhere it does not, such as under `prefers-reduced-motion`. Returns whether\nthe cards moved.",
+              "type": {
+                "text": "arrange(options: CanvasArrangeOptions = {}) => boolean"
+              }
+            },
             {
               "kind": "field",
               "name": "handleHistoryKey",
@@ -19668,6 +19953,14 @@
               "name": "helix-before-move",
               "reactProp": "onhelix-before-move"
             },
+            {
+              "type": {
+                "text": "HelixBeforePasteEvent"
+              },
+              "description": "Cards and connections are about to be pasted. Cancelable: cancel it to add the detail's document to your own state.",
+              "name": "helix-before-paste",
+              "reactProp": "onhelix-before-paste"
+            },
             {
               "type": {
                 "text": "HelixBeforeReconnectEvent"
@@ -19732,6 +20025,14 @@
               "name": "helix-move",
               "reactProp": "onhelix-move"
             },
+            {
+              "type": {
+                "text": "HelixPastedEvent"
+              },
+              "description": "Cards and connections were pasted, and the board holds them.",
+              "name": "helix-pasted",
+              "reactProp": "onhelix-pasted"
+            },
             {
               "type": {
                 "text": "HelixReconnectEvent"
@@ -19775,6 +20076,15 @@
               "description": "The hint shown when the board, waiting to be pressed with\n`gestures=\"activate\"`, is scrolled or swiped over.",
               "fieldName": "activateHintLabel"
             },
+            {
+              "name": "arranged-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Cards arranged'",
+              "description": "What screen readers hear after `arrange()` moves the cards.",
+              "fieldName": "arrangedLabel"
+            },
             {
               "name": "comes-from-label",
               "type": {
@@ -19891,6 +20201,15 @@
               "description": "The order the arrow keys and screen readers move through the cards:\n`spatial` or `edges`.\n\n`spatial` bands them into rows and reads each row across, which is how a\nperson reads a board laid out on a grid and is a heuristic a loose board\ndefeats. `edges` follows the arrows from the cards nothing points to, which\non a board that is a flow is the order its author meant.\n\nAbsent is spatial, a resting value being an attribute's absence: a default\nthat reflected would write a choice onto every host that no server sent.",
               "fieldName": "order"
             },
+            {
+              "name": "pasted-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'{count, plural, one {# card pasted} other {# cards pasted}}'",
+              "description": "What screen readers hear after a paste, with `{count}` for the cards pasted.",
+              "fieldName": "pastedLabel"
+            },
             {
               "name": "path",
               "type": {
@@ -19926,6 +20245,15 @@
               "description": "What screen readers hear after a move or a resize is made again.",
               "fieldName": "redoneLabel"
             },
+            {
+              "name": "removed-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'{count, plural, one {Asked to remove {name}.} other {Asked to remove # items.}}'",
+              "description": "What screen readers hear when Delete asks to remove what is selected, with\n`{count}` for how many cards and connections, and `{name}` for the one\nwhere there is one.",
+              "fieldName": "removedLabel"
+            },
             {
               "name": "resized-label",
               "type": {
@@ -20281,6 +20609,14 @@
         }
       ],
       "exports": [
+        {
+          "kind": "js",
+          "name": "CanvasArrangeOptions",
+          "declaration": {
+            "name": "CanvasArrangeOptions",
+            "module": "../arrange.js"
+          }
+        },
         {
           "kind": "js",
           "name": "CanvasDocument",
@@ -23439,6 +23775,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -23460,7 +23840,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -23469,6 +23849,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -23951,21 +24345,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -27588,7 +27967,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -28028,6 +28407,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -28049,7 +28472,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -28058,6 +28481,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -28540,21 +28977,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -29386,7 +29808,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -29826,6 +30248,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -29847,7 +30313,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -29856,6 +30322,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -30338,21 +30818,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -34414,7 +34879,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -34854,6 +35319,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -34875,7 +35384,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -34884,6 +35393,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -35340,21 +35863,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -37526,6 +38034,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -37547,7 +38099,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -37556,6 +38108,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -38012,21 +38578,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -39756,7 +40307,7 @@
                   "text": "TemplateResult"
                 }
               },
-              "description": "The caret saying the field opens, behind a seam.\n\nSlot fallback, so a consumer replaces it by slotting; and a method, so the\ntier above replaces it by overriding. Those answer different people: the\nslot is for the page and the method is for whoever is building the styled\nlayer, and a fallback with only the first is one a tier can restyle and\ncannot change."
+              "description": "The caret saying the field opens, behind a seam.\n\nSlot fallback, so a consumer replaces it by slotting; and a method, so the\ntier above replaces it by overriding. Those answer different people: the\nslot is for the page and the method is for whoever is building the styled\nlayer, and a fallback with only the first is one a tier can restyle and\ncannot change.\n\n**One em square by its own attributes**, which any stylesheet overrides.\nAn inline `<svg>` with a `viewBox` and no size fills the width it is given:\nmeasured with no stylesheet, the caret was 1,264px tall, the field 1,289px,\nand the panel opened above the top of the page."
             },
             {
               "kind": "method",
@@ -40426,7 +40977,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -40866,6 +41417,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -40887,7 +41482,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -40896,6 +41491,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -41364,21 +41973,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -44221,6 +44815,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -44242,7 +44880,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -44251,6 +44889,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -44733,21 +45385,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -49191,7 +49828,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "The calendar is `DatePicker`, which handles months, ranges, disabled days,\nthe first day of the week, and the grid's keyboard behavior. The date input\nadds the field, the overlay, and the connection between them.\n\nYou can type a date as well as pick one. The native `<input type=\"date\">`\ngives a picker and locale formatting but allows almost no styling, so the\nfield is a text field. Typing sends `input` on each keystroke and `change`\nwhen you leave the field, as a text field does. A date picked from the\ncalendar sends both. The field reads ISO, `2026-08-04`, and a date written\nin the order, the digits, and the month names of `locale`, `8/4/2026` or\n`Aug 4, 2026` in `en-US` and `4.8.2026` in `de-DE`, which becomes the value\nas you leave the field.\n\nThe trigger and ArrowDown open the calendar with focus on the selected day,\nTab moves between the calendar's controls without leaving it, and Escape\ncloses it and returns focus to the field. A press into the field opens the\ncalendar too. Tab into the field opens nothing, and Tab out of the field\ncloses the calendar. The text field is a `combobox` with\n`aria-haspopup=\"dialog\"`, `aria-expanded`, and `aria-controls`, as in the\nAPG date picker combobox, since Down opens the calendar from it.\n\nWith `segmented`, the field is a row of segments in place of the text: a\nmonth, a day and a year in the order the locale writes them, each set with\ndigits or the arrow keys. Alt+Down opens the calendar from a segment. A\n`range` is two rows with a dash between them, the start and the end, as\nReact Aria's DateRangePicker draws them, and `multiple` keeps the text.\n\nText that is not a date gives the form an empty value, as a native date\nfield does, and `value` keeps the text so it can be corrected.\n\n**Keyboard.** The field is one tab stop, or each segment is with\n`segmented`, and the trigger is one more.\n\n| Key | What it does |\n|---|---|\n| Down | In the text field, opens the calendar with focus on the chosen day. |\n| Alt with Down | Opens the calendar, from the text field or a segment. |\n| Enter | In the text field, takes the typed date and submits the form, as a native field does. |\n| Escape | Closes the calendar and puts focus back in the field. |\n| Tab | In the open calendar, moves between its controls. Out of the field, closes it. |\n| Up, Down on a segment | Steps the segment by one, round from its last value to its first. |\n| Page Up, Page Down on a segment | Steps by a page: a week of days, two months, or five years. |\n| Home, End on a segment | Goes to the segment's first or last value. |\n| Digits on a segment | Fill it, and move to the next once it can take no more. |\n| Backspace, Delete on a segment | Empty the segment. |\n| Left, Right on a segment | Move to the previous or the next segment, along the line of text. |\n\nIn the calendar, the keys are `DatePicker`'s: the arrows move by a day or a\nweek, Page Up and Page Down by a month, with Shift by a year, and Home and\nEnd to the start and the end of the week.",
+          "description": "The calendar is `DatePicker`, which handles months, ranges, disabled days,\nthe first day of the week, and the grid's keyboard behavior. The date input\nadds the field, the overlay, and the connection between them.\n\nYou can type a date as well as pick one. The native `<input type=\"date\">`\ngives a picker and locale formatting but allows almost no styling, so the\nfield is a text field. Typing sends `input` on each keystroke and `change`\nwhen you leave the field, as a text field does. A date picked from the\ncalendar sends both. The field reads ISO, `2026-08-04`, and a date written\nin the order, the digits, and the month names of `locale`, `8/4/2026` or\n`Aug 4, 2026` in `en-US` and `4.8.2026` in `de-DE`, which becomes the value\nas you leave the field.\n\nThe trigger and ArrowDown open the calendar with focus on the selected day,\nTab moves between the calendar's controls without leaving it, and Escape\ncloses it and returns focus to the field. A press into the field opens the\ncalendar too. Tab into the field opens nothing, and Tab out of the field\ncloses the calendar. The text field is a `combobox` with\n`aria-haspopup=\"dialog\"`, `aria-expanded`, and `aria-controls`, as in the\nAPG date picker combobox, since Down opens the calendar from it.\n\nWith `segmented`, the field is a row of segments in place of the text: a\nmonth, a day and a year in the order the locale writes them, each set with\ndigits or the arrow keys. Alt+Down opens the calendar from a segment. A\n`range` is two rows with a dash between them, the start and the end, as\nReact Aria's DateRangePicker draws them, and `multiple` keeps the text.\n\nText that is not a date gives the form an empty value, as a native date\nfield does, and `value` keeps the text so it can be corrected.\n\n**Keyboard.** The field is one tab stop, or each segment is with\n`segmented`, and the trigger is one more.\n\n| Key | What it does |\n|---|---|\n| Down | In the text field, opens the calendar with focus on the chosen day. |\n| Alt with Down | Opens the calendar, from the text field or a segment. |\n| Enter | In the text field, takes the typed date and submits the form, as a native field does. |\n| Escape | Closes the calendar and puts focus back in the field. |\n| Tab | In the open calendar, moves between its controls. Out of the field, closes it. |\n| Up, Down on a segment | Steps the segment by one, round from its last value to its first. |\n| Page Up, Page Down on a segment | Steps by a page: a week of days, two months, or five years. |\n| Home, End on a segment | Goes to the segment's first or last value. |\n| Digits on a segment | Fill it, and move to the next once it can take no more. |\n| Backspace, Delete on a segment | Take off its last digit, or move to the segment before where it is empty. |\n| Left, Right on a segment | Move to the previous or the next segment, along the line of text. |\n\nIn the calendar, the keys are `DatePicker`'s: the arrows move by a day or a\nweek, Page Up and Page Down by a month, with Shift by a year, and Home and\nEnd to the start and the end of the week.",
           "name": "HelixHeadlessDateInput",
           "cssParts": [
             {
@@ -50743,6 +51380,29 @@
                 "module": "src/mixins/mixin-segmented-field/mixin-segmented-field.ts"
               }
             },
+            {
+              "kind": "method",
+              "name": "erase",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "element",
+                  "type": {
+                    "text": "HTMLElement"
+                  }
+                }
+              ],
+              "description": "Takes the last digit off the segment, or moves to the segment before it\nwhere this one is already empty, as React Aria's segments do. A reader\nclearing a date from its end holds Backspace and it empties right to\nleft.",
+              "inheritedFrom": {
+                "name": "MixinSegmentedField",
+                "module": "src/mixins/mixin-segmented-field/mixin-segmented-field.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "composing",
@@ -51867,7 +52527,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -52307,6 +52967,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -52328,7 +53032,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -52337,6 +53041,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -52793,21 +53511,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -55453,6 +56156,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -55474,7 +56221,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -55483,6 +56230,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -55939,21 +56700,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -65112,7 +65858,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -65552,6 +66298,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -65573,7 +66363,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -65582,6 +66372,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -66038,21 +66842,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -70491,7 +71280,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -70931,6 +71720,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -70952,7 +71785,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -70961,6 +71794,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -71417,21 +72264,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -72173,10 +73005,10 @@
               "kind": "field",
               "name": "date",
               "type": {
-                "text": "string"
+                "text": "Date | number | string"
               },
               "default": "''",
-              "description": "The timestamp, in any format `Date` can parse.\n\nAn ISO string is what an API sends and what `<time datetime>` takes, so it\nis the shape that needs no translation at either end. Left unset this\nrenders nothing rather than the epoch, which is what parsing an empty string\nwould give.\n\n**The element's own text is read as a fallback, and only in a browser.**\n`<helix-headless-format-date\nelapsed>2026-08-27T01:00:00Z</helix-headless-format-date>` is the spelling\nthat reads best in markup, and it cannot be the only one: measured against\nLit's server shim, `textContent`, `children`, `firstChild` and\n`querySelector` are all `undefined` there, so a server has no way to see\nit. An element rendered on a server needs the attribute; one rendered in a\nbrowser may use either.",
+              "description": "The timestamp: a `Date`, milliseconds since the epoch, or a string in any\nformat `Date` can parse. The attribute is the string.\n\nAn ISO string is what an API sends and what `<time datetime>` takes, so it\nis the shape that needs no translation at either end. Left unset this\nrenders nothing rather than the epoch, which is what parsing an empty string\nwould give.\n\n**The element's own text is read as a fallback, and only in a browser.**\n`<helix-headless-format-date\nelapsed>2026-08-27T01:00:00Z</helix-headless-format-date>` is the spelling\nthat reads best in markup, and it cannot be the only one: measured against\nLit's server shim, `textContent`, `children`, `firstChild` and\n`querySelector` are all `undefined` there, so a server has no way to see\nit. An element rendered on a server needs the attribute; one rendered in a\nbrowser may use either.",
               "attribute": "date"
             },
             {
@@ -72435,7 +73267,7 @@
                 "text": "string"
               },
               "privacy": "private",
-              "description": "The timestamp as written, in the attribute or in the light DOM.",
+              "description": "The timestamp as written, in the property, the attribute or the light DOM.\n\nA `Date` or a number is written as its ISO string, so it is read the way an\nattribute is. Measured before this: assigning `new Date()` threw, since\nonly a string has `trim`, where Shoelace and Web Awesome take a `Date`.",
               "readonly": true
             },
             {
@@ -72846,10 +73678,10 @@
             {
               "name": "date",
               "type": {
-                "text": "string"
+                "text": "Date | number | string"
               },
               "default": "''",
-              "description": "The timestamp, in any format `Date` can parse.\n\nAn ISO string is what an API sends and what `<time datetime>` takes, so it\nis the shape that needs no translation at either end. Left unset this\nrenders nothing rather than the epoch, which is what parsing an empty string\nwould give.\n\n**The element's own text is read as a fallback, and only in a browser.**\n`<helix-headless-format-date\nelapsed>2026-08-27T01:00:00Z</helix-headless-format-date>` is the spelling\nthat reads best in markup, and it cannot be the only one: measured against\nLit's server shim, `textContent`, `children`, `firstChild` and\n`querySelector` are all `undefined` there, so a server has no way to see\nit. An element rendered on a server needs the attribute; one rendered in a\nbrowser may use either.",
+              "description": "The timestamp: a `Date`, milliseconds since the epoch, or a string in any\nformat `Date` can parse. The attribute is the string.\n\nAn ISO string is what an API sends and what `<time datetime>` takes, so it\nis the shape that needs no translation at either end. Left unset this\nrenders nothing rather than the epoch, which is what parsing an empty string\nwould give.\n\n**The element's own text is read as a fallback, and only in a browser.**\n`<helix-headless-format-date\nelapsed>2026-08-27T01:00:00Z</helix-headless-format-date>` is the spelling\nthat reads best in markup, and it cannot be the only one: measured against\nLit's server shim, `textContent`, `children`, `firstChild` and\n`querySelector` are all `undefined` there, so a server has no way to see\nit. An element rendered on a server needs the attribute; one rendered in a\nbrowser may use either.",
               "fieldName": "date"
             },
             {
@@ -79102,6 +79934,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -79123,7 +79999,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -79132,6 +80008,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -79614,21 +80504,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "superclass": {
@@ -83495,7 +84370,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -83935,6 +84810,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -83956,7 +84875,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -83965,6 +84884,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -84421,21 +85354,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -94271,11 +95189,32 @@
                   "text": "void"
                 }
               },
-              "description": "Scrolls the chosen option to the middle of the list.\n\nA method rather than something this does on its own, because a listbox\nopening on its answer usually wants it merely *visible* and the browser\nalready manages that: centering is what a caller wants when the list is being\nread as a dial rather than scanned as a list, which is what Time Picker's\nwheels do with three of these.\n\nMeasured by core's `centerInView`, or, for a list of `items`, by the\narithmetic, since the chosen option may not be drawn.",
+              "description": "Scrolls the chosen option to the middle of the list, or the highlighted one\nwhere nothing is chosen.\n\nA method rather than something this does on its own, because a listbox\nopening on its answer usually wants it merely *visible* and the browser\nalready manages that: centering is what a caller wants when the list is being\nread as a dial rather than scanned as a list, which is what Time Picker's\nwheels do with three of these.\n\nMeasured by core's `centerInView`, or, for a list of `items`, by the\narithmetic, since the chosen option may not be drawn.",
               "type": {
                 "text": "reveal() => void"
               }
             },
+            {
+              "kind": "method",
+              "name": "highlightValue",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "value",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "Puts the highlight on the option holding `value`, without choosing it, so\nthe arrow keys move from there. Nothing changes where no option a reader\ncan reach holds `value`.\n\nTime Picker calls it for a time between two of its steps, which no option\nholds: without it the first arrow moved from the top of the list, so Down\nfrom 14:07 went to midnight.",
+              "type": {
+                "text": "highlightValue(value: string) => void"
+              }
+            },
             {
               "kind": "method",
               "name": "place",
@@ -95013,7 +95952,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -95453,6 +96392,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -95474,7 +96457,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -95483,6 +96466,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -95965,21 +96962,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -116901,7 +117883,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -117326,6 +118308,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -117347,7 +118373,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -117356,6 +118382,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -117812,21 +118852,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -124708,6 +125733,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -124729,7 +125798,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -124738,6 +125807,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -125220,21 +126303,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -126979,7 +128047,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -127419,6 +128487,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -127440,7 +128552,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -127449,6 +128561,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -127905,21 +129031,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -132206,7 +133317,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -132646,6 +133757,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -132667,7 +133822,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -132676,6 +133831,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -133144,21 +134313,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -134919,7 +136073,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -135359,6 +136513,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -135380,7 +136578,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -135389,6 +136587,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -135871,21 +137083,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -140232,7 +141429,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -140672,6 +141869,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -140693,7 +141934,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -140702,6 +141943,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -141158,21 +142413,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -143743,7 +144983,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -144183,6 +145423,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -144204,7 +145488,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -144213,6 +145497,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -144695,21 +145993,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -153325,7 +154608,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -153765,6 +155048,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -153786,7 +155113,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -153795,6 +155122,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -154277,21 +155618,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -156374,7 +157700,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "Lays out the rows on a CSS grid, so every column lines up across rows and\neach row stays a real element that can be styled, hidden, or made\ninteractive. A `<table>` layout aligns columns but limits almost everything\nelse.\n\nA grid of elements has no table structure for assistive technology, so the\nroles are set explicitly: `table`, `row`, `cell`, `columnheader`, and\n`rowheader` for a `header` cell in a row of values. Rows are\n`display: contents`, so their cells become items of the one grid.\n\n**Sorting.** A column with `sortable` and a `field` draws its heading as a\nbutton that sorts the rows by the text of its cells, numbers by their value.\nYour markup is not reordered: the table draws the rows in the sorted order.\n\n1. Each press cycles the column through ascending, descending, and the\n   order the rows were written in, which keeps a server's own ranking\n   reachable.\n2. `helix-sort` asks first, with `field:direction`, or empty for the written\n   order. Refuse it to keep the order, or to sort the rows yourself and set\n   `sort`.\n3. `helix-sorted` follows once the order stands, and `sort` holds it.\n4. The heading carries `aria-sort`, and a screen reader hears `sorted-label`\n   (\"Sorted by Name, ascending\") or `unsorted-label` from a polite region.\n\nTab reaches each sort button, and Enter or Space presses it.\n\nThe `heading` slot names the table: slot a heading or a line of text into\nit, and the table is named by its words. An `aria-label` or `aria-labelledby` on the\nhost wins over it.\n\n**Selecting.** `selectable` adds a column of checkboxes.\n\n1. Each row is known by its `value`, or by its place among the rows where it\n   has none, and `selected` holds the chosen keys, comma separated, the same\n   shape `DataTable` uses. `default-selected` is where it starts.\n2. A row's checkbox is named by `select-row-label` (\"Select {row}\") with the\n   words of the row's first cell. The checkbox in the heading selects every\n   row, and shows a dash while only some are chosen.\n3. `helix-select` asks first, with every key the change would leave.\n   Refuse it to keep the selection. `helix-selected` follows once it stands.\n4. A chosen row takes `:state(selected)`, and a screen reader hears\n   `selected-label` (\"2 selected\") from a polite region.\n\nTab reaches each checkbox, and Space ticks it. To act on one row, put a\nlink or a button in a cell, or give the row an `href`.\n\n`selection-mode=\"single\"` selects one row at a time: ticking a row lets go\nof the one before, the heading holds no checkbox, and Shift and Control with\nA take in nothing more. `selection-behavior=\"replace\"` makes a press on a\nrow, anywhere but its own controls, select it alone, as a file list does,\nand in a `grid` table the arrow keys carry the selection with them. Control\nor Command with a press adds or takes out the row, and with an arrow moves\nwithout selecting. Shift with a press takes in the rows from the one last\nchosen.\n\n**Nesting rows.** A row with `parent` sits under the row of that key, as\na file sits in a folder. The table then draws a column of disclosure\nbuttons, under a heading named by `expand-column-label`: a row with rows\nunder it has a button named by `expand-row-label` (\"Expand {row}\") that\nsays with `aria-expanded` whether it is open, and the rows under a shut row\nare not drawn. `expanded` holds the open rows' keys, comma separated, and\n`default-expanded` is where it starts. A press asks with\n`helix-before-toggle` and tells with `helix-toggle`, both from the row, so\nyou can refuse it or load the rows on the way. A sort orders the rows\nunder each row among themselves, and in a `grid` table the table is a\n`treegrid` whose rows say their depth.\n\n**Moving rows.** `reorderable` adds a column of grips before the checkboxes,\nunder a heading named by `row-grips-label`.\n\n1. Each row is known by its `value`, or by its place among the rows where it\n   has none, as for selecting. Give rows a `value` when they move, so a key\n   stays with its row.\n2. A grip is a button named by `move-row-label` (\"Move {row}\") with the\n   words of the row's first cell. Drag it to move its row, and the page\n   scrolls near an edge. Or press it with Space, Enter, or a click to pick\n   the row up, move it with Up, Down, Home, and End, and press it again to\n   drop it. A click on another row drops it there, and Escape puts it back.\n3. `helix-before-reorder` asks first, and `helix-reorder` follows with\n   `keys`, every row's key in the new order. **You move the rows**: the\n   table moves no element of yours, and focus goes back to the moved row's\n   grip once you have.\n4. Each step is said in the table's live region, in words you can change:\n   `picked-up-label`, `moved-label`, `dropped-label`, and `canceled-label`.\n   The grips do nothing while a sort is set.\n\n**A grid.** `grid` makes the table one tab stop that the arrow keys move\nthrough cell by cell, the headings included, as React Aria's table is. The\ntable is then a `grid` and each value a `gridcell`, and the table gives\nevery cell a `tabindex` so focus can rest on it: set `grid` only where the\ncells may carry one.\n\n| Key | What it does |\n|---|---|\n| Right, Left | Moves one cell along the row. Left moves on, on a right-to-left page. |\n| Down, Up | Moves one row, the headings included. |\n| Home, End | Moves to the first or the last cell of the row. |\n| Control with Home or End | Moves to the first or the last cell of the table. |\n| Page Down, Page Up | Moves by the rows that fit in view. |\n| Enter, F2 | Moves into the cell's links and controls. Escape or F2 moves back to the cell, and Tab moves between the controls of one cell. |\n| Enter on a cell of a row with `href` | Follows the row's link. |\n| Enter, Space on a sortable heading | Sorts by the column. |\n| Space on a row, Enter or Space on its checkbox cell | Selects the row, in a `selectable` table. |\n| Enter or Space on a disclosure cell | Shows or hides the rows under the row, in a table whose rows nest. |\n| Right on a disclosure cell | Shows the rows under a shut row, and otherwise moves one cell along the row. Left does, on a right-to-left page. |\n| Left on a disclosure cell | Hides the rows under an open row, and moves to the row this one sits under from any other. |\n| Enter or Space on a grip cell | Picks the row up, or drops it, in a `reorderable` table. Up, Down, Home, and End move a row picked up, and Escape puts it back. |\n| Down, Up, Page Down, Page Up under `selection-behavior=\"replace\"` | Selects the row it moves to alone. Control or Command with the key moves without selecting. |\n| Shift with Down or Up | Selects the rows it moves across, in a `selectable` table. |\n| Shift with Space | Selects every row from the one last chosen, in a `selectable` table. |\n| Control or Command with A | Selects every row, in a `selectable` table. |\n| A letter or a word | Moves to the next row whose first cell starts with what you typed. |\n| Tab | Leaves the table. |\n\n**Loading more.** `load-more` sends `helix-load-more` once the end of the\ntable comes within a screen of view, in the box that scrolls it or the\npage, once for each number of rows: add rows and it can send it again. Set\n`loading` while you fetch, and the table asks for nothing until it clears.\n\nWhen the rows did not load, set `error-text`, such as \"The orders did not\nload\", and put a button that tries again in the `error` slot. The line shows\nafter the rows in place of the empty and loading lines, the live region says\nit, and the table takes the `error` state. Clear it once you try again.\n\nThe CSS custom properties listed for this component are written by it and\nread by the stylesheet that draws it. Do not set them. Each holds a number\nthe component computes and CSS cannot, so the stylesheet can draw the table\nwithout measuring anything.",
+          "description": "Lays out the rows on a CSS grid, so every column lines up across rows and\neach row stays a real element that can be styled, hidden, or made\ninteractive. A `<table>` layout aligns columns but limits almost everything\nelse.\n\nA grid of elements has no table structure for assistive technology, so the\nroles are set explicitly: `table`, `row`, `cell`, `columnheader`, and\n`rowheader` for a `header` cell in a row of values. Rows are\n`display: contents`, so their cells become items of the one grid.\n\n**Sorting.** A column with `sortable` and a `field` draws its heading as a\nbutton that sorts the rows by the text of its cells, numbers by their value.\nYour markup is not reordered: the table draws the rows in the sorted order.\n\n1. Each press cycles the column through ascending, descending, and the\n   order the rows were written in, which keeps a server's own ranking\n   reachable.\n2. `helix-sort` asks first, with `field:direction`, or empty for the written\n   order. Refuse it to keep the order, or to sort the rows yourself and set\n   `sort`.\n3. `helix-sorted` follows once the order stands, and `sort` holds it.\n4. The heading carries `aria-sort`, and a screen reader hears `sorted-label`\n   (\"Sorted by Name, ascending\") or `unsorted-label` from a polite region.\n\nTab reaches each sort button, and Enter or Space presses it.\n\nThe `heading` slot names the table: slot a heading or a line of text into\nit, and the table is named by its words. An `aria-label` or `aria-labelledby` on the\nhost wins over it.\nA table with no name is reported once in a development build.\n\n**Selecting.** `selectable` adds a column of checkboxes.\n\n1. Each row is known by its `value`, or by its place among the rows where it\n   has none, and `selected` holds the chosen keys, comma separated, the same\n   shape `DataTable` uses. `default-selected` is where it starts.\n2. A row's checkbox is named by `select-row-label` (\"Select {row}\") with the\n   words of the row's first cell. The checkbox in the heading selects every\n   row, and shows a dash while only some are chosen.\n3. `helix-select` asks first, with every key the change would leave.\n   Refuse it to keep the selection. `helix-selected` follows once it stands.\n4. A chosen row takes `:state(selected)`, and a screen reader hears\n   `selected-label` (\"2 selected\") from a polite region.\n\nTab reaches each checkbox, and Space ticks it. To act on one row, put a\nlink or a button in a cell, or give the row an `href`.\n\n`selection-mode=\"single\"` selects one row at a time: ticking a row lets go\nof the one before, the heading holds no checkbox, and Shift and Control with\nA take in nothing more. `selection-behavior=\"replace\"` makes a press on a\nrow, anywhere but its own controls, select it alone, as a file list does,\nand in a `grid` table the arrow keys carry the selection with them. Control\nor Command with a press adds or takes out the row, and with an arrow moves\nwithout selecting. Shift with a press takes in the rows from the one last\nchosen.\n\n**Nesting rows.** A row with `parent` sits under the row of that key, as\na file sits in a folder. The table then draws a column of disclosure\nbuttons, under a heading named by `expand-column-label`: a row with rows\nunder it has a button named by `expand-row-label` (\"Expand {row}\") that\nsays with `aria-expanded` whether it is open, and the rows under a shut row\nare not drawn. `expanded` holds the open rows' keys, comma separated, and\n`default-expanded` is where it starts. A press asks with\n`helix-before-toggle` and tells with `helix-toggle`, both from the row, so\nyou can refuse it or load the rows on the way. A sort orders the rows\nunder each row among themselves, and in a `grid` table the table is a\n`treegrid` whose rows say their depth.\n\n**Moving rows.** `reorderable` adds a column of grips before the checkboxes,\nunder a heading named by `row-grips-label`.\n\n1. Each row is known by its `value`, or by its place among the rows where it\n   has none, as for selecting. Give rows a `value` when they move, so a key\n   stays with its row.\n2. A grip is a button named by `move-row-label` (\"Move {row}\") with the\n   words of the row's first cell. Drag it to move its row, and the page\n   scrolls near an edge. Or press it with Space, Enter, or a click to pick\n   the row up, move it with Up, Down, Home, and End, and press it again to\n   drop it. A click on another row drops it there, and Escape puts it back.\n3. `helix-before-reorder` asks first, and `helix-reorder` follows with\n   `keys`, every row's key in the new order. **You move the rows**: the\n   table moves no element of yours, and focus goes back to the moved row's\n   grip once you have.\n4. Each step is said in the table's live region, in words you can change:\n   `picked-up-label`, `moved-label`, `dropped-label`, and `canceled-label`.\n   The grips do nothing while a sort is set.\n\n**A grid.** `grid` makes the table one tab stop that the arrow keys move\nthrough cell by cell, the headings included, as React Aria's table is. The\ntable is then a `grid` and each value a `gridcell`, and the table gives\nevery cell a `tabindex` so focus can rest on it: set `grid` only where the\ncells may carry one.\n\n| Key | What it does |\n|---|---|\n| Right, Left | Moves one cell along the row. Left moves on, on a right-to-left page. |\n| Down, Up | Moves one row, the headings included. |\n| Home, End | Moves to the first or the last cell of the row. |\n| Control with Home or End | Moves to the first or the last cell of the table. |\n| Page Down, Page Up | Moves by the rows that fit in view. |\n| Enter, F2 | Moves into the cell's links and controls. Escape or F2 moves back to the cell, and Tab moves between the controls of one cell. |\n| Enter on a cell of a row with `href` | Follows the row's link. |\n| Enter, Space on a sortable heading | Sorts by the column. |\n| Space on a row, Enter or Space on its checkbox cell | Selects the row, in a `selectable` table. |\n| Enter or Space on a disclosure cell | Shows or hides the rows under the row, in a table whose rows nest. |\n| Right on a disclosure cell | Shows the rows under a shut row, and otherwise moves one cell along the row. Left does, on a right-to-left page. |\n| Left on a disclosure cell | Hides the rows under an open row, and moves to the row this one sits under from any other. |\n| Enter or Space on a grip cell | Picks the row up, or drops it, in a `reorderable` table. Up, Down, Home, and End move a row picked up, and Escape puts it back. |\n| Down, Up, Page Down, Page Up under `selection-behavior=\"replace\"` | Selects the row it moves to alone. Control or Command with the key moves without selecting. |\n| Shift with Down or Up | Selects the rows it moves across, in a `selectable` table. |\n| Shift with Space | Selects every row from the one last chosen, in a `selectable` table. |\n| Control or Command with A | Selects every row, in a `selectable` table. |\n| A letter or a word | Moves to the next row whose first cell starts with what you typed. |\n| Tab | Leaves the table. |\n\n**Long tables.** `windowed` draws only the rows in view, as Data Table's\ndoes, and the box of the table scrolls under headings that stick. The\ntable still says how many rows it has with `aria-rowcount`, and each row\nits place with `aria-rowindex`. The keys reach every row, drawn or not, and\nthe row holding focus stays drawn when it scrolls away. Nested rows,\nsorting, and selecting work as they do in a table that draws every row.\n\n**Loading more.** `load-more` sends `helix-load-more` once the end of the\ntable comes within a screen of view, in the box that scrolls it or the\npage, or in the table's own box when it is `windowed`, once for each\nnumber of rows: add rows and it can send it again. Set\n`loading` while you fetch, and the table asks for nothing until it clears.\n\nWhen the rows did not load, set `error-text`, such as \"The orders did not\nload\", and put a button that tries again in the `error` slot. The line shows\nafter the rows in place of the empty and loading lines, the live region says\nit, and the table takes the `error` state. Clear it once you try again.\n\nThe CSS custom properties listed for this component are written by it and\nread by the stylesheet that draws it. Do not set them. Each holds a number\nthe component computes and CSS cannot, so the stylesheet can draw the table\nwithout measuring anything.",
           "name": "HelixHeadlessTable",
           "cssProperties": [
             {
@@ -156383,6 +157709,14 @@
             }
           ],
           "cssParts": [
+            {
+              "description": "The space that stands in for the rows below the window. Only while `windowed`.",
+              "name": "after"
+            },
+            {
+              "description": "The space that stands in for the rows above the window. Only while `windowed`.",
+              "name": "before"
+            },
             {
               "description": "The checkbox in the heading that selects every row, in a `selectable` table.",
               "name": "checkbox"
@@ -156894,6 +158228,17 @@
                 "words": true
               }
             },
+            {
+              "kind": "field",
+              "name": "windowed",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Draws only the rows in view, with empty space in place of the rest, as\nData Table's `windowed` does. The table's box then scrolls, at the\nheight `--table-block-size` gives it in the styled tier, and the\nheadings stick to its top.\n\nOff by default. Windowing costs a scroll listener, a measurement per row\ndrawn, and a height on the table, and a table of twenty rows should pay\nnone of them.",
+              "attribute": "windowed",
+              "reflects": true
+            },
             {
               "kind": "field",
               "name": "sortState",
@@ -156931,6 +158276,40 @@
               "description": "Whether any row sits under another, which makes the table a tree.",
               "readonly": true
             },
+            {
+              "kind": "field",
+              "name": "memo",
+              "type": {
+                "text": "{ arranged?: Element[]; keyed?: { key: string; row: Row }[]; nests?: boolean }"
+              },
+              "privacy": "private",
+              "default": "{}",
+              "description": "What the table read from its rows, kept until anything asks for an\nupdate or the turn ends.\n\n**Read once rather than on every question.** A render, the assignment\nand the keyboard each asked for the rows in order dozens of times, and\neach answer walked every row: in Chromium a windowed table of 3,000 rows\ntook 89 milliseconds to move its window, 42 of them reading the keys."
+            },
+            {
+              "kind": "method",
+              "name": "remember",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "NonNullable<HelixHeadlessTable['memo'][K]>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "key",
+                  "type": {
+                    "text": "K"
+                  }
+                },
+                {
+                  "name": "compute",
+                  "type": {
+                    "text": "() => NonNullable<HelixHeadlessTable['memo'][K]>"
+                  }
+                }
+              ]
+            },
             {
               "kind": "field",
               "name": "open",
@@ -156983,9 +158362,119 @@
               "name": "gridKeys",
               "privacy": "private",
               "readonly": true,
-              "default": "new TableGridController(this, { activate: (place, event) => this.activate(place, event), arrive: (to, control) => { if (this.replaces && !control) { this.chooseOnly(to) } }, columns: () => this.tableColumns.filter((column) => column.shown), disclose: (at, forward) => this.disclose(at, forward), lead: () => this.lead, on: () => this.grid, part: (name) => this.partNamed(name), rows: () => (this.childrenKnown ? this.arrangedRows : []), rowWords: () => this.arrangedRows.map((row) => textOf(row.children[0])), selectAll: () => this.selectable && !this.single && this.requestSelected(new Set([...this.chosen, ...this.enabledKeys])), selectRange: (to, from) => this.selectRange(to, from), })",
+              "default": "new TableGridController(this, { activate: (place, event) => this.activate(place, event), arrive: (to, control) => { if (this.replaces && !control) { this.chooseOnly(to) } }, columns: () => this.tableColumns.filter((column) => column.shown), disclose: (at, forward) => this.disclose(at, forward), drawn: () => (this.windowed ? new Set(this.drawnRows) : undefined), lead: () => this.lead, on: () => this.grid, part: (name) => this.partNamed(name), reveal: (row) => this.revealRow(row), rows: () => (this.childrenKnown ? this.arrangedRows : []), rowWords: () => this.arrangedRows.map((row) => textOf(row.children[0])), selectAll: () => this.selectable && !this.single && this.requestSelected(new Set([...this.chosen, ...this.enabledKeys])), selectRange: (to, from) => this.selectRange(to, from), })",
               "description": "The keyboard of a `grid` table, in `grid-controller.ts`."
             },
+            {
+              "kind": "field",
+              "name": "virtualize",
+              "privacy": "private",
+              "readonly": true,
+              "default": "new VirtualizeController(this, { container: () => (this.windowed ? this.partNamed('table') : null), count: () => this.arrangedCount, estimate: () => ESTIMATE, measured: () => this.windowed, rows: () => (this.windowed ? this.measuredRows() : []), })",
+              "description": "The slice of a long table that is drawn, under `windowed`. The rows are\nthe page's elements, so the window is which of them the body slot is\ngiven: a row it is not given is not laid out and not in the\naccessibility tree."
+            },
+            {
+              "kind": "field",
+              "name": "arrangedCount",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "default": "0",
+              "description": "How many rows are drawn in order, read when the rows are assigned."
+            },
+            {
+              "kind": "field",
+              "name": "hasRows",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "readonly": true,
+              "description": "A `windowed` table has rows while it holds any, drawn or not.",
+              "inheritedFrom": {
+                "name": "MixinCollection",
+                "module": "src/mixins/mixin-collection/mixin-collection.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "drawnRows",
+              "type": {
+                "text": "Element[]"
+              },
+              "privacy": "private",
+              "default": "[]",
+              "description": "The rows the body slot was last given, under `windowed`."
+            },
+            {
+              "kind": "method",
+              "name": "measuredRows",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "{ element: HTMLElement; index: number }[]"
+                }
+              },
+              "description": "The rows drawn now, each by its first cell, with its place among the\nrows. A row is `display: contents` and has no box, and a cell is a grid\nitem stretched to its row, as Data Table measures its rows."
+            },
+            {
+              "kind": "method",
+              "name": "keptRow",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "number | undefined"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "rows",
+                  "type": {
+                    "text": "Element[]"
+                  }
+                }
+              ],
+              "description": "The row outside the window that stays drawn: the grid's stop, or the row holding focus."
+            },
+            {
+              "kind": "method",
+              "name": "windowOf",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "Element[]"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "rows",
+                  "type": {
+                    "text": "Element[]"
+                  }
+                }
+              ],
+              "description": "The rows to draw under `windowed`: the window, and the row kept for\nfocus beside it on its side."
+            },
+            {
+              "kind": "method",
+              "name": "revealRow",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "row",
+                  "type": {
+                    "text": "number"
+                  }
+                }
+              ],
+              "description": "Scrolls drawn row `row` into view below the headings, and moves the\nwindow to it, before a key focuses it."
+            },
             {
               "kind": "field",
               "name": "reorder",
@@ -157092,6 +158581,17 @@
               "description": "The rows in the order they are drawn: sorted by `sort`, and as written\nwhere there is no sort.\n\n**Drawn in order by assignment.** A manually assigned slot draws its nodes\nin the order they were assigned, so the rows move on screen and in the\naccessibility tree while the consumer's markup stays as it was written,\nwhich is what a framework holding those rows needs.",
               "readonly": true
             },
+            {
+              "kind": "method",
+              "name": "arrange",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "Element[]"
+                }
+              },
+              "description": "The rows in the order they are drawn, worked out again."
+            },
             {
               "kind": "method",
               "name": "nested",
@@ -157663,6 +159163,13 @@
               },
               "description": "Starts or stops watching the end of the table, against the box that\nscrolls it, or the page, with a screen of room below it, so the next rows\nare asked for before a reader reaches the last. List does the same."
             },
+            {
+              "kind": "field",
+              "name": "nearEnd",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Asks for more once a reader of a `windowed` table is within a screen of its end."
+            },
             {
               "kind": "field",
               "name": "endInView",
@@ -157817,19 +159324,6 @@
                 "module": "src/mixins/mixin-collection/mixin-collection.ts"
               }
             },
-            {
-              "kind": "field",
-              "name": "hasRows",
-              "type": {
-                "text": "boolean"
-              },
-              "privacy": "protected",
-              "readonly": true,
-              "inheritedFrom": {
-                "name": "MixinCollection",
-                "module": "src/mixins/mixin-collection/mixin-collection.ts"
-              }
-            },
             {
               "kind": "method",
               "name": "renderStatus",
@@ -158596,6 +160090,15 @@
               "description": "What screen readers hear when the table stops being sorted.",
               "fieldName": "unsortedLabel"
             },
+            {
+              "name": "windowed",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Draws only the rows in view, with empty space in place of the rest, as\nData Table's `windowed` does. The table's box then scrolls, at the\nheight `--table-block-size` gives it in the styled tier, and the\nheadings stick to its top.\n\nOff by default. Windowing costs a scroll listener, a measurement per row\ndrawn, and a height on the table, and a table of twenty rows should pay\nnone of them.",
+              "fieldName": "windowed"
+            },
             {
               "name": "empty-text",
               "type": {
@@ -158887,6 +160390,17 @@
               "default": "undefined",
               "description": "The table's rules this row holds, so the next ones replace them rather than pile up."
             },
+            {
+              "kind": "method",
+              "name": "nameByHeader",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Names the row by its header cell, the cell with `header` among cells of\nvalues, or by its first cell where it has none, as React Aria's rows are\nnamed.\n\n**Named from its contents, a row read out its checkbox's name too**, \"Select\n412 412 main Passed\" in a `selectable` table, since the checkbox is a cell of\nthe row's own. Not on a server, which has no cells to point at, and not\nwhere a page named the row itself."
+            },
             {
               "kind": "field",
               "name": "handleClick",
@@ -164511,7 +166025,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -164951,6 +166465,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -164972,7 +166530,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -164981,6 +166539,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -165437,21 +167009,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -165830,7 +167387,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "The list is a `TimePicker`, which you can also use on its own, for example in\na settings pane. This element adds the field, the overlay, and the form\nassociation, the same arrangement Date Input has with `DatePicker` and Color\nInput has with `ColorPicker`.\n\nYou can type a time or pick one. The list offers times at a step, and the\nfield lets you enter any time, such as `09:07`.\n\nThe value is always `HH:mm` on a 24-hour clock, or `HH:mm:ss` with\n`seconds`, because that is what the form\nsubmits, what `min` and `max` compare against, and what sorts correctly as a\nstring. While idle, the field shows the time in the user's locale format.\nOnce the caret is in the field, it shows the value itself. You can type\n`14:30`, or a time as you write one, such as `2:30 PM`, `2.30pm`, or\n`14h30`, and the field reads it as you leave it, with AM and PM in the\nlocale's words.\n\nTyping sends `input` on each keystroke and `change` when you leave the\nfield. The trigger and ArrowDown open the list, and so does a press into the\nfield; Tab into the field opens nothing. The text field is a `combobox`\nwith `aria-haspopup=\"dialog\"`, `aria-expanded`, and `aria-controls`, since\nDown opens the list from it. In the list, the arrow keys, typed digits and PageUp and PageDown\nmove through the times, and Enter, Space or a click chooses one and closes\nthe panel. With `variant=\"wheels\"` each wheel moves the time as you turn it,\nthe panel stays open, and Enter or Escape closes it.\n\nWith `segmented`, the field is a row of segments in place of the text: an\nhour, a minute, and AM or PM where the clock has them, each set with digits\nor the arrow keys. Alt+Down opens the list from a segment. A `range` is two\nrows with a dash between them, the start and the end, and `multiple` keeps\nthe text.\n\nText that is not a time gives the form an empty value, as a native time\nfield does, and `value` keeps the text so it can be corrected.\n\n**Keyboard.** The field is one tab stop, or each segment is with\n`segmented`, and the trigger is one more.\n\n| Key | What it does |\n|---|---|\n| Down | In the text field, opens the list on the chosen time. |\n| Alt with Down | Opens the list, from the text field or a segment. |\n| Enter | In the text field, takes the typed time and submits the form, as a native field does. In the list, chooses the highlighted time. |\n| Escape | Closes the list and puts focus back in the field. |\n| Up, Down on a segment | Steps the segment by one, round from its last value to its first. |\n| Page Up, Page Down on a segment | Steps by a page: two hours, or fifteen minutes or seconds. |\n| Home, End on a segment | Goes to the segment's first or last value. |\n| Digits on a segment | Fill it, and move to the next once it can take no more. |\n| A letter on the half of the day | Picks the half whose name starts with it, such as A for AM. |\n| Backspace, Delete on a segment | Empty the segment. |\n| Left, Right on a segment | Move to the previous or the next segment, along the line of text. |\n\nIn the list, the keys are `TimePicker`'s.",
+          "description": "The list is a `TimePicker`, which you can also use on its own, for example in\na settings pane. This element adds the field, the overlay, and the form\nassociation, the same arrangement Date Input has with `DatePicker` and Color\nInput has with `ColorPicker`.\n\nYou can type a time or pick one. The list offers times at a step, and the\nfield lets you enter any time, such as `09:07`.\n\nThe value is always `HH:mm` on a 24-hour clock, or `HH:mm:ss` with\n`seconds`, because that is what the form\nsubmits, what `min` and `max` compare against, and what sorts correctly as a\nstring. While idle, the field shows the time in the user's locale format.\nOnce the caret is in the field, it shows the value itself. You can type\n`14:30`, or a time as you write one, such as `2:30 PM`, `2.30pm`, or\n`14h30`, and the field reads it as you leave it, with AM and PM in the\nlocale's words.\n\nTyping sends `input` on each keystroke and `change` when you leave the\nfield. The trigger and ArrowDown open the list, and so does a press into the\nfield; Tab into the field opens nothing. The text field is a `combobox`\nwith `aria-haspopup=\"dialog\"`, `aria-expanded`, and `aria-controls`, since\nDown opens the list from it. In the list, the arrow keys, typed digits and PageUp and PageDown\nmove through the times, and Enter, Space or a click chooses one and closes\nthe panel. With `variant=\"wheels\"` each wheel moves the time as you turn it,\nthe panel stays open, and Enter or Escape closes it.\n\nWith `segmented`, the field is a row of segments in place of the text: an\nhour, a minute, and AM or PM where the clock has them, each set with digits\nor the arrow keys. Alt+Down opens the list from a segment. A `range` is two\nrows with a dash between them, the start and the end, and `multiple` keeps\nthe text.\n\nText that is not a time gives the form an empty value, as a native time\nfield does, and `value` keeps the text so it can be corrected.\n\n**Keyboard.** The field is one tab stop, or each segment is with\n`segmented`, and the trigger is one more.\n\n| Key | What it does |\n|---|---|\n| Down | In the text field, opens the list on the chosen time. |\n| Alt with Down | Opens the list, from the text field or a segment. |\n| Enter | In the text field, takes the typed time and submits the form, as a native field does. In the list, chooses the highlighted time. |\n| Escape | Closes the list and puts focus back in the field. |\n| Up, Down on a segment | Steps the segment by one, round from its last value to its first. |\n| Page Up, Page Down on a segment | Steps by a page: two hours, or fifteen minutes or seconds. |\n| Home, End on a segment | Goes to the segment's first or last value. |\n| Digits on a segment | Fill it, and move to the next once it can take no more. |\n| A letter on the half of the day | Picks the half whose name starts with it, such as A for AM. |\n| Backspace, Delete on a segment | Take off its last digit, or move to the segment before where it is empty. |\n| Left, Right on a segment | Move to the previous or the next segment, along the line of text. |\n\nIn the list, the keys are `TimePicker`'s.",
           "name": "HelixHeadlessTimeInput",
           "cssParts": [
             {
@@ -165985,6 +167542,10 @@
               "description": "The filter field.",
               "name": "picker-list-search-field"
             },
+            {
+              "description": "The picker's button that chooses the current time, which Time Input does not draw.",
+              "name": "picker-now"
+            },
             {
               "description": "One time in the picker. Carries `data-between` inside a range.",
               "name": "picker-option"
@@ -167169,6 +168730,29 @@
                 "module": "src/mixins/mixin-segmented-field/mixin-segmented-field.ts"
               }
             },
+            {
+              "kind": "method",
+              "name": "erase",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "element",
+                  "type": {
+                    "text": "HTMLElement"
+                  }
+                }
+              ],
+              "description": "Takes the last digit off the segment, or moves to the segment before it\nwhere this one is already empty, as React Aria's segments do. A reader\nclearing a date from its end holds Backspace and it empties right to\nleft.",
+              "inheritedFrom": {
+                "name": "MixinSegmentedField",
+                "module": "src/mixins/mixin-segmented-field/mixin-segmented-field.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "composing",
@@ -168316,7 +169900,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -168756,6 +170340,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -168777,7 +170405,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -168786,6 +170414,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -169242,21 +170884,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -169957,7 +171584,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "Shows the times at each `step` as a `Listbox`, which provides the keyboard\nbehavior, typeahead, scrolling into view, and announcements for a set of\noptions. `variant=\"wheels\"` shows a column each for the hour, the minute, and\nthe meridiem, and one for the second with `seconds`. Left and Right move\nbetween the wheels, and Tab does too.\n\n`hour-cycle` writes every time on a twelve or a twenty-four hour clock\nwhatever the locale, and `seconds` holds times to the second.\n\nThe step keeps the list usable. At the default of 15 minutes a day is 96\nrows, which people can scroll or type into. At 1 minute it is 1,440. Use the\nlist for the times your product offers, and Time Input for any time, the same\nway Date Input separates typing a date from picking one on the calendar.\n\nThe value is always `HH:mm` on a 24-hour clock, or `HH:mm:ss` with\n`seconds`. A form submits that shape,\n`min` and `max` compare against it, and it sorts as a string. Each row's text\nfollows the person's own conventions, from `Intl`.\n\nThe chosen row is marked in the served markup. The listbox gets the answer as\n`.value`, and Lit SSR serializes no property binding, so without more the 96\nserved rows would carry no mark until the listbox upgrades and runs `place`.\nEach option also gets `selected`, an attribute binding that does serialize,\nand `place` then writes the same answer from the same value. This is the same\n`selected` you write on `Option` elsewhere in Helix, and Date Picker marks\nits choice in markup for the same reason. The list and the wheels both do\nthis, because each wheel is also a listbox.\n\n**Keyboard.** The list is one tab stop, and each wheel is one.\n\n| Key | What it does |\n|---|---|\n| Down, Up | Moves to the next or the previous time, or in a wheel to the next or the previous hour, minute, second, or half of the day. |\n| Home, End | Moves to the first or the last time, or the first or the last in a wheel. |\n| Page Down, Page Up | Moves by as many times as the list shows at once. |\n| Digits | Moves to the next time that starts with what you typed, such as `9` for 9:00. |\n| Enter, Space | Chooses the highlighted time. Moving chooses too, except under `manual` or with a `mode`. With a `mode`, Space adds or removes the time. |\n| Right, Left | In the wheels, moves to the next or the previous wheel, mirrored right to left. |\n| Tab | Moves to the next wheel, then out of the picker. |\n\n**ARIA.** The list is a `listbox` named by `label`, a slotted label, the\nhost's `aria-label` or its `aria-labelledby`. A development build warns\nwhere all four are empty. The list is described by the hint, or by the\nmessage in `feedback` in its place, and carries `aria-multiselectable` with\na `mode`. It carries `aria-invalid` while `feedback` says what is wrong,\nwhile it holds a time outside `min` and `max` or one the picker does not\noffer, and, for a `required` picker with no time, once the reader has\nchosen one or a form has refused the picker. The wheels\nare a `group` with that name, holding one `listbox` per wheel, named \"Hour\",\n\"Minute\", \"Second\" and \"AM/PM\" in the page's language, and each described\nthe same way.",
+          "description": "Shows the times at each `step` as a `Listbox`, which provides the keyboard\nbehavior, typeahead, scrolling into view, and announcements for a set of\noptions. `variant=\"wheels\"` shows a column each for the hour, the minute, and\nthe meridiem, and one for the second with `seconds`. Left and Right move\nbetween the wheels, and Tab does too.\n\n`hour-cycle` writes every time on a twelve or a twenty-four hour clock\nwhatever the locale, and `seconds` holds times to the second. `show-now`\ndraws a button that chooses the current time, on the step and inside the\nbounds.\n\nThe step keeps the list usable. At the default of 15 minutes a day is 96\nrows, which people can scroll or type into. At 1 minute it is 1,440. Use the\nlist for the times your product offers, and Time Input for any time, the same\nway Date Input separates typing a date from picking one on the calendar.\n\nThe value is always `HH:mm` on a 24-hour clock, or `HH:mm:ss` with\n`seconds`. A form submits that shape,\n`min` and `max` compare against it, and it sorts as a string. Each row's text\nfollows the person's own conventions, from `Intl`.\n\nThe chosen row is marked in the served markup. The listbox gets the answer as\n`.value`, and Lit SSR serializes no property binding, so without more the 96\nserved rows would carry no mark until the listbox upgrades and runs `place`.\nEach option also gets `selected`, an attribute binding that does serialize,\nand `place` then writes the same answer from the same value. This is the same\n`selected` you write on `Option` elsewhere in Helix, and Date Picker marks\nits choice in markup for the same reason. The list and the wheels both do\nthis, because each wheel is also a listbox.\n\n**Keyboard.** The list is one tab stop, and each wheel is one.\n\n| Key | What it does |\n|---|---|\n| Down, Up | Moves to the next or the previous time, or in a wheel to the next or the previous hour, minute, second, or half of the day. |\n| Home, End | Moves to the first or the last time, or the first or the last in a wheel. |\n| Page Down, Page Up | Moves by as many times as the list shows at once. |\n| Digits | Moves to the next time that starts with what you typed, such as `9` for 9:00. |\n| Enter, Space | Chooses the highlighted time. Moving chooses too, except under `manual` or with a `mode`. With a `mode`, Space adds or removes the time. |\n| Right, Left | In the wheels, moves to the next or the previous wheel, mirrored right to left. |\n| Tab | Moves to the next wheel, then out of the picker. |\n\n**ARIA.** The list is a `listbox` named by `label`, a slotted label, the\nhost's `aria-label` or its `aria-labelledby`. A development build warns\nwhere all four are empty. The list is described by the hint, or by the\nmessage in `feedback` in its place, and carries `aria-multiselectable` with\na `mode`. It carries `aria-invalid` while `feedback` says what is wrong,\nwhile it holds a time outside `min` and `max` or one the picker does not\noffer, and, for a `required` picker with no time, once the reader has\nchosen one or a form has refused the picker. The wheels\nare a `group` with that name, holding one `listbox` per wheel, named \"Hour\",\n\"Minute\", \"Second\" and \"AM/PM\" in the page's language, and each described\nthe same way.",
           "name": "HelixHeadlessTimePicker",
           "cssParts": [
             {
@@ -170080,6 +171707,10 @@
               "description": "The filter field.",
               "name": "list-search-field"
             },
+            {
+              "description": "The button that chooses the current time, drawn with `show-now`.",
+              "name": "now"
+            },
             {
               "description": "One time in the list. It carries `data-between` inside a range, and inside the run to the time under the pointer while a range waits for its second end.",
               "name": "option"
@@ -170293,6 +171924,19 @@
               "attribute": "mode",
               "reflects": true
             },
+            {
+              "kind": "field",
+              "name": "nowLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Now'",
+              "description": "The words on the button that chooses the current time, drawn with\n`show-now`.",
+              "attribute": "now-label",
+              "helix": {
+                "words": true
+              }
+            },
             {
               "kind": "field",
               "name": "rangeOverflowMessage",
@@ -170484,6 +172128,72 @@
               "readonly": true,
               "description": "Takes what the list announced and constrains it to what the mode allows.\n\nThe listbox is put in `multiple` for both modes, because that is what marks\nmore than one row and toggles on press. A range then differs only in what is\nkept: two, and a third pick starts again from that third one. Working out\nwhich is newest by difference rather than by position, since a toggle can\nremove as easily as add and the announced list is a set rather than a\nsequence."
             },
+            {
+              "kind": "method",
+              "name": "choose",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "announced",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "Requests the times a pick announced, kept to what the mode allows, and\nreturns whether the value changed."
+            },
+            {
+              "kind": "method",
+              "name": "selectNow",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "description": "Chooses the current time, as a press on the `show-now` button does, and\nreturns whether the value changed.\n\nThe time is read off the reader's clock and moved to the nearest time on\noffer that is not barred, so it falls on the `step` and inside `min` and\n`max`. It is requested as a pick is, so `helix-before-change` can cancel\nit. With a `mode` the time joins the times held, and a range that holds\ntwo starts over from it, as a third pick does.",
+              "type": {
+                "text": "selectNow() => boolean"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "highlightNearest",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Puts the list's highlight on the offered time nearest one held between two\nsteps, so the arrows move from there.\n\nNo row holds `14:07` at a step of 15, so the list had nothing to move\nfrom: Down went to the top of the list, and in a list that chooses as it\nmoves, the value became 00:00. Down now goes to 14:15."
+            },
+            {
+              "kind": "field",
+              "name": "handleListFocus",
+              "privacy": "private",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "handleNow",
+              "privacy": "private",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "renderNow",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "TemplateResult | typeof nothing"
+                }
+              },
+              "description": "The button that chooses the current time, drawn with `show-now`."
+            },
             {
               "kind": "field",
               "name": "previewed",
@@ -170651,6 +172361,16 @@
               "description": "Whether times carry their seconds.\n\nThe value becomes `HH:mm:ss`, each time is written with its seconds, the\nwheels take a column of seconds, and `step` counts seconds, the unit\n`<input type=\"time\">` counts in. A list at a step of one second is 86,400\nrows, so give `seconds` a `step` and bounds that keep it a list, or use\nthe wheels.",
               "attribute": "seconds"
             },
+            {
+              "kind": "field",
+              "name": "showNow",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Draws a button under the times that chooses the current time, as\n`selectNow()` does.\n\nFor a form about something happening now, such as a shift starting or a\ndose taken, where the reader would otherwise scroll to the time on the\nclock. The button is a tab stop after the times, and its words are\n`now-label`.",
+              "attribute": "show-now"
+            },
             {
               "kind": "field",
               "name": "step",
@@ -171462,6 +173182,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -171483,7 +173247,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -171492,6 +173256,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -171948,21 +173726,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -172113,6 +173876,15 @@
               "description": "How many times can be held at once.\n\nAbsent is one. `range` holds a start and an end with everything between\nthem shown as part of the answer, `multiple` holds any number, and both are\ncarried as one comma-separated value: the same shape `DatePicker` uses,\nbecause it is the same question asked of a different unit.\n\n**A range is two picks, and a third starts over.** That is the calendar's\nbehavior and a reader who has met one has met both. The alternative, a\nseparate \"from\" and \"to\" control, is two answers to what a product asks as\none, and it makes the between part impossible to show.\n\n**Neither works on wheels and the variant falls back.** A range on\nwheels is two sets of wheels, which is two controls; a multiple is a set,\nand a wheel has exactly one value by construction. Rather than draw\nsomething that cannot say what it holds, `wheels` renders as a list\nwhenever a mode is set.",
               "fieldName": "mode"
             },
+            {
+              "name": "now-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Now'",
+              "description": "The words on the button that chooses the current time, drawn with\n`show-now`.",
+              "fieldName": "nowLabel"
+            },
             {
               "name": "range-overflow-message",
               "type": {
@@ -172166,6 +173938,15 @@
               "description": "Whether times carry their seconds.\n\nThe value becomes `HH:mm:ss`, each time is written with its seconds, the\nwheels take a column of seconds, and `step` counts seconds, the unit\n`<input type=\"time\">` counts in. A list at a step of one second is 86,400\nrows, so give `seconds` a `step` and bounds that keep it a list, or use\nthe wheels.",
               "fieldName": "seconds"
             },
+            {
+              "name": "show-now",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Draws a button under the times that chooses the current time, as\n`selectNow()` does.\n\nFor a form about something happening now, such as a shift starting or a\ndose taken, where the reader would otherwise scroll to the time on the\nclock. The button is a tab stop after the times, and its words are\n`now-label`.",
+              "fieldName": "showNow"
+            },
             {
               "name": "step",
               "type": {
@@ -176638,7 +178419,7 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
+              "description": "Whether the reader has had a go at the field yet.\n\n**Not `:user-invalid`**, which is the platform's own answer to \"is this\nfield wrong *yet*\" and cannot work here, for a structural reason rather\nthan a browser bug: it tracks interaction with the element it is on, and\nnobody interacts with this element. The reader types into an `<input>`\ninside its shadow root, so the host's interaction flag is never set and\nthe selector never matches. Measured after submitting an invalid required\nfield and again after editing one and leaving it: false both times, while\n`:invalid` matched both times.\n\nSo the moments are listened for instead, and both of them demonstrably\nreach the host: `invalid` when a form is submitted with this control\nfailing, and `change` when the reader has edited and committed. The\n`invalid` a script's `checkValidity()` fires is not one of them, as it\nis not for a native control. Focus\nalone is deliberately not one of them. Tabbing past an empty required\nfield should not be answered with an error.\n\n**A composite control has to construct its own `change`, and this mixin\ndeliberately does not do it for them.** A native `change` is\n`composed: false`, so a control built from several inner inputs never\nrelays one to its host: `Input` gets this free from its one control,\nwhile a `PinInput` of four boxes has no inner `change` that means the\ncode is entered, so a half-entered code is never `touched` and can never\nsay what is wrong with it.\n\n**The obvious shared fix is for `touched` to take a `focusout`, and it is\nthe wrong one**, because it is the paragraph above undone: a `focusout`\nfires on the reader who tabbed past and typed nothing, which is exactly\nthe case this refuses to call an error. What a composite needs is not a\nfocus moment, it is the native meaning of `change`, \"edited, then left\",\nand the editing half is the part a mixin up here cannot see.\n\n**Nor is there one shape to extract yet.** The two composites solve it\ndifferently and both are right: `PinInput` is focus-driven, taking a\nbaseline when focus arrives from outside the row and announcing on the\nway out if it moved, and `DateInput` is value-driven, stopping its inner\n`change` and announcing once the date itself moves. Only one of them has\na leaving moment at all, so generalizing from the pair is generalizing\nfrom one. The trigger for lifting it is a third control that needs the\nfocus-driven shape, at which point what moves up is the\nbaseline-and-commit pair rather than `touched`.",
               "inheritedFrom": {
                 "name": "MixinField",
                 "module": "src/mixins/mixin-field/mixin-field.ts"
@@ -177078,6 +178859,50 @@
                 "module": "src/helix-form-element/helix-form-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "willValidate",
@@ -177099,7 +178924,7 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot.",
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
               "inheritedFrom": {
                 "name": "HelixFormElement",
                 "module": "src/helix-form-element/helix-form-element.ts"
@@ -177108,6 +178933,20 @@
                 "text": "checkValidity() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires.",
+              "inheritedFrom": {
+                "name": "HelixFormElement",
+                "module": "src/helix-form-element/helix-form-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "reportValidity",
@@ -177576,21 +179415,6 @@
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
               }
-            },
-            {
-              "kind": "method",
-              "name": "performUpdate",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
-              "inheritedFrom": {
-                "name": "HelixElement",
-                "module": "src/helix-element/helix-element.ts"
-              }
             }
           ],
           "events": [
@@ -192618,7 +194442,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "The items arrive as data, in one of two ways:\n\n- `items` takes an array. A framework sets it as a property, and React\n  hydration keeps it.\n- `for` names a `<script type=\"application/json\">` that holds an array, which\n  a server sends as markup.\n\nEach item is drawn into a row in one of two ways:\n\n- `renderItem` is a function from an item and its index to the row's\n  content: a Lit template, a string, or a DOM node.\n- A `<template>` child defines one row. `data-field=\"name\"` fills an element\n  with the item's `name` as text, and `data-field-href=\"url\"` writes the\n  item's `url` into `href`, the same for any attribute. A field may be a path\n  of keys, such as `author.name`.\n\nRows are your markup in the light DOM, so your stylesheet styles them.\n\n**A grid.** `columns` lays the items out that many to a line, as a grid of\nequal columns, and windows the set a line at a time, as React Aria's grid\nlayout does. Each item draws one element, a cell of the grid, and\n`estimate` is the height of a line. `min-column-width` lays out as many\ncolumns as fit the box instead, as React Aria's grid layout does with its\nsmallest item size, and follows the box as it resizes. `gap` spaces the rows, and the columns\nof a grid, by a number of pixels the list counts in each row's place.\n\n**Keyboard.** The list is one tab stop.\n\n| Key | What it does |\n|---|---|\n| Down, Up | Moves to the next or the previous item, or in a grid to the item in the same column on the next or the previous line. |\n| Right, Left | In a grid, moves to the next or the previous item along the line, the other way round on a right-to-left page. |\n| Home, End | Moves to the first or the last item. |\n| Page Down, Page Up | Moves by the number of items, or of lines in a grid, on screen. |\n| A letter or a word | Moves to the next item whose text starts with what you typed. |\n| Escape | Lets go of every chosen item, in a list with `selection-mode`. |\n| Tab | Moves into the focused row's own links and buttons, then out of the list. |\n\nAn item that is not drawn is scrolled into view and focused, so a keyboard\nreaches the whole set. When the row holding the tab stop scrolls away, the\nstop moves to the first row on screen. Typing matches each item's\n`text-field`, which is the first `data-field` of the row template by default,\nor the item itself when it is a string or a number.\n\nEach row says its place in the whole set with `aria-posinset` and\n`aria-setsize`, so a screen reader says \"4,000 of 10,000\". The row holding\nfocus stays drawn when it scrolls out.\n\n**Selecting.** `selection-mode` makes the list a list box a reader chooses\nfrom: `single` selects one item and `multiple` any number. Space or a press\nselects an item, Shift with Space, an arrow, Home, End or a press takes in\nthe items from the last one chosen, and Control or Command with A selects\nthem all, in `multiple`. Escape lets go of every chosen item, and keeps the\nkey from the dialog or menu around the list while there was something to\nlet go of. `value` holds the chosen items' keys, separated by commas, in\nthe order of the set: `key-field` names each item's key, and a string or a\nnumber item is its own key. A change asks with `helix-before-change` and\ntells with `change`. Each row is an `option` marked `aria-selected`, so a\nrow's own links and buttons are not reached there: keep those to a list\nwithout `selection-mode`.\n\n`selection-behavior=\"replace\"` selects the item pressed alone, as a file\nlist does, and the arrow keys carry the selection with them. Control or\nCommand with a press or with Space adds or takes out one item, and with an\narrow moves without selecting.\n\n**Disabled items.** `disabled-keys` names items by their keys, separated by\ncommas. Their rows carry `aria-disabled`, the keys and typing pass over\nthem, and a press, Space, or Control with A does not select them.\n\n**Loading more.** `helix-range-change` fires as the items on screen change,\nand `range` holds them. `helix-load-more` fires once a reader is within one\nscreen of the end, once for each length of the set: add to `items` and it can\nfire again. While you fetch, set `loading`: the list is busy, and a row after\nthe last item says \"Loading more\" (`loading-label`, or your own content in\nthe `loading` slot). `scrollToIndex` takes a reader to an item.\n\n**An empty list.** Set `empty-label`, or put your own content in the `empty`\nslot, for a row shown when there are no items and none are loading, such as\n\"No messages yet\" and a link to write one. Without either, an empty list\nshows nothing, since a list whose items have not arrived yet has not said\nit has none.\n\nThe list takes the `empty` state while it has read its items and holds none,\nand the `loading` state while `loading` is set, so your stylesheet can\nchange the box around it for either. A list with no name is reported once\nin a development build. Name it with `label` or `aria-label`.\n\n**Row height.** Rows are placed by `estimate` until they are drawn. Then the\nlist reads the drawn rows' height once and places every row by it, so a\nwrong estimate still reaches the last item. Set `measured` for rows of\ndifferent heights. Once the list draws rows of different heights, such as\nrows that wrap on a narrow screen, it places each row by its own height\nwhether `measured` is set or not.\n\nThe list follows its source. A new `items` array, an edit to the script's\ntext, or a script replaced under the same id draws the new rows. A row that\nstays in view keeps its element as the list scrolls.\n\nThe viewport scrolls on this tier. It carries `data-scroller`, and `core`\nships `[data-scroller] { overflow: auto }` into every shadow root, so\n`scrollTop` works with no stylesheet. You still need to set a block size.",
+          "description": "The items arrive as data, in one of two ways:\n\n- `items` takes an array. A framework sets it as a property, and React\n  hydration keeps it.\n- `for` names a `<script type=\"application/json\">` that holds an array, which\n  a server sends as markup.\n\nEach item is drawn into a row in one of two ways:\n\n- `renderItem` is a function from an item and its index to the row's\n  content: a Lit template, a string, or a DOM node.\n- A `<template>` child defines one row. `data-field=\"name\"` fills an element\n  with the item's `name` as text, and `data-field-href=\"url\"` writes the\n  item's `url` into `href`, the same for any attribute. A field may be a path\n  of keys, such as `author.name`.\n\nRows are your markup in the light DOM, so your stylesheet styles them.\n\n**A grid.** `columns` lays the items out that many to a line, as a grid of\nequal columns, and windows the set a line at a time, as React Aria's grid\nlayout does. Each item draws one element, a cell of the grid, and\n`estimate` is the height of a line. `min-column-width` lays out as many\ncolumns as fit the box instead, as React Aria's grid layout does with its\nsmallest item size, and follows the box as it resizes. `gap` spaces the rows, and the columns\nof a grid, by a number of pixels the list counts in each row's place.\n\n**Across.** `orientation=\"horizontal\"` lays the items out along a line and\nscrolls it sideways, as a strip of cards does, windowed the same way:\n`estimate` is then an item's width, and the box needs an inline size.\n\n**Sections.** `section-field` names the field of each item that says which\nsection it is in, and the list draws a header before each section's items,\nas React Aria's list box sections do. Each section is an element with the\n`group` role, named by its header, which is its first child and carries\n`data-header`, so your stylesheet styles it, such as with `position:\nsticky`. A section starts wherever the field changes, so give the items in\norder. The window counts the headers with the items, and a section the\nwindow starts inside is drawn with its header. `renderSection` draws a\nheader of your own.\n\n**Keyboard.** The list is one tab stop.\n\n| Key | What it does |\n|---|---|\n| Down, Up | Moves to the next or the previous item, or in a grid to the item in the same column on the next or the previous line. |\n| Right, Left | In a grid, moves to the next or the previous item along the line, the other way round on a right-to-left page. In a list that runs across, moves to the next or the previous item the same way, and Down and Up are left to the row. |\n| Home, End | Moves to the first or the last item. |\n| Page Down, Page Up | Moves by the number of items, or of lines in a grid, on screen. |\n| A letter or a word | Moves to the next item whose text starts with what you typed. |\n| Escape | Lets go of every chosen item, in a list with `selection-mode`. |\n| Tab | Moves into the focused row's own links and buttons, then out of the list. |\n\nAn item that is not drawn is scrolled into view and focused, so a keyboard\nreaches the whole set. When the row holding the tab stop scrolls away, the\nstop moves to the first row on screen. Typing matches each item's\n`text-field`, which is the first `data-field` of the row template by default,\nor the item itself when it is a string or a number.\n\nEach row says its place in the whole set with `aria-posinset` and\n`aria-setsize`, so a screen reader says \"4,000 of 10,000\". The row holding\nfocus stays drawn when it scrolls out.\n\n**Selecting.** `selection-mode` makes the list a list box a reader chooses\nfrom: `single` selects one item and `multiple` any number. Space or a press\nselects an item, Shift with Space, an arrow, Home, End or a press takes in\nthe items from the last one chosen, and Control or Command with A selects\nthem all, in `multiple`. Escape lets go of every chosen item, and keeps the\nkey from the dialog or menu around the list while there was something to\nlet go of. `value` holds the chosen items' keys, separated by commas, in\nthe order of the set: `key-field` names each item's key, and a string or a\nnumber item is its own key. A change asks with `helix-before-change` and\ntells with `change`. Each row is an `option` marked `aria-selected`, so a\nrow's own links and buttons are not reached there: keep those to a list\nwithout `selection-mode`.\n\n`selection-behavior=\"replace\"` selects the item pressed alone, as a file\nlist does, and the arrow keys carry the selection with them. Control or\nCommand with a press or with Space adds or takes out one item, and with an\narrow moves without selecting.\n\n**Disabled items.** `disabled-keys` names items by their keys, separated by\ncommas. Their rows carry `aria-disabled`, the keys and typing pass over\nthem, and a press, Space, or Control with A does not select them.\n\n**Loading more.** `helix-range-change` fires as the items on screen change,\nand `range` holds them. `helix-load-more` fires once a reader is within one\nscreen of the end, once for each length of the set: add to `items` and it can\nfire again. While you fetch, set `loading`: the list is busy, and a row after\nthe last item says \"Loading more\" (`loading-label`, or your own content in\nthe `loading` slot). `scrollToIndex` takes a reader to an item.\n\n**An empty list.** Set `empty-label`, or put your own content in the `empty`\nslot, for a row shown when there are no items and none are loading, such as\n\"No messages yet\" and a link to write one. Without either, an empty list\nshows nothing, since a list whose items have not arrived yet has not said\nit has none.\n\nThe list takes the `empty` state while it has read its items and holds none,\nand the `loading` state while `loading` is set, so your stylesheet can\nchange the box around it for either. A list with no name is reported once\nin a development build. Name it with `label` or `aria-label`.\n\n**Row height.** Rows are placed by `estimate` until they are drawn. Then the\nlist reads the drawn rows' height once and places every row by it, so a\nwrong estimate still reaches the last item. Set `measured` for rows of\ndifferent heights. Once the list draws rows of different heights, such as\nrows that wrap on a narrow screen, it places each row by its own height\nwhether `measured` is set or not.\n\nThe list follows its source. A new `items` array, an edit to the script's\ntext, or a script replaced under the same id draws the new rows. A row that\nstays in view keeps its element as the list scrolls.\n\nThe viewport scrolls on this tier. It carries `data-scroller`, and `core`\nships `[data-scroller] { overflow: auto }` into every shadow root, so\n`scrollTop` works with no stylesheet. You still need to set a block size.",
           "name": "HelixHeadlessVirtualList",
           "cssParts": [
             {
@@ -192798,6 +194622,16 @@
               "description": "The narrowest a column of a grid may be, in pixels. Set, the list lays\nout as many columns as fit the box at that width, at least one, and\nfollows the box as it resizes, which `columns` then does not decide.",
               "attribute": "min-column-width"
             },
+            {
+              "kind": "field",
+              "name": "orientation",
+              "type": {
+                "text": "'horizontal' | 'vertical'"
+              },
+              "default": "'vertical'",
+              "description": "Which way the list runs. `horizontal` lays the items out along a line\nand scrolls it sideways: Left and Right move between items, the other\nway round on a right-to-left page, and `estimate` is an item's width. A\ngrid always runs down.",
+              "attribute": "orientation"
+            },
             {
               "kind": "field",
               "name": "renderItem",
@@ -192806,6 +194640,24 @@
               },
               "description": "Draws one item into its row, given the item and its index. Set it as a\nproperty.\n\nIt returns what Lit renders: a template from `html`, a string, or a DOM\nnode. The list wraps each result in a `<div>` that carries the row's role\nand place in the set. Where it is unset, the row `<template>` is used."
             },
+            {
+              "kind": "field",
+              "name": "renderSection",
+              "type": {
+                "text": "VirtualListSectionRenderer | undefined"
+              },
+              "description": "Draws each section's header, given its name and its place among the\nsections, for a list given `section-field`. Set it as a property. Where\nit is unset, the header is the name as text."
+            },
+            {
+              "kind": "field",
+              "name": "sectionField",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "The field of each item that names its section, as a key or a path of\nkeys. Set, the items are drawn in sections: a header, then the items, in\nan element with the `group` role that the header names. A section starts\nwherever the field changes, so give the items in order. A list of one\ncolumn only.",
+              "attribute": "section-field"
+            },
             {
               "kind": "field",
               "name": "selectionBehavior",
@@ -192978,7 +194830,7 @@
               "name": "virtualize",
               "privacy": "private",
               "readonly": true,
-              "default": "new VirtualizeController(this, { container: () => this.partNamed('viewport'), count: () => Math.ceil(this.data.length / this.across), estimate: () => this.estimate, gap: () => this.space, measured: () => this.measured, rows: () => this.lines(), })"
+              "default": "new VirtualizeController(this, { container: () => this.partNamed('viewport'), count: () => this.sections ? this.data.length + this.sections.starts.length : Math.ceil(this.data.length / this.across), estimate: () => this.estimate, gap: () => this.space, horizontal: () => this.horizontal, measured: () => this.measured, rows: () => this.lines(), })"
             },
             {
               "kind": "field",
@@ -193068,6 +194920,54 @@
               ],
               "description": "The items a span of lines holds."
             },
+            {
+              "kind": "method",
+              "name": "lineOf",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "number"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "at",
+                  "type": {
+                    "text": "number"
+                  }
+                }
+              ],
+              "description": "The line item `at` is on: its entry in a list with sections."
+            },
+            {
+              "kind": "field",
+              "name": "horizontal",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "description": "Whether the list runs across, which a grid never does.",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "sectionsRead",
+              "type": {
+                "text": "{ data: readonly unknown[]; field: string; sections: Sections } | undefined"
+              },
+              "privacy": "private",
+              "description": "The sections and the items they were read from, kept until either changes."
+            },
+            {
+              "kind": "field",
+              "name": "sections",
+              "type": {
+                "text": "Sections | undefined"
+              },
+              "privacy": "private",
+              "description": "The sections `section-field` divides the items into, in a list of one column.",
+              "readonly": true
+            },
             {
               "kind": "method",
               "name": "scrollToIndex",
@@ -193265,6 +195165,25 @@
               ],
               "description": "The item a row element drew, for an element that is one of the rows."
             },
+            {
+              "kind": "method",
+              "name": "isRow",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "node is HTMLElement"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "node",
+                  "type": {
+                    "text": "unknown"
+                  }
+                }
+              ],
+              "description": "Whether a node is one of the rows: a child, or a child of a section."
+            },
             {
               "kind": "method",
               "name": "rowFor",
@@ -193590,6 +195509,68 @@
               },
               "description": "Puts the windowed rows into the light DOM, and takes the rest out.\n\n**A row that stays in the window keeps its element.** Clearing and\ncloning every row on every move replaced the node a reader had focused,\nso a link in a row lost focus to the body on any scroll, even with its row\nstill on screen. Rows are keyed by item: the ones leaving go, the ones\narriving are drawn in their place, and the ones staying are not moved.\n\n**The row holding focus is drawn outside the window too**, beside it on the\nside it belongs, and the spacer on that side gives up its room.\n\n**One row holds the tab stop**, the one the reader last focused while it is\ndrawn, and the first row on screen once it is not. Its own links and\nbuttons are in the tab order, and those of every other row wait."
             },
+            {
+              "kind": "field",
+              "name": "placedSections",
+              "type": {
+                "text": "Sections | undefined"
+              },
+              "privacy": "private",
+              "description": "The sections the rows were last placed in."
+            },
+            {
+              "kind": "field",
+              "name": "headedBy",
+              "type": {
+                "text": "VirtualListSectionRenderer | undefined"
+              },
+              "privacy": "private",
+              "description": "The function the drawn headers were drawn by, so a new one draws them again."
+            },
+            {
+              "kind": "field",
+              "name": "sectionId",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Ties each header's id to this list."
+            },
+            {
+              "kind": "method",
+              "name": "groups",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "Map<number, HTMLElement>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "sections",
+                  "type": {
+                    "text": "Sections | undefined"
+                  }
+                },
+                {
+                  "name": "wanted",
+                  "type": {
+                    "text": "readonly number[]"
+                  }
+                },
+                {
+                  "name": "regroup",
+                  "type": {
+                    "text": "boolean"
+                  }
+                },
+                {
+                  "name": "refill",
+                  "type": {
+                    "text": "boolean"
+                  }
+                }
+              ],
+              "description": "The section elements a pass draws rows into, by section, for the\nsections of the wanted items: each a `group` named by its header, which\nis its first child. The ones no wanted item is in leave, and all of them\ndo when the sections change."
+            },
             {
               "kind": "method",
               "name": "spacerSizes",
@@ -193599,7 +195580,7 @@
                   "text": "{ after: number; before: number }"
                 }
               },
-              "description": "The spacers' heights: the window's, with the line kept for focus taking its own room."
+              "description": "The spacers' sizes: the window's, with the line kept for focus taking its\nown room, and so do the headers drawn with their sections from outside it."
             },
             {
               "kind": "field",
@@ -194084,6 +196065,24 @@
               "description": "The narrowest a column of a grid may be, in pixels. Set, the list lays\nout as many columns as fit the box at that width, at least one, and\nfollows the box as it resizes, which `columns` then does not decide.",
               "fieldName": "minColumnWidth"
             },
+            {
+              "name": "orientation",
+              "type": {
+                "text": "'horizontal' | 'vertical'"
+              },
+              "default": "'vertical'",
+              "description": "Which way the list runs. `horizontal` lays the items out along a line\nand scrolls it sideways: Left and Right move between items, the other\nway round on a right-to-left page, and `estimate` is an item's width. A\ngrid always runs down.",
+              "fieldName": "orientation"
+            },
+            {
+              "name": "section-field",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "The field of each item that names its section, as a key or a path of\nkeys. Set, the items are drawn in sections: a header, then the items, in\nan element with the `group` role that the header names. A section starts\nwherever the field changes, so give the items in order. A list of one\ncolumn only.",
+              "fieldName": "sectionField"
+            },
             {
               "name": "selection-behavior",
               "type": {
@@ -194125,6 +196124,10 @@
               "description": "While the list has read its items and holds none.",
               "name": "empty"
             },
+            {
+              "description": "While the list runs across, with `orientation=\"horizontal\"`.",
+              "name": "horizontal"
+            },
             {
               "description": "While `loading` is set.",
               "name": "loading"
@@ -194183,10 +196186,184 @@
           }
         }
       ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/virtual-list/sections.ts",
+      "declarations": [
+        {
+          "kind": "function",
+          "name": "sectionsOf",
+          "return": {
+            "type": {
+              "text": "Sections"
+            }
+          },
+          "parameters": [
+            {
+              "name": "items",
+              "type": {
+                "text": "readonly unknown[]"
+              }
+            },
+            {
+              "name": "field",
+              "type": {
+                "text": "string"
+              }
+            }
+          ],
+          "description": "The sections `field` divides the items into."
+        },
+        {
+          "kind": "function",
+          "name": "sectionAt",
+          "return": {
+            "type": {
+              "text": "number"
+            }
+          },
+          "parameters": [
+            {
+              "name": "{ starts }",
+              "type": {
+                "text": "Sections"
+              }
+            },
+            {
+              "name": "item",
+              "type": {
+                "text": "number"
+              }
+            }
+          ],
+          "description": "The section item `item` is in."
+        },
+        {
+          "kind": "function",
+          "name": "entryOf",
+          "return": {
+            "type": {
+              "text": "number"
+            }
+          },
+          "parameters": [
+            {
+              "name": "sections",
+              "type": {
+                "text": "Sections"
+              }
+            },
+            {
+              "name": "item",
+              "type": {
+                "text": "number"
+              }
+            }
+          ],
+          "description": "The entry item `item` is."
+        },
+        {
+          "kind": "function",
+          "name": "headOf",
+          "return": {
+            "type": {
+              "text": "number"
+            }
+          },
+          "parameters": [
+            {
+              "name": "{ starts }",
+              "type": {
+                "text": "Sections"
+              }
+            },
+            {
+              "name": "section",
+              "type": {
+                "text": "number"
+              }
+            }
+          ],
+          "description": "The entry of section `section`'s header."
+        },
+        {
+          "kind": "function",
+          "name": "itemsIn",
+          "return": {
+            "type": {
+              "text": "{ first: number; last: number }"
+            }
+          },
+          "parameters": [
+            {
+              "name": "sections",
+              "type": {
+                "text": "Sections"
+              }
+            },
+            {
+              "name": "entries",
+              "type": {
+                "text": "{ first: number; last: number }"
+              }
+            },
+            {
+              "name": "count",
+              "type": {
+                "text": "number"
+              }
+            }
+          ],
+          "description": "The items a span of entries holds: what a window of entries draws, or what\na reader sees. A header at either end holds no item, so the span starts at\nits section's first item."
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "sectionsOf",
+          "declaration": {
+            "name": "sectionsOf",
+            "module": "src/virtual-list/sections.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "sectionAt",
+          "declaration": {
+            "name": "sectionAt",
+            "module": "src/virtual-list/sections.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "entryOf",
+          "declaration": {
+            "name": "entryOf",
+            "module": "src/virtual-list/sections.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "headOf",
+          "declaration": {
+            "name": "headOf",
+            "module": "src/virtual-list/sections.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "itemsIn",
+          "declaration": {
+            "name": "itemsIn",
+            "module": "src/virtual-list/sections.ts"
+          }
+        }
+      ]
     }
   ],
   "helix": {
     "package": "@fusion.dev/helix-headless",
-    "version": "0.166.0"
+    "version": "0.167.0"
   }
 }