@fusion.dev/helix-headless 0.147.0 → 0.149.0

package/types/vue.d.ts

@@ -129,6 +129,7 @@ import type {
   HelixHeadlessSkipLink,
   HelixHeadlessSlider,
   HelixHeadlessSparkline,
+  HelixHeadlessSpeedDialGroup,
   HelixHeadlessSpeedDialItem,
   HelixHeadlessSpeedDial,
   HelixHeadlessSplitter,
@@ -174,6 +175,7 @@ import type {
   ToggleEvent,
   HelixDismissEvent,
   HelixScrolledEvent,
+  HelixBeforeChangeEvent,
   HelixPressEvent,
   HelixBeforeMoveEvent,
   HelixBeforeReconnectEvent,
@@ -194,7 +196,6 @@ import type {
   HelixBeforePinEvent,
   HelixHistoryEvent,
   HelixPinEvent,
-  HelixBeforeChangeEvent,
   HelixBeforeToggleEvent,
   HelixCopyEvent,
   HelixSampleEndEvent,
@@ -203,6 +204,7 @@ import type {
   HelixFilterEvent,
   HelixLoadMoreEvent,
   HelixCopyErrorEvent,
+  HelixBeforeReorderEvent,
   HelixExpandEvent,
   HelixFilteredEvent,
   HelixNavigateEvent,
@@ -453,6 +455,22 @@ export type HelixHeadlessAnnouncementVueProps = {
 Read once when the announcement is first rendered, as `Toast` reads its
 own. The clock stops while the pointer or focus is on the announcement. */
   duration?: (HelixHeadlessAnnouncement["duration"]) | undefined;
+  /** The key that moves focus to the announcement's first control, and back
+to where it was, written as keys joined by `+`, such as `F6` or `Alt+A`.
+
+F6 by default, the key React Aria's regions answer to. Empty turns it
+off. With several announcements, the first one in the page takes focus. */
+  hotkey?: (HelixHeadlessAnnouncement["hotkey"]) | undefined;
+  /** The name of the announcement's region, which screen readers list among
+the page's landmarks. Translate it with the rest of your interface.
+
+Empty leaves the announcement no region. */
+  label?: (HelixHeadlessAnnouncement["label"]) | undefined;
+  /** Whether the announcement waits its turn behind the queued announcements
+before it in the same parent, showing when the last of them is removed.
+
+Off by default, so every announcement on a page shows at once. */
+  queued?: (HelixHeadlessAnnouncement["queued"]) | undefined;
   /** The band's color.
 
 Paint only: unlike `Callout`, no value here draws a mark, changes the label,
@@ -481,14 +499,22 @@ axes, which is the test the registry answers to. */
 `attribute` is spelled out because Lit lowercases a property name to
 derive one rather than dash-casing it, so this would otherwise be
 reachable only as `dismisslabel`, which nobody would guess and no linter
-would catch. */
+would catch.
+
+A word property: register it for a locale under the host's key. A family
+that names the control otherwise, such as Tag's `Remove {label}`,
+declares its own English with `@words` above the override. */
   "dismiss-label"?: (HelixHeadlessAnnouncement["dismissLabel"]) | undefined;
   /** The dismiss control's label, read by screen readers.
 
 `attribute` is spelled out because Lit lowercases a property name to
 derive one rather than dash-casing it, so this would otherwise be
 reachable only as `dismisslabel`, which nobody would guess and no linter
-would catch. */
+would catch.
+
+A word property: register it for a locale under the host's key. A family
+that names the control otherwise, such as Tag's `Remove {label}`,
+declares its own English with `@words` above the override. */
   dismissLabel?: (HelixHeadlessAnnouncement["dismissLabel"]) | undefined;
 };
 
@@ -583,6 +609,14 @@ the total.
 Absent stacks the amounts, so the top edge is the total. Set, every reading
 fills the height and the bands are shares of it. */
   share?: (HelixHeadlessAreaChart["share"]) | undefined;
+  /** The summary's sentence. `{reading}` is the latest reading's name,
+`{totalLabel}` the name for the sum, `{total}` the sum, written in the
+locale, and `{shares}` each part's share, listed as the locale lists. */
+  "summary-label"?: (HelixHeadlessAreaChart["summaryLabel"]) | undefined;
+  /** The summary's sentence. `{reading}` is the latest reading's name,
+`{totalLabel}` the name for the sum, `{total}` the sum, written in the
+locale, and `{shares}` each part's share, listed as the locale lists. */
+  summaryLabel?: (HelixHeadlessAreaChart["summaryLabel"]) | undefined;
   /** The name for the sum of the parts, shown in the tooltip and the summary. */
   "total-label"?: (HelixHeadlessAreaChart["totalLabel"]) | undefined;
   /** The name for the sum of the parts, shown in the tooltip and the summary. */
@@ -604,8 +638,8 @@ words and is already written. */
   /** The locale the chart's own numbers are written in: its axis, its
 percentages and its totals, such as `de` for `1.240` and `32 %`.
 
-Absent uses the runtime's own. The table's cells are shown as the table
-writes them, whatever this says. */
+Absent reads the nearest `lang`, then the runtime's own. The table's
+cells are shown as the table writes them, whatever this says. */
   locale?: (HelixHeadlessAreaChart["locale"]) | undefined;
   /** Where a reading the keys moved to stands among the readings, said after
 it. `{position}` and `{count}` are replaced with the numbers, written in
@@ -647,14 +681,20 @@ everyone, assigning a matching property rather than an attribute.
 takes no default**: `max = 0` would stamp `max="0"` onto every host that
 never asked for a limit, including on the server. */
   max?: (HelixHeadlessAvatarGroup["max"]) | undefined;
-  /** What a screen reader is told the count is, with `{count}` for the number
-and `{names}` for the people it stands for, by each avatar's `name`.
+  /** What a screen reader is told the count is, with `{count}` for the number,
+written in the locale, and `{names}` for the people it stands for, by each
+avatar's `name`, listed as the locale lists. A language that needs plural
+forms writes them: `{count, plural, one {# osoba więcej: {names}} few
+{# osoby więcej: {names}} other {# osób więcej: {names}}}`.
 
 The count shows "+3", which reads as "plus three" and says nothing about
 what was counted, nor who. */
   "overflow-label"?: (HelixHeadlessAvatarGroup["overflowLabel"]) | undefined;
-  /** What a screen reader is told the count is, with `{count}` for the number
-and `{names}` for the people it stands for, by each avatar's `name`.
+  /** What a screen reader is told the count is, with `{count}` for the number,
+written in the locale, and `{names}` for the people it stands for, by each
+avatar's `name`, listed as the locale lists. A language that needs plural
+forms writes them: `{count, plural, one {# osoba więcej: {names}} few
+{# osoby więcej: {names}} other {# osób więcej: {names}}}`.
 
 The count shows "+3", which reads as "plus three" and says nothing about
 what was counted, nor who. */
@@ -746,11 +786,15 @@ shown as it is either way. */
 
 Required for a dot, which has no text to read. `{count}` is replaced with
 what the badge shows, so `label="{count} unread"` reads "8 unread" and
-stays current as `value` changes, with no label of yours to keep in step. */
+stays current as `value` changes, with no label of yours to keep in step.
+A language with plural forms writes them, `{count, plural, one {{count}
+nieprzeczytana} few {{count} nieprzeczytane} other {{count}
+nieprzeczytanych}}`, picked by the count in `locale`. */
   label?: (HelixHeadlessBadge["label"]) | undefined;
-  /** The locale a count is written in under `format-options`, such as `de`.
+  /** The locale a count is written in under `format-options`, and whose plural
+rules `label` picks a form by, such as `de`.
 
-Absent uses the runtime's own. */
+Absent reads the nearest `lang`, then the runtime's own. */
   locale?: (HelixHeadlessBadge["locale"]) | undefined;
   /** The largest number the badge shows.
 
@@ -794,9 +838,11 @@ of many thin bars, where the eye has stopped counting.
 Furniture rather than data, so the rules are inside the `aria-hidden` plot
 and reach no reader through the table. */
   gridlines?: (HelixHeadlessBarChart["gridlines"]) | undefined;
-  /** The word the summary puts before each series' highest reading. */
+  /** The name the summary gives each series' highest reading, `{highestLabel}`
+in `summary-label`. */
   "highest-label"?: (HelixHeadlessBarChart["highestLabel"]) | undefined;
-  /** The word the summary puts before each series' highest reading. */
+  /** The name the summary gives each series' highest reading, `{highestLabel}`
+in `summary-label`. */
   highestLabel?: (HelixHeadlessBarChart["highestLabel"]) | undefined;
   /** The names of the series to draw as lines. The other series are drawn as
 columns.
@@ -874,6 +920,14 @@ the other. The scale fits the stacks. A series
 in `lines` is still a line, measured on its own reading; columns on the
 second scale stack among themselves. */
   stacked?: (HelixHeadlessBarChart["stacked"]) | undefined;
+  /** The summary's sentence. `{highestLabel}` is `highest-label`, and
+`{readings}` each series' highest reading: the series, the category and
+the reading as the table writes it. */
+  "summary-label"?: (HelixHeadlessBarChart["summaryLabel"]) | undefined;
+  /** The summary's sentence. `{highestLabel}` is `highest-label`, and
+`{readings}` each series' highest reading: the series, the category and
+the reading as the table writes it. */
+  summaryLabel?: (HelixHeadlessBarChart["summaryLabel"]) | undefined;
   /** The id of the table to read.
 
 Names a table in the same tree, so a chart inside another component's
@@ -891,8 +945,8 @@ words and is already written. */
   /** The locale the chart's own numbers are written in: its axis, its
 percentages and its totals, such as `de` for `1.240` and `32 %`.
 
-Absent uses the runtime's own. The table's cells are shown as the table
-writes them, whatever this says. */
+Absent reads the nearest `lang`, then the runtime's own. The table's
+cells are shown as the table writes them, whatever this says. */
   locale?: (HelixHeadlessBarChart["locale"]) | undefined;
   /** Where a reading the keys moved to stands among the readings, said after
 it. `{position}` and `{count}` are replaced with the numbers, written in
@@ -915,8 +969,19 @@ legend hid is not counted. */
 export type HelixHeadlessBarChartVueEvents = {};
 
 export type HelixHeadlessBlockquoteVueProps = {
-  /** The URL of the source the passage came from. */
+  /** Who said it, and where, as words, such as "Maria Lopez, operations
+manager". The `attribution` slot replaces them, for markup such as a link.
+
+Words are served with the figure they name, where a server cannot see a
+slotted attribution. */
+  attribution?: (HelixHeadlessBlockquote["attribution"]) | undefined;
+  /** The URL of the source the passage came from. Who said it goes in
+`attribution`: a `cite` with words in it warns once, with the runtime kind
+`cite-not-url`. */
   cite?: (HelixHeadlessBlockquote["cite"]) | undefined;
+  /** Whether to draw an opening quotation mark before the passage, in the
+element's language. Leave the marks out of the text. */
+  marks?: (HelixHeadlessBlockquote["marks"]) | undefined;
 };
 
 export type HelixHeadlessBlockquoteVueEvents = {};
@@ -954,10 +1019,14 @@ export type HelixHeadlessBreadcrumbVueEvents = {};
 
 export type HelixHeadlessBreadcrumbsVueProps = {
   /** The name of the button that shows a folded trail's hidden crumbs. `{count}`
-is replaced by how many it shows. Translate it with the page. */
+is how many it shows, written in the locale, and a language with plural
+forms writes them: `{count, plural, one {# weiteren zeigen} other {#
+weitere zeigen}}`. */
   "expand-label"?: (HelixHeadlessBreadcrumbs["expandLabel"]) | undefined;
   /** The name of the button that shows a folded trail's hidden crumbs. `{count}`
-is replaced by how many it shows. Translate it with the page. */
+is how many it shows, written in the locale, and a language with plural
+forms writes them: `{count, plural, one {# weiteren zeigen} other {#
+weitere zeigen}}`. */
   expandLabel?: (HelixHeadlessBreadcrumbs["expandLabel"]) | undefined;
   /** The landmark's name, read by screen readers. An `aria-label` on the host
 wins over it. */
@@ -980,6 +1049,15 @@ attribute would put the whole path into the markup twice. */
 
 export type HelixHeadlessBreadcrumbsVueEvents = {};
 
+/** `HelixHeadlessButtonGroup` component event */
+export type HelixHeadlessButtonGroupElementEvent<E = Event> = TypedEvent<
+  HelixHeadlessButtonGroup,
+  E
+>;
+/** `helix-before-change` event type */
+export type HelixHeadlessButtonGroupHelixBeforeChangeElementEvent =
+  HelixHeadlessButtonGroupElementEvent<HelixBeforeChangeEvent>;
+
 export type HelixHeadlessButtonGroupVueProps = {
   /** The group's name, read by screen readers.
 
@@ -1004,9 +1082,32 @@ buttons sharing edges as one shape, and a wrapped row carries the corners of
 a first row into a second. Stacked, the same three keep one shape and one
 column. */
   orientation?: (HelixHeadlessButtonGroup["orientation"]) | undefined;
+  /** Whether the buttons stay pressed: `single` keeps one pressed at a time and
+`multiple` any number. Unset, they are action buttons, each its own tab
+stop, as before.
+
+Optional, so the attribute is absent until a consumer writes it. */
+  "selection-mode"?: (HelixHeadlessButtonGroup["selectionMode"]) | undefined;
+  /** Whether the buttons stay pressed: `single` keeps one pressed at a time and
+`multiple` any number. Unset, they are action buttons, each its own tab
+stop, as before.
+
+Optional, so the attribute is absent until a consumer writes it. */
+  selectionMode?: (HelixHeadlessButtonGroup["selectionMode"]) | undefined;
+  /** The values of the pressed buttons, comma separated, in a selection mode.
+A button's own `value` names it, so a value holds no comma.
+
+The attribute is the seed, and a press changes the property, which does
+not reflect, as a native control's `value` does not. */
+  value?: (HelixHeadlessButtonGroup["value"]) | undefined;
 };
 
-export type HelixHeadlessButtonGroupVueEvents = {};
+export type HelixHeadlessButtonGroupVueEvents = {
+  /** Fired after a press changes `value`, in a selection mode. */
+  change: HelixHeadlessButtonGroupElementEvent;
+  /** Fired before a press changes `value`, with the value it would leave in `detail.value`. Cancelable: call `preventDefault()` to keep the buttons as they are. */
+  "helix-before-change": HelixHeadlessButtonGroupHelixBeforeChangeElementEvent;
+};
 
 /** `HelixHeadlessButton` component event */
 export type HelixHeadlessButtonElementEvent<E = Event> = TypedEvent<
@@ -1079,7 +1180,11 @@ not text.
 
 Lives here rather than only on `IconButton` so the two share one render.
 An icon-only button without it is a control a screen reader announces as
-"button" and nothing else. */
+"button" and nothing else.
+
+Undefaulted, so a subclass's own default, such as Copy Button's `Copy`, is
+the first value its element receives and so the English its words fall
+back to. */
   label?: (HelixHeadlessButton["label"]) | undefined;
   /** Whether the action the button started is still running.
 
@@ -1215,14 +1320,28 @@ is the whole of the registry, which is why there is no `severity` beside it. */
   tone?: (HelixHeadlessCallout["tone"]) | undefined;
   /** What a screen reader is told the tone is, such as "Fehler".
 
-Absent is the English for the tone: "Error", "Information", "Note",
-"Success" or "Warning". */
+Absent is the tone's words in `tone-labels`, "Error", "Information",
+"Note", "Success" or "Warning" in English. */
   "tone-label"?: (HelixHeadlessCallout["toneLabel"]) | undefined;
   /** What a screen reader is told the tone is, such as "Fehler".
 
-Absent is the English for the tone: "Error", "Information", "Note",
-"Success" or "Warning". */
+Absent is the tone's words in `tone-labels`, "Error", "Information",
+"Note", "Success" or "Warning" in English. */
   toneLabel?: (HelixHeadlessCallout["toneLabel"]) | undefined;
+  /** What a screen reader is told each tone is, by the tone's name, written as
+JSON in the attribute: `tone-labels='{"danger":"Fehler"}'`. A tone left
+out keeps its English, and `tone-label` wins over both.
+
+`danger` is said as "Error", the word a reader understands, and
+`neutral` as "Note", for what the passage is. */
+  "tone-labels"?: (HelixHeadlessCallout["toneLabels"]) | undefined;
+  /** What a screen reader is told each tone is, by the tone's name, written as
+JSON in the attribute: `tone-labels='{"danger":"Fehler"}'`. A tone left
+out keeps its English, and `tone-label` wins over both.
+
+`danger` is said as "Error", the word a reader understands, and
+`neutral` as "Note", for what the passage is. */
+  toneLabels?: (HelixHeadlessCallout["toneLabels"]) | undefined;
   /** Whether the element shows a control that dismisses it. */
   dismissible?: (HelixHeadlessCallout["dismissible"]) | undefined;
   /** The dismiss control's label, read by screen readers.
@@ -1230,14 +1349,22 @@ Absent is the English for the tone: "Error", "Information", "Note",
 `attribute` is spelled out because Lit lowercases a property name to
 derive one rather than dash-casing it, so this would otherwise be
 reachable only as `dismisslabel`, which nobody would guess and no linter
-would catch. */
+would catch.
+
+A word property: register it for a locale under the host's key. A family
+that names the control otherwise, such as Tag's `Remove {label}`,
+declares its own English with `@words` above the override. */
   "dismiss-label"?: (HelixHeadlessCallout["dismissLabel"]) | undefined;
   /** The dismiss control's label, read by screen readers.
 
 `attribute` is spelled out because Lit lowercases a property name to
 derive one rather than dash-casing it, so this would otherwise be
 reachable only as `dismisslabel`, which nobody would guess and no linter
-would catch. */
+would catch.
+
+A word property: register it for a locale under the host's key. A family
+that names the control otherwise, such as Tag's `Remove {label}`,
+declares its own English with `@words` above the override. */
   dismissLabel?: (HelixHeadlessCallout["dismissLabel"]) | undefined;
 };
 
@@ -1437,6 +1564,12 @@ export type HelixHeadlessCanvasHelixSelectElementEvent =
   HelixHeadlessCanvasElementEvent<HelixSelectEvent>;
 
 export type HelixHeadlessCanvasVueProps = {
+  /** The hint shown when the board, waiting to be pressed with
+`gestures="activate"`, is scrolled or swiped over. */
+  "activate-hint-label"?: (HelixHeadlessCanvas["activateHintLabel"]) | undefined;
+  /** The hint shown when the board, waiting to be pressed with
+`gestures="activate"`, is scrolled or swiped over. */
+  activateHintLabel?: (HelixHeadlessCanvas["activateHintLabel"]) | undefined;
   /** The text read with a card to say where its connections come from, with `{cards}`. */
   "comes-from-label"?: (HelixHeadlessCanvas["comesFromLabel"]) | undefined;
   /** The text read with a card to say where its connections come from, with `{cards}`. */
@@ -1467,6 +1600,16 @@ this, so a reader hears the ends first and what the line says after. */
 Its own label, where it has one, is its description rather than part of
 this, so a reader hears the ends first and what the line says after. */
   connectionLabel?: (HelixHeadlessCanvas["connectionLabel"]) | undefined;
+  /** The name of the group of controls, read by screen readers, which names
+what the controls drive rather than the mechanism. */
+  "controls-label"?: (HelixHeadlessCanvas["controlsLabel"]) | undefined;
+  /** The name of the group of controls, read by screen readers, which names
+what the controls drive rather than the mechanism. */
+  controlsLabel?: (HelixHeadlessCanvas["controlsLabel"]) | undefined;
+  /** The board's name where `label` is empty. */
+  "fallback-label"?: (HelixHeadlessCanvas["fallbackLabel"]) | undefined;
+  /** The board's name where `label` is empty. */
+  fallbackLabel?: (HelixHeadlessCanvas["fallbackLabel"]) | undefined;
   /** The accessible name for the board. Required.
 
 A document has no name of its own in the format, and "Canvas" names the
@@ -1490,6 +1633,26 @@ as the list.
 The list is joined the way the page's language joins one, "Second and
 Third", rather than with a comma this component chose. */
   leadsToLabel?: (HelixHeadlessCanvas["leadsToLabel"]) | undefined;
+  /** The text read with a card that has connections both ways. `{leadsTo}` is
+`leads-to-label` and `{comesFrom}` is `comes-from-label`, each filled in. */
+  "linked-label"?: (HelixHeadlessCanvas["linkedLabel"]) | undefined;
+  /** The text read with a card that has connections both ways. `{leadsTo}` is
+`leads-to-label` and `{comesFrom}` is `comes-from-label`, each filled in. */
+  linkedLabel?: (HelixHeadlessCanvas["linkedLabel"]) | undefined;
+  /** What screen readers hear after a key moves a card, with `{name}` for the
+card and `{x}` and `{y}` for where it now is, in the document's units.
+
+**A move a reader cannot see has to be said.** Shift with an arrow moved
+the card and said nothing, so a reader moving one by keys could not tell
+whether it had moved, or how far. */
+  "moved-label"?: (HelixHeadlessCanvas["movedLabel"]) | undefined;
+  /** What screen readers hear after a key moves a card, with `{name}` for the
+card and `{x}` and `{y}` for where it now is, in the document's units.
+
+**A move a reader cannot see has to be said.** Shift with an arrow moved
+the card and said nothing, so a reader moving one by keys could not tell
+whether it had moved, or how far. */
+  movedLabel?: (HelixHeadlessCanvas["movedLabel"]) | undefined;
   /** The order the arrow keys and screen readers move through the cards:
 `spatial` or `edges`.
 
@@ -1530,6 +1693,14 @@ walk the cards. */
   /** The text announced when a connection's end is picked up, with `{from}` and
 `{to}`. */
   reconnectingLabel?: (HelixHeadlessCanvas["reconnectingLabel"]) | undefined;
+  /** What screen readers hear after a key resizes a card, with `{name}` for the
+card and `{width}` and `{height}` for its new size, in the document's
+units. */
+  "resized-label"?: (HelixHeadlessCanvas["resizedLabel"]) | undefined;
+  /** What screen readers hear after a key resizes a card, with `{name}` for the
+card and `{width}` and `{height}` for its new size, in the document's
+units. */
+  resizedLabel?: (HelixHeadlessCanvas["resizedLabel"]) | undefined;
   /** The names of the selected cards and connections, comma separated. Empty
 when nothing is selected.
 
@@ -1550,6 +1721,45 @@ on its board across cards and connections both, and may not hold a comma.
 
 Written to select from outside, and read to act on the selection. */
   selected?: (HelixHeadlessCanvas["selected"]) | undefined;
+  /** What a selected card or connection adds to what screen readers hear on
+it, before its tone and its connections. Empty adds nothing.
+
+A card is an article and a connection a button, and neither has a selected
+state for `aria-selected` to carry, so the state is said in words. */
+  "selected-label"?: (HelixHeadlessCanvas["selectedLabel"]) | undefined;
+  /** What a selected card or connection adds to what screen readers hear on
+it, before its tone and its connections. Empty adds nothing.
+
+A card is an article and a connection a button, and neither has a selected
+state for `aria-selected` to carry, so the state is said in words. */
+  selectedLabel?: (HelixHeadlessCanvas["selectedLabel"]) | undefined;
+  /** What screen readers hear after the selection grows or shrinks, with
+`{count}` for how many cards and connections are selected, written in the
+locale, where a language that needs plural forms writes them: by Space, a
+click with Shift, Command or Control, Command or Control with A, a box
+drawn across the board, or Escape.
+
+A selection of one made by arriving on a card or clicking it is not said,
+since the card is. */
+  "selection-label"?: (HelixHeadlessCanvas["selectionLabel"]) | undefined;
+  /** What screen readers hear after the selection grows or shrinks, with
+`{count}` for how many cards and connections are selected, written in the
+locale, where a language that needs plural forms writes them: by Space, a
+click with Shift, Command or Control, Command or Control with A, a box
+drawn across the board, or Escape.
+
+A selection of one made by arriving on a card or clicking it is not said,
+since the card is. */
+  selectionLabel?: (HelixHeadlessCanvas["selectionLabel"]) | undefined;
+  /** Snaps the cards a reader moves or resizes to a multiple of this many of the
+document's units, such as `32` to land on the lines `grid` draws.
+
+**A drag lets go on the nearest line and a key goes to the next one.**
+Shift with an arrow moves a card to the next line that way, rather than
+by its step of 16, and Alt with an arrow moves its bottom right corner
+the same way. A group moves with what it carries, so a card inside one
+keeps its place in it. Absent, cards land where they are let go. */
+  snap?: (HelixHeadlessCanvas["snap"]) | undefined;
   /** The text announced when a connection is stopped before it is requested. */
   "stopped-label"?: (HelixHeadlessCanvas["stoppedLabel"]) | undefined;
   /** The text announced when a connection is stopped before it is requested. */
@@ -1572,12 +1782,26 @@ red is "blocked" on one board and "urgent" on the next. A reader who can
 see the board is told by the color; this is how a reader who cannot is
 told the same. A tone left out is not read. */
   toneLabels?: (HelixHeadlessCanvas["toneLabels"]) | undefined;
-  /** The hint shown when a surface waiting to be pressed is scrolled or
-swiped over, with `gestures="activate"`. Absent is the family's own. */
-  "activate-hint-label"?: (HelixHeadlessCanvas["activateHintLabel"]) | undefined;
-  /** The hint shown when a surface waiting to be pressed is scrolled or
-swiped over, with `gestures="activate"`. Absent is the family's own. */
-  activateHintLabel?: (HelixHeadlessCanvas["activateHintLabel"]) | undefined;
+  /** The hint shown when one finger swipes over the board with `gestures="cooperative"`. */
+  "two-finger-hint-label"?: (HelixHeadlessCanvas["twoFingerHintLabel"]) | undefined;
+  /** The hint shown when one finger swipes over the board with `gestures="cooperative"`. */
+  twoFingerHintLabel?: (HelixHeadlessCanvas["twoFingerHintLabel"]) | undefined;
+  /** The line shown while the board, with `gestures="activate"`, has the gestures. */
+  "using-label"?: (HelixHeadlessCanvas["usingLabel"]) | undefined;
+  /** The line shown while the board, with `gestures="activate"`, has the gestures. */
+  usingLabel?: (HelixHeadlessCanvas["usingLabel"]) | undefined;
+  /** The hint shown when the wheel scrolls past the board with
+`gestures="cooperative"`. `{key}` is ⌘ on a Mac and Ctrl elsewhere. */
+  "wheel-hint-label"?: (HelixHeadlessCanvas["wheelHintLabel"]) | undefined;
+  /** The hint shown when the wheel scrolls past the board with
+`gestures="cooperative"`. `{key}` is ⌘ on a Mac and Ctrl elsewhere. */
+  wheelHintLabel?: (HelixHeadlessCanvas["wheelHintLabel"]) | undefined;
+  /** What screen readers hear after a zoom button or key, with `{zoom}` for the
+zoom as a percentage, written the way the element's locale writes one. */
+  "zoomed-label"?: (HelixHeadlessCanvas["zoomedLabel"]) | undefined;
+  /** What screen readers hear after a zoom button or key, with `{zoom}` for the
+zoom as a percentage, written the way the element's locale writes one. */
+  zoomedLabel?: (HelixHeadlessCanvas["zoomedLabel"]) | undefined;
   /** Which controls to show, as a list such as `pan zoom fullscreen`, or
 `none`. A family can add words of its own.
 
@@ -1600,20 +1824,6 @@ of the frame. The
 stylesheet lays the cluster out by which buttons are in it rather than by
 this attribute, so the two defaults need no rule each. */
   controls?: (HelixHeadlessCanvas["controls"]) | undefined;
-  /** The name of the group of controls, read by screen readers.
-
-Absent is the family's own name for it, "Map controls" or "Board
-controls", which names what the controls drive rather than the
-mechanism. Written here to say it in another language, which every other
-string this surface speaks already allowed and this one did not. */
-  "controls-label"?: (HelixHeadlessCanvas["controlsLabel"]) | undefined;
-  /** The name of the group of controls, read by screen readers.
-
-Absent is the family's own name for it, "Map controls" or "Board
-controls", which names what the controls drive rather than the
-mechanism. Written here to say it in another language, which every other
-string this surface speaks already allowed and this one did not. */
-  controlsLabel?: (HelixHeadlessCanvas["controlsLabel"]) | undefined;
   /** Which corner the controls sit in.
 
 **Configurable because there is no safe default**, which is a collision
@@ -1716,26 +1926,6 @@ at any zoom, and a consumer who wants their own units multiplies by them. */
   "pan-up-label"?: (HelixHeadlessCanvas["panUpLabel"]) | undefined;
   /** The pan up button's label. */
   panUpLabel?: (HelixHeadlessCanvas["panUpLabel"]) | undefined;
-  /** The hint shown when one finger swipes over a surface with
-`gestures="cooperative"`. Absent is the family's own. */
-  "two-finger-hint-label"?: (HelixHeadlessCanvas["twoFingerHintLabel"]) | undefined;
-  /** The hint shown when one finger swipes over a surface with
-`gestures="cooperative"`. Absent is the family's own. */
-  twoFingerHintLabel?: (HelixHeadlessCanvas["twoFingerHintLabel"]) | undefined;
-  /** The line shown while a surface with `gestures="activate"` has the
-gestures. Absent is the family's own. */
-  "using-label"?: (HelixHeadlessCanvas["usingLabel"]) | undefined;
-  /** The line shown while a surface with `gestures="activate"` has the
-gestures. Absent is the family's own. */
-  usingLabel?: (HelixHeadlessCanvas["usingLabel"]) | undefined;
-  /** The hint shown when the wheel scrolls past a surface with
-`gestures="cooperative"`, with `{key}`, which is ⌘ on a Mac and Ctrl
-elsewhere. Absent is the family's own. */
-  "wheel-hint-label"?: (HelixHeadlessCanvas["wheelHintLabel"]) | undefined;
-  /** The hint shown when the wheel scrolls past a surface with
-`gestures="cooperative"`, with `{key}`, which is ⌘ on a Mac and Ctrl
-elsewhere. Absent is the family's own. */
-  wheelHintLabel?: (HelixHeadlessCanvas["wheelHintLabel"]) | undefined;
   /** The zoom in button's label. */
   "zoom-in-label"?: (HelixHeadlessCanvas["zoomInLabel"]) | undefined;
   /** The zoom in button's label. */
@@ -2222,9 +2412,8 @@ nothing for `them`. */
   "failed-label"?: (HelixHeadlessChatMessage["failedLabel"]) | undefined;
   /** Label for a message that did not send. */
   failedLabel?: (HelixHeadlessChatMessage["failedLabel"]) | undefined;
-  /** Locale for the timestamp.
-
-Empty is the runtime's own. */
+  /** The locale the timestamp and the words are in, as a BCP 47 tag such as
+`de`. Empty reads the nearest `lang`, then the browser's language. */
   locale?: (HelixHeadlessChatMessage["locale"]) | undefined;
   /** Label for the retry button on a failed message. */
   "retry-label"?: (HelixHeadlessChatMessage["retryLabel"]) | undefined;
@@ -2301,6 +2490,24 @@ set.
 attribute could not say that: it is true by being there, whatever it holds,
 so a default of true had no attribute that turned it off. */
   defaultPinned?: (HelixHeadlessChat["defaultPinned"]) | undefined;
+  /** What a turn from `turns` that did not send says, and what a screen reader
+hears before its words. A turn you write as a child says its own
+`failed-label`. */
+  "failed-label"?: (HelixHeadlessChat["failedLabel"]) | undefined;
+  /** What a turn from `turns` that did not send says, and what a screen reader
+hears before its words. A turn you write as a child says its own
+`failed-label`. */
+  failedLabel?: (HelixHeadlessChat["failedLabel"]) | undefined;
+  /** What a screen reader hears for a turn that did not send. `{failed}` is the
+turn's `failed-label` and `{text}` is its words. */
+  "failed-turn-label"?: (HelixHeadlessChat["failedTurnLabel"]) | undefined;
+  /** What a screen reader hears for a turn that did not send. `{failed}` is the
+turn's `failed-label` and `{text}` is its words. */
+  failedTurnLabel?: (HelixHeadlessChat["failedTurnLabel"]) | undefined;
+  /** The conversation's name, read by screen readers, where `label` is empty. */
+  "fallback-label"?: (HelixHeadlessChat["fallbackLabel"]) | undefined;
+  /** The conversation's name, read by screen readers, where `label` is empty. */
+  fallbackLabel?: (HelixHeadlessChat["fallbackLabel"]) | undefined;
   /** Whether there are older turns to load, and whether they are loading.
 
 `more` makes reaching the top fire `helix-history`, once per arrival;
@@ -2428,6 +2635,14 @@ Read from the boxes once they are known, so a box a script ticks directly
 is in it at once. Written, it is pushed onto the boxes. A box whose value
 holds a comma cannot be named here: use `values`. */
   value?: (HelixHeadlessCheckboxGroup["value"]) | undefined;
+  /** The message reported when the field is required and no box is ticked.
+Absent, or empty, is this sentence, or the words registered for the page's
+locale. */
+  "value-missing-message"?: (HelixHeadlessCheckboxGroup["valueMissingMessage"]) | undefined;
+  /** The message reported when the field is required and no box is ticked.
+Absent, or empty, is this sentence, or the words registered for the page's
+locale. */
+  valueMissingMessage?: (HelixHeadlessCheckboxGroup["valueMissingMessage"]) | undefined;
   /**  */
   "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
@@ -2440,24 +2655,6 @@ browser's message. */
   label?: (HelixHeadlessCheckboxGroup["label"]) | undefined;
   /** Whether the field needs a value before the form can submit. */
   required?: (HelixHeadlessCheckboxGroup["required"]) | undefined;
-  /** The message shown when the field is required and empty.
-
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
-and this one was the English a form in another language still spoke in
-the bubble it raises on submit: `feedback` replaces the message under
-the field and does not reach that one. */
-  "value-missing-message"?: (HelixHeadlessCheckboxGroup["valueMissingMessage"]) | undefined;
-  /** The message shown when the field is required and empty.
-
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
-and this one was the English a form in another language still spoke in
-the bubble it raises on submit: `feedback` replaces the message under
-the field and does not reach that one. */
-  valueMissingMessage?: (HelixHeadlessCheckboxGroup["valueMissingMessage"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -2520,6 +2717,14 @@ reads it as `:state(indeterminate)`. */
   indeterminate?: (HelixHeadlessCheckbox["indeterminate"]) | undefined;
   /** The value submitted when the box is checked. */
   value?: (HelixHeadlessCheckbox["value"]) | undefined;
+  /** The message reported when the field is required and the box is not ticked.
+Absent, or empty, is this sentence, or the words registered for the page's
+locale. */
+  "value-missing-message"?: (HelixHeadlessCheckbox["valueMissingMessage"]) | undefined;
+  /** The message reported when the field is required and the box is not ticked.
+Absent, or empty, is this sentence, or the words registered for the page's
+locale. */
+  valueMissingMessage?: (HelixHeadlessCheckbox["valueMissingMessage"]) | undefined;
   /** Whether the control is checked.
 
 One property rather than two. Writing always applies;
@@ -2571,24 +2776,6 @@ browser's message. */
   label?: (HelixHeadlessCheckbox["label"]) | undefined;
   /** Whether the field needs a value before the form can submit. */
   required?: (HelixHeadlessCheckbox["required"]) | undefined;
-  /** The message shown when the field is required and empty.
-
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
-and this one was the English a form in another language still spoke in
-the bubble it raises on submit: `feedback` replaces the message under
-the field and does not reach that one. */
-  "value-missing-message"?: (HelixHeadlessCheckbox["valueMissingMessage"]) | undefined;
-  /** The message shown when the field is required and empty.
-
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
-and this one was the English a form in another language still spoke in
-the bubble it raises on submit: `feedback` replaces the message under
-the field and does not reach that one. */
-  valueMissingMessage?: (HelixHeadlessCheckbox["valueMissingMessage"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -2638,15 +2825,21 @@ export type HelixHeadlessCodeBlockVueProps = {
   /** The copy button's name and tooltip text before a copy.
 
 Where the block has a name, the button says it too, such as "Copy code,
-app.ts", so each copy button on a page with several blocks is told apart.
-In a diff, that is each file's own name. */
+app.ts", as `copy-name-label` puts it, so each copy button on a page with
+several blocks is told apart. In a diff, that is each file's own name. */
   "copy-label"?: (HelixHeadlessCodeBlock["copyLabel"]) | undefined;
   /** The copy button's name and tooltip text before a copy.
 
 Where the block has a name, the button says it too, such as "Copy code,
-app.ts", so each copy button on a page with several blocks is told apart.
-In a diff, that is each file's own name. */
+app.ts", as `copy-name-label` puts it, so each copy button on a page with
+several blocks is told apart. In a diff, that is each file's own name. */
   copyLabel?: (HelixHeadlessCodeBlock["copyLabel"]) | undefined;
+  /** The copy button's name and tooltip text before a copy, where the block
+has a name. `{copy}` is `copy-label` and `{name}` the block's name. */
+  "copy-name-label"?: (HelixHeadlessCodeBlock["copyNameLabel"]) | undefined;
+  /** The copy button's name and tooltip text before a copy, where the block
+has a name. `{copy}` is `copy-label` and `{name}` the block's name. */
+  copyNameLabel?: (HelixHeadlessCodeBlock["copyNameLabel"]) | undefined;
   /** Whether the content is a unified diff, drawn as the lines it changed.
 
 Reflected, because the stylesheet paints a diff differently from code, and
@@ -2663,16 +2856,18 @@ block lays out. Not for a diff, whose files each scroll on their own. */
   "expand-label"?: (HelixHeadlessCodeBlock["expandLabel"]) | undefined;
   /** The expand button's words while the cap hides lines. */
   expandLabel?: (HelixHeadlessCodeBlock["expandLabel"]) | undefined;
-  /** The block's name, usually a file name or a language.
+  /** The block's name, usually a file name, drawn in the header.
 
-In a diff, each file is named from the patch, and this names a patch that
-carries no name of its own. */
+Absent, the block is named by `language` where there is one. In a diff,
+each file is named from the patch, and this names a patch that carries no
+name of its own. */
   label?: (HelixHeadlessCodeBlock["label"]) | undefined;
   /** The language the code is written in, such as `ts` or `css`, handed to
 `highlight` as its second argument.
 
-Absent hands it an empty string. It draws nothing of its own: the block's
-name is `label`. */
+A block with no `label` is named by it, in the header and on the copy
+button, as a docs site names a snippet by its language. Absent hands
+`highlight` an empty string and names nothing. */
   language?: (HelixHeadlessCodeBlock["language"]) | undefined;
   /** Whether the lines are numbered in a gutter beside the code.
 
@@ -2840,6 +3035,14 @@ Date Input and Time Input. */
   readOnly?: (HelixHeadlessColorInput["readOnly"]) | undefined;
   /** Colors offered under the picker, as a comma-separated list. */
   swatches?: (HelixHeadlessColorInput["swatches"]) | undefined;
+  /** What the swatch says in `variant="swatch"`, after the field's label, once
+there is a color. `{name}` is the color's name, such as "vibrant red", and
+`{value}` the value as written. */
+  "swatch-label"?: (HelixHeadlessColorInput["swatchLabel"]) | undefined;
+  /** What the swatch says in `variant="swatch"`, after the field's label, once
+there is a color. `{name}` is the color's name, such as "vibrant red", and
+`{value}` the value as written. */
+  swatchLabel?: (HelixHeadlessColorInput["swatchLabel"]) | undefined;
   /** Accessible name for the control that opens the panel. */
   "trigger-label"?: (HelixHeadlessColorInput["triggerLabel"]) | undefined;
   /** Accessible name for the control that opens the panel. */
@@ -2925,18 +3128,22 @@ browser's message. */
   required?: (HelixHeadlessColorInput["required"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   "value-missing-message"?: (HelixHeadlessColorInput["valueMissingMessage"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
@@ -3239,6 +3446,22 @@ into. */
   "saturation-label"?: (HelixHeadlessColorPicker["saturationLabel"]) | undefined;
   /** What the square's horizontal ramp is called. */
   saturationLabel?: (HelixHeadlessColorPicker["saturationLabel"]) | undefined;
+  /** What a screen reader hears for the square's place, the color's two
+numbers and its name, on whichever of its two inputs it is on.
+`{first}` is `saturation` or `brightness`, the input's own channel, which
+is said first, so each order is its whole sentence. `{saturation}` and
+`{brightness}` are shares from 0 to 1, written as percentages with
+`number, percent`, `{saturationLabel}` and `{brightnessLabel}` the
+channels' names, and `{name}` the color's, such as "vibrant red". */
+  "square-text"?: (HelixHeadlessColorPicker["squareText"]) | undefined;
+  /** What a screen reader hears for the square's place, the color's two
+numbers and its name, on whichever of its two inputs it is on.
+`{first}` is `saturation` or `brightness`, the input's own channel, which
+is said first, so each order is its whole sentence. `{saturation}` and
+`{brightness}` are shares from 0 to 1, written as percentages with
+`number, percent`, `{saturationLabel}` and `{brightnessLabel}` the
+channels' names, and `{name}` the color's, such as "vibrant red". */
+  squareText?: (HelixHeadlessColorPicker["squareText"]) | undefined;
   /** Colors offered under the picker, as a comma-separated list. */
   swatches?: (HelixHeadlessColorPicker["swatches"]) | undefined;
   /** What the group holding the eyedropper and the syntax toggle is called. */
@@ -3253,13 +3476,15 @@ into. */
 
 **Every sentence a control raises in the browser's bubble is a property**,
 named for the validity flag it reports, so a form in another language
-speaks it. Absent is the control's own sentence, in English. */
+speaks it. Unset is the sentence registered for the page's language, then
+the English. */
   "value-missing-message"?: (HelixHeadlessColorPicker["valueMissingMessage"]) | undefined;
   /** The message shown when a color is required and none is chosen.
 
 **Every sentence a control raises in the browser's bubble is a property**,
 named for the validity flag it reports, so a form in another language
-speaks it. Absent is the control's own sentence, in English. */
+speaks it. Unset is the sentence registered for the page's language, then
+the English. */
   valueMissingMessage?: (HelixHeadlessColorPicker["valueMissingMessage"]) | undefined;
   /** Draws the hue as a wheel around the square, in place of the hue ramp, as
 React Aria's ColorWheel sits round its ColorArea.
@@ -3386,12 +3611,19 @@ leaves the field or presses Enter with nothing highlighted, and text that
 names an option takes that option. Unlike `creatable`, no event asks
 first and no option is expected to be added: the value is the text. */
   allowsCustomValue?: (HelixHeadlessCombobox["allowsCustomValue"]) | undefined;
-  /** What the browser may autofill in the text field, as a platform token.
+  /** What the browser may autofill, as a platform token such as `country`.
 
 **Defaults to `off`, which is not the platform's default and is the
 point.** The field filters a list rather than collecting a value, so a
 browser offering to fill it with a saved address is competing for the same
-keystrokes as the listbox. A consumer who wants autofill can still ask. */
+keystrokes as the listbox. A consumer who wants autofill can still ask.
+
+Set, a combobox whose answer is one of its options keeps a hidden native
+`<select>` with the same options for the browser to fill, as React Aria's
+combobox and Select do, and the option the browser picks, by its value or
+its words, becomes the value. The text field itself stays `off`, so the
+browser fills the answer and not the filter. With `allows-custom-value`
+the token goes on the text field, whose words are the answer. */
   autocomplete?: (HelixHeadlessCombobox["autocomplete"]) | undefined;
   /** Whether the user can add a value that is not in the list.
 
@@ -3401,9 +3633,15 @@ it is offered next to near misses too: a reader typing "Ruby on Rails" with
 halfway through. The arrow keys reach it after the last option, and Enter
 on it adds what was typed. */
   creatable?: (HelixHeadlessCombobox["creatable"]) | undefined;
-  /** The text of the create row, shown before the typed words it adds. */
+  /** The text of the create row. `{value}` is what was typed.
+
+A sentence without `{value}`, such as `Create`, is followed by what was
+typed in quotes, as before `{value}` existed. */
   "create-label"?: (HelixHeadlessCombobox["createLabel"]) | undefined;
-  /** The text of the create row, shown before the typed words it adds. */
+  /** The text of the create row. `{value}` is what was typed.
+
+A sentence without `{value}`, such as `Create`, is followed by what was
+typed in quotes, as before `{value}` existed. */
   createLabel?: (HelixHeadlessCombobox["createLabel"]) | undefined;
   /** Text shown when the filter hides every option. */
   "empty-text"?: (HelixHeadlessCombobox["emptyText"]) | undefined;
@@ -3430,12 +3668,14 @@ every keystroke. See Listbox's `filter-delay`. */
   /** The list's name, read by screen readers. The list has no visible name. */
   listLabel?: (HelixHeadlessCombobox["listLabel"]) | undefined;
   /** What the list says when its options could not be loaded, such as after a
-request to a server fails. Empty is no error. Passed to the list, which
-shows it under any options there are and tells screen readers. */
+request to a server fails. Empty, null or no attribute is no error, so
+removing the attribute clears it. Passed to the list, which shows it
+under any options there are and tells screen readers. */
   "load-error"?: (HelixHeadlessCombobox["loadError"]) | undefined;
   /** What the list says when its options could not be loaded, such as after a
-request to a server fails. Empty is no error. Passed to the list, which
-shows it under any options there are and tells screen readers. */
+request to a server fails. Empty, null or no attribute is no error, so
+removing the attribute clears it. Passed to the list, which shows it
+under any options there are and tells screen readers. */
   loadError?: (HelixHeadlessCombobox["loadError"]) | undefined;
   /** Whether the options are still loading.
 
@@ -3446,6 +3686,10 @@ message belongs. */
   "loading-text"?: (HelixHeadlessCombobox["loadingText"]) | undefined;
   /** Text the list shows while the options load. */
   loadingText?: (HelixHeadlessCombobox["loadingText"]) | undefined;
+  /** The locale the words, plural forms, and numbers are in, as a BCP 47 tag
+such as `pl`. Empty reads the nearest `lang`, then the browser's
+language. */
+  locale?: (HelixHeadlessCombobox["locale"]) | undefined;
   /** Whether more than one option can be chosen.
 
 The list already does the work: `value` comes apart on commas, a press
@@ -3504,20 +3748,28 @@ filled in.
 **The name goes in**, so a row of them is heard as which one each
 removes rather than as "Remove" said once per chosen option. */
   removeLabel?: (HelixHeadlessCombobox["removeLabel"]) | undefined;
-  /** What a screen reader hears when typing leaves one option. `{count}` is
-the count. */
+  /** What a screen reader hears when typing leaves one option, where
+`results-label` should not say it. `{count}` is the count. */
   "result-label"?: (HelixHeadlessCombobox["resultLabel"]) | undefined;
-  /** What a screen reader hears when typing leaves one option. `{count}` is
-the count. */
+  /** What a screen reader hears when typing leaves one option, where
+`results-label` should not say it. `{count}` is the count. */
   resultLabel?: (HelixHeadlessCombobox["resultLabel"]) | undefined;
-  /** What a screen reader hears when typing leaves any other number of
-options. `{count}` is the count, and `Intl.PluralRules` picks between the
-two. */
+  /** What a screen reader hears when typing narrows the list. `{count}` is how
+many options are left, written in the locale, and each language writes
+the forms it has: `{count, plural, one {# wynik} few {# wyniki} many
+{# wyników} other {# wyniku}}`. */
   "results-label"?: (HelixHeadlessCombobox["resultsLabel"]) | undefined;
-  /** What a screen reader hears when typing leaves any other number of
-options. `{count}` is the count, and `Intl.PluralRules` picks between the
-two. */
+  /** What a screen reader hears when typing narrows the list. `{count}` is how
+many options are left, written in the locale, and each language writes
+the forms it has: `{count, plural, one {# wynik} few {# wyniki} many
+{# wyników} other {# wyniku}}`. */
   resultsLabel?: (HelixHeadlessCombobox["resultsLabel"]) | undefined;
+  /** What VoiceOver hears for a chosen option, as the highlight reaches it and
+once it is chosen, on Apple devices. `{name}` is the option's words. */
+  "selected-label"?: (HelixHeadlessCombobox["selectedLabel"]) | undefined;
+  /** What VoiceOver hears for a chosen option, as the highlight reaches it and
+once it is chosen, on Apple devices. `{name}` is the option's words. */
+  selectedLabel?: (HelixHeadlessCombobox["selectedLabel"]) | undefined;
   /** Whether the field completes the word as the user types.
 
 `suggest` rather than `autocomplete`, which is a real HTML attribute this
@@ -3525,6 +3777,14 @@ element already sets on the input it renders, and two things of one name
 meaning different things on the same control is a question a consumer
 should not have to ask. */
   suggest?: (HelixHeadlessCombobox["suggest"]) | undefined;
+  /** The message reported when the field is required and nothing is chosen.
+Absent, or empty, is this sentence, or the words registered for the page's
+locale. */
+  "value-missing-message"?: (HelixHeadlessCombobox["valueMissingMessage"]) | undefined;
+  /** The message reported when the field is required and nothing is chosen.
+Absent, or empty, is this sentence, or the words registered for the page's
+locale. */
+  valueMissingMessage?: (HelixHeadlessCombobox["valueMissingMessage"]) | undefined;
   /** Whether the element starts open. Ignored once `open` is written. */
   "default-open"?: (HelixHeadlessCombobox["defaultOpen"]) | undefined;
   /** Whether the element starts open. Ignored once `open` is written. */
@@ -3558,6 +3818,12 @@ as `+3`, does not say what it does. */
   "max-tags"?: (HelixHeadlessCombobox["maxTags"] | `${number}`) | undefined;
   /** How many tokens to show before the rest become a count. */
   maxTags?: (HelixHeadlessCombobox["maxTags"]) | undefined;
+  /** The count of the tokens past `max-tags`, as it is shown, with `{count}`
+for the number, written in the element's locale. */
+  "rest-text"?: (HelixHeadlessCombobox["restText"]) | undefined;
+  /** The count of the tokens past `max-tags`, as it is shown, with `{count}`
+for the number, written in the element's locale. */
+  restText?: (HelixHeadlessCombobox["restText"]) | undefined;
   /** The value the control starts with. A form reset returns it to this value,
 and to the `value` attribute where this one is not written, as a native
 control resets to the `value` it declares. */
@@ -3585,24 +3851,6 @@ browser's message. */
   label?: (HelixHeadlessCombobox["label"]) | undefined;
   /** Whether the field needs a value before the form can submit. */
   required?: (HelixHeadlessCombobox["required"]) | undefined;
-  /** The message shown when the field is required and empty.
-
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
-and this one was the English a form in another language still spoke in
-the bubble it raises on submit: `feedback` replaces the message under
-the field and does not reach that one. */
-  "value-missing-message"?: (HelixHeadlessCombobox["valueMissingMessage"]) | undefined;
-  /** The message shown when the field is required and empty.
-
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
-and this one was the English a form in another language still spoke in
-the bubble it raises on submit: `feedback` replaces the message under
-the field and does not reach that one. */
-  valueMissingMessage?: (HelixHeadlessCombobox["valueMissingMessage"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -3707,12 +3955,14 @@ with: one key, said once. */
   /** Accessible name for the overlay, which has no visible heading. */
   label?: (HelixHeadlessCommand["label"]) | undefined;
   /** What the list says when its commands could not be loaded, such as after a
-request to a server fails. Empty is no error. Passed to the list, which
-shows it under any commands there are and tells screen readers. */
+request to a server fails. Empty, null or no attribute is no error, so
+removing the attribute clears it. Passed to the list, which shows it
+under any commands there are and tells screen readers. */
   "load-error"?: (HelixHeadlessCommand["loadError"]) | undefined;
   /** What the list says when its commands could not be loaded, such as after a
-request to a server fails. Empty is no error. Passed to the list, which
-shows it under any commands there are and tells screen readers. */
+request to a server fails. Empty, null or no attribute is no error, so
+removing the attribute clears it. Passed to the list, which shows it
+under any commands there are and tells screen readers. */
   loadError?: (HelixHeadlessCommand["loadError"]) | undefined;
   /** Whether the commands are still loading, for a palette that asks a server
 for them as the user types.
@@ -3731,19 +3981,21 @@ some. Absent, `empty-text` shows. See Listbox's `no-results-text`. */
   noResultsText?: (HelixHeadlessCommand["noResultsText"]) | undefined;
   /** The text shown in the filter field before anything is typed. */
   placeholder?: (HelixHeadlessCommand["placeholder"]) | undefined;
-  /** What a screen reader hears when typing leaves one command. `{count}` is
-the count. */
+  /** What a screen reader hears when typing leaves one command, where
+`results-label` should not say it. `{count}` is the count. */
   "result-label"?: (HelixHeadlessCommand["resultLabel"]) | undefined;
-  /** What a screen reader hears when typing leaves one command. `{count}` is
-the count. */
+  /** What a screen reader hears when typing leaves one command, where
+`results-label` should not say it. `{count}` is the count. */
   resultLabel?: (HelixHeadlessCommand["resultLabel"]) | undefined;
-  /** What a screen reader hears when typing leaves any other number of
-commands. `{count}` is the count, and `Intl.PluralRules` picks between the
-two. */
+  /** What a screen reader hears when typing narrows the commands. `{count}` is
+how many are left, written in the locale, and each language writes the
+forms it has: `{count, plural, one {# polecenie} few {# polecenia} many
+{# poleceń} other {# polecenia}}`. */
   "results-label"?: (HelixHeadlessCommand["resultsLabel"]) | undefined;
-  /** What a screen reader hears when typing leaves any other number of
-commands. `{count}` is the count, and `Intl.PluralRules` picks between the
-two. */
+  /** What a screen reader hears when typing narrows the commands. `{count}` is
+how many are left, written in the locale, and each language writes the
+forms it has: `{count, plural, one {# polecenie} few {# polecenia} many
+{# poleceń} other {# polecenia}}`. */
   resultsLabel?: (HelixHeadlessCommand["resultsLabel"]) | undefined;
   /** Whether the element starts open. Ignored once `open` is written. */
   "default-open"?: (HelixHeadlessCommand["defaultOpen"]) | undefined;
@@ -3915,6 +4167,9 @@ export type HelixHeadlessDataTableElementEvent<E = Event> = TypedEvent<
 /** `helix-activate` event type */
 export type HelixHeadlessDataTableHelixActivateElementEvent =
   HelixHeadlessDataTableElementEvent<HelixActivateEvent>;
+/** `helix-before-reorder` event type */
+export type HelixHeadlessDataTableHelixBeforeReorderElementEvent =
+  HelixHeadlessDataTableElementEvent<HelixBeforeReorderEvent>;
 /** `helix-expand` event type */
 export type HelixHeadlessDataTableHelixExpandElementEvent =
   HelixHeadlessDataTableElementEvent<HelixExpandEvent>;
@@ -3950,10 +4205,16 @@ export type HelixHeadlessDataTableHelixSortedElementEvent =
   HelixHeadlessDataTableElementEvent<HelixSortedEvent>;
 
 export type HelixHeadlessDataTableVueProps = {
-  /** The word for an ascending sort, in `sorted-label`. */
+  /** The word for an ascending sort, in a `sorted-label` that writes `{order}`. */
   "ascending-label"?: (HelixHeadlessDataTable["ascendingLabel"]) | undefined;
-  /** The word for an ascending sort, in `sorted-label`. */
+  /** The word for an ascending sort, in a `sorted-label` that writes `{order}`. */
   ascendingLabel?: (HelixHeadlessDataTable["ascendingLabel"]) | undefined;
+  /** What screen readers hear when a held row is put back, or a move is
+refused, with `reorderable-rows`. */
+  "canceled-label"?: (HelixHeadlessDataTable["canceledLabel"]) | undefined;
+  /** What screen readers hear when a held row is put back, or a move is
+refused, with `reorderable-rows`. */
+  canceledLabel?: (HelixHeadlessDataTable["canceledLabel"]) | undefined;
   /** The field that holds a row's child rows, as an array. Set it, and `row-key`,
 and the grid becomes a tree grid.
 
@@ -3998,10 +4259,14 @@ is set. */
   "default-sort"?: (HelixHeadlessDataTable["defaultSort"]) | undefined;
   /** The starting sort order, used until `sort` is set. */
   defaultSort?: (HelixHeadlessDataTable["defaultSort"]) | undefined;
-  /** The word for a descending sort, in `sorted-label`. */
+  /** The word for a descending sort, in a `sorted-label` that writes `{order}`. */
   "descending-label"?: (HelixHeadlessDataTable["descendingLabel"]) | undefined;
-  /** The word for a descending sort, in `sorted-label`. */
+  /** The word for a descending sort, in a `sorted-label` that writes `{order}`. */
   descendingLabel?: (HelixHeadlessDataTable["descendingLabel"]) | undefined;
+  /** What screen readers hear when a row is dropped, with `reorderable-rows`. */
+  "dropped-label"?: (HelixHeadlessDataTable["droppedLabel"]) | undefined;
+  /** What screen readers hear when a row is dropped, with `reorderable-rows`. */
+  droppedLabel?: (HelixHeadlessDataTable["droppedLabel"]) | undefined;
   /** The estimated height of a row before it is drawn, in pixels.
 
 Only read while `windowed`, and a starting guess rather than a claim: a
@@ -4043,6 +4308,10 @@ when there are no more rows to load. */
   "load-more-label"?: (HelixHeadlessDataTable["loadMoreLabel"]) | undefined;
   /** The words on the button in the `more` row. */
   loadMoreLabel?: (HelixHeadlessDataTable["loadMoreLabel"]) | undefined;
+  /** The locale the words, plural forms, and numbers are in, as a BCP 47 tag
+such as `pl`. Empty reads the nearest `lang`, then the browser's
+language. The built-in pagination speaks it too. */
+  locale?: (HelixHeadlessDataTable["locale"]) | undefined;
   /** Where filtering, sorting, and paging happen. `client` does them in the
 table, and `server` leaves them to your code.
 
@@ -4053,6 +4322,20 @@ the client cannot hold the data, so this is not an optimization, it is the
 only mode that works, and it is here from the start because adding it later
 inverts the data flow. */
   mode?: (HelixHeadlessDataTable["mode"]) | undefined;
+  /** What screen readers hear each time a key moves a held row, with
+`reorderable-rows`. `{name}` is the row's name, `{position}` the place it
+would go, counting from 1, and `{count}` the number of rows on the page. */
+  "moved-label"?: (HelixHeadlessDataTable["movedLabel"]) | undefined;
+  /** What screen readers hear each time a key moves a held row, with
+`reorderable-rows`. `{name}` is the row's name, `{position}` the place it
+would go, counting from 1, and `{count}` the number of rows on the page. */
+  movedLabel?: (HelixHeadlessDataTable["movedLabel"]) | undefined;
+  /** The name of a row's grip, with `reorderable-rows`. `{row}` is replaced with
+the row's name. */
+  "move-row-label"?: (HelixHeadlessDataTable["moveRowLabel"]) | undefined;
+  /** The name of a row's grip, with `reorderable-rows`. `{row}` is replaced with
+the row's name. */
+  moveRowLabel?: (HelixHeadlessDataTable["moveRowLabel"]) | undefined;
   /** The built-in pagination's name for the button that moves forward a page. */
   "next-label"?: (HelixHeadlessDataTable["nextLabel"]) | undefined;
   /** The built-in pagination's name for the button that moves forward a page. */
@@ -4104,6 +4387,12 @@ which is why the slot replaces this rather than sitting beside it. */
   "pagination-label"?: (HelixHeadlessDataTable["paginationLabel"]) | undefined;
   /** The name of the built-in pagination's navigation landmark. */
   paginationLabel?: (HelixHeadlessDataTable["paginationLabel"]) | undefined;
+  /** What screen readers hear when a key or a click picks up a row, with
+`reorderable-rows`. `{name}` is the row's name. */
+  "picked-up-label"?: (HelixHeadlessDataTable["pickedUpLabel"]) | undefined;
+  /** What screen readers hear when a key or a click picks up a row, with
+`reorderable-rows`. `{name}` is the row's name. */
+  pickedUpLabel?: (HelixHeadlessDataTable["pickedUpLabel"]) | undefined;
   /** The built-in pagination's name for the button that moves back a page. */
   "previous-label"?: (HelixHeadlessDataTable["previousLabel"]) | undefined;
   /** The built-in pagination's name for the button that moves back a page. */
@@ -4113,16 +4402,32 @@ which is why the slot replaces this rather than sitting beside it. */
 Each heading with a `field` gets a grip, dragged along the header or moved a
 place at a time with the arrow keys once it has focus. */
   reorderable?: (HelixHeadlessDataTable["reorderable"]) | undefined;
-  /** What screen readers hear when a search leaves one row. `{count}` is the count. */
+  /** Lets people move rows, by a grip that leads each row. The table moves no
+row itself: set `rows` to the order `helix-reorder` carries. */
+  "reorderable-rows"?: (HelixHeadlessDataTable["reorderableRows"]) | undefined;
+  /** Lets people move rows, by a grip that leads each row. The table moves no
+row itself: set `rows` to the order `helix-reorder` carries. */
+  reorderableRows?: (HelixHeadlessDataTable["reorderableRows"]) | undefined;
+  /** What screen readers hear when a search leaves one row, where
+`results-label` should not say it. `{count}` is the count. */
   "result-label"?: (HelixHeadlessDataTable["resultLabel"]) | undefined;
-  /** What screen readers hear when a search leaves one row. `{count}` is the count. */
+  /** What screen readers hear when a search leaves one row, where
+`results-label` should not say it. `{count}` is the count. */
   resultLabel?: (HelixHeadlessDataTable["resultLabel"]) | undefined;
-  /** What screen readers hear when a search leaves any other number of rows.
-`{count}` is the count. */
+  /** What screen readers hear when a search narrows the rows. `{count}` is how
+many rows are left, written in the locale, and each language writes the
+forms it has: `{count, plural, one {# wiersz} few {# wiersze} many
+{# wierszy} other {# wiersza}}`. */
   "results-label"?: (HelixHeadlessDataTable["resultsLabel"]) | undefined;
-  /** What screen readers hear when a search leaves any other number of rows.
-`{count}` is the count. */
+  /** What screen readers hear when a search narrows the rows. `{count}` is how
+many rows are left, written in the locale, and each language writes the
+forms it has: `{count, plural, one {# wiersz} few {# wiersze} many
+{# wierszy} other {# wiersza}}`. */
   resultsLabel?: (HelixHeadlessDataTable["resultsLabel"]) | undefined;
+  /** The name of the heading over the row grips, with `reorderable-rows`. */
+  "row-grips-label"?: (HelixHeadlessDataTable["rowGripsLabel"]) | undefined;
+  /** The name of the heading over the row grips, with `reorderable-rows`. */
+  rowGripsLabel?: (HelixHeadlessDataTable["rowGripsLabel"]) | undefined;
   /** The field that identifies each row.
 
 **Needed before selection exists, not after.** Lit keys the rendered rows by
@@ -4167,10 +4472,14 @@ price of the shape. A reader's choice fires `helix-select` first, and
 refusing it leaves the selection as it was. */
   selected?: (HelixHeadlessDataTable["selected"]) | undefined;
   /** What screen readers hear when the chosen rows change. `{count}` is how many
-rows are chosen. */
+rows are chosen, written in the locale, and a language that needs plural
+forms writes them: `{count, plural, one {# wybrany} few {# wybrane} many
+{# wybranych} other {# wybranego}}`. */
   "selected-label"?: (HelixHeadlessDataTable["selectedLabel"]) | undefined;
   /** What screen readers hear when the chosen rows change. `{count}` is how many
-rows are chosen. */
+rows are chosen, written in the locale, and a language that needs plural
+forms writes them: `{count, plural, one {# wybrany} few {# wybrane} many
+{# wybranych} other {# wybranego}}`. */
   selectedLabel?: (HelixHeadlessDataTable["selectedLabel"]) | undefined;
   /** The name of a row's checkbox. `{row}` is replaced with the row's value in
 the first column that has a field, or with its key. */
@@ -4186,10 +4495,14 @@ the event and set this to the order you chose. `default-sort` seeds an
 order this element then owns. */
   sort?: (HelixHeadlessDataTable["sort"]) | undefined;
   /** What screen readers hear when the table is sorted. `{column}` is the
-column's heading and `{order}` is `ascending-label` or `descending-label`. */
+column's heading and `{direction}` is `ascending` or `descending`, so each
+order has its whole sentence. `{order}` is the deprecated
+`ascending-label` or `descending-label`. */
   "sorted-label"?: (HelixHeadlessDataTable["sortedLabel"]) | undefined;
   /** What screen readers hear when the table is sorted. `{column}` is the
-column's heading and `{order}` is `ascending-label` or `descending-label`. */
+column's heading and `{direction}` is `ascending` or `descending`, so each
+order has its whole sentence. `{order}` is the deprecated
+`ascending-label` or `descending-label`. */
   sortedLabel?: (HelixHeadlessDataTable["sortedLabel"]) | undefined;
   /** The number of rows in the whole result, for when the table cannot count
 them.
@@ -4250,6 +4563,8 @@ holds and reordering it under them is a mutation they did not ask for. */
 export type HelixHeadlessDataTableVueEvents = {
   /** Fired after the page changes, with the new page as a string in `detail.value`. */
   "helix-activate": HelixHeadlessDataTableHelixActivateElementEvent;
+  /** A row is about to move, with `reorderable-rows`. The event carries every row's key in the new order. Cancelable: cancel it to keep the row where it is. */
+  "helix-before-reorder": HelixHeadlessDataTableHelixBeforeReorderElementEvent;
   /** Fired after a row opens or closes, with every open row's key, separated by commas, which `expanded` also holds. */
   "helix-expand": HelixHeadlessDataTableHelixExpandElementEvent;
   /** The search query is about to change. Cancelable: cancel it to keep the current query. */
@@ -4260,7 +4575,7 @@ export type HelixHeadlessDataTableVueEvents = {
   "helix-load-more": HelixHeadlessDataTableHelixLoadMoreElementEvent;
   /** Another page was requested. Cancelable: cancel it to stay on the current page. */
   "helix-navigate": HelixHeadlessDataTableHelixNavigateElementEvent;
-  /** The columns are about to move. The event carries every field in the new order. Cancelable: cancel it to keep the current order. */
+  /** The columns are about to move, with `kind` set to `column` and every field in the new order. Cancelable: cancel it to keep the current order. For a row, with `kind` set to `row`, it follows `helix-before-reorder`, and you set `rows` to the order in `keys`. */
   "helix-reorder": HelixHeadlessDataTableHelixReorderElementEvent;
   /** Fired after the columns move, with every field in the new order. */
   "helix-reordered": HelixHeadlessDataTableHelixReorderedElementEvent;
@@ -4299,6 +4614,15 @@ Empty leaves the attribute off, which is the browser's default and is what
 lets autofill work at all: hardcoding `off` here means a birthday or a
 postal code can never be filled in for a reader. */
   autocomplete?: (HelixHeadlessDateInput["autocomplete"]) | undefined;
+  /** The calendar the written date and the calendar's days are in: `gregory`,
+`buddhist`, `japanese`, `roc`, or `iso8601`.
+
+Absent is the locale's own where it is one of the five, and `gregory` for
+every other, as Date Picker's `calendar` is. The value is `YYYY-MM-DD` in
+every calendar, and a focused field is ISO in every calendar. In
+`segmented`, the segments are the Gregorian day, month, and year, in the
+order the locale writes them, or ISO order for `iso8601`. */
+  calendar?: (HelixHeadlessDateInput["calendar"]) | undefined;
   /** The name of the calendar's grid of days, read by screen readers. */
   "calendar-label"?: (HelixHeadlessDateInput["calendarLabel"]) | undefined;
   /** The name of the calendar's grid of days, read by screen readers. */
@@ -4437,14 +4761,14 @@ window has no room for that width it shows one month until there is. */
   /** The message shown when a range holds more than two dates.
 
 **Every sentence a control raises in the browser's bubble is a property**,
-so a form in another language speaks it. Absent is the control's own
-sentence, in English. */
+so a form in another language speaks it. Unset is the sentence registered
+for the page's language, then the English. */
   "range-length-message"?: (HelixHeadlessDateInput["rangeLengthMessage"]) | undefined;
   /** The message shown when a range holds more than two dates.
 
 **Every sentence a control raises in the browser's bubble is a property**,
-so a form in another language speaks it. Absent is the control's own
-sentence, in English. */
+so a form in another language speaks it. Unset is the sentence registered
+for the page's language, then the English. */
   rangeLengthMessage?: (HelixHeadlessDateInput["rangeLengthMessage"]) | undefined;
   /** The message shown when a date is after `max`. `{max}` is replaced with
 `max`, written the way the field writes dates. */
@@ -4495,12 +4819,28 @@ platform's base. */
   /** The name of the calendar's heading where it shows a page of years, with
 `{heading}` filled in. */
   yearViewLabel?: (HelixHeadlessDateInput["yearViewLabel"]) | undefined;
+  /** What a row of segments reports when the field is required and every
+segment is empty, where `value-missing-message` is not set. `{kind}` is
+`date` or `time`. */
+  "empty-message"?: (HelixHeadlessDateInput["emptyMessage"]) | undefined;
+  /** What a row of segments reports when the field is required and every
+segment is empty, where `value-missing-message` is not set. `{kind}` is
+`date` or `time`. */
+  emptyMessage?: (HelixHeadlessDateInput["emptyMessage"]) | undefined;
   /** What a screen reader hears for a segment with nothing in it, which a
 sighted reader sees as dashes. */
   "empty-segment-label"?: (HelixHeadlessDateInput["emptySegmentLabel"]) | undefined;
   /** What a screen reader hears for a segment with nothing in it, which a
 sighted reader sees as dashes. */
   emptySegmentLabel?: (HelixHeadlessDateInput["emptySegmentLabel"]) | undefined;
+  /** What a row of segments reports while some segments are set and others
+are not, where `bad-input-message` is not set. `{kind}` is `date` or
+`time`. */
+  "incomplete-message"?: (HelixHeadlessDateInput["incompleteMessage"]) | undefined;
+  /** What a row of segments reports while some segments are set and others
+are not, where `bad-input-message` is not set. `{kind}` is `date` or
+`time`. */
+  incompleteMessage?: (HelixHeadlessDateInput["incompleteMessage"]) | undefined;
   /** Whether the field is a row of segments, one for each part of the date or
 time, in place of a line of text.
 
@@ -4582,6 +4922,12 @@ as `+3`, does not say what it does. */
   "max-tags"?: (HelixHeadlessDateInput["maxTags"] | `${number}`) | undefined;
   /** How many tokens to show before the rest become a count. */
   maxTags?: (HelixHeadlessDateInput["maxTags"]) | undefined;
+  /** The count of the tokens past `max-tags`, as it is shown, with `{count}`
+for the number, written in the element's locale. */
+  "rest-text"?: (HelixHeadlessDateInput["restText"]) | undefined;
+  /** The count of the tokens past `max-tags`, as it is shown, with `{count}`
+for the number, written in the element's locale. */
+  restText?: (HelixHeadlessDateInput["restText"]) | undefined;
   /** The value the control starts with. A form reset returns it to this value,
 and to the `value` attribute where this one is not written, as a native
 control resets to the `value` it declares. */
@@ -4611,18 +4957,22 @@ browser's message. */
   required?: (HelixHeadlessDateInput["required"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   "value-missing-message"?: (HelixHeadlessDateInput["valueMissingMessage"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
@@ -4709,14 +5059,28 @@ export type HelixHeadlessDatePickerVueProps = {
 
 **Every sentence a control raises in the browser's bubble is a property**,
 named for the validity flag it reports, so a form in another language
-speaks it. Absent is the control's own sentence, in English. */
+speaks it. Unset is the sentence registered for the page's language, then
+the English. `{mode}` is `single`, `range` or `multiple`, so each can have
+its own sentence. */
   "bad-input-message"?: (HelixHeadlessDatePicker["badInputMessage"]) | undefined;
   /** The validation message for a value that is not a date.
 
 **Every sentence a control raises in the browser's bubble is a property**,
 named for the validity flag it reports, so a form in another language
-speaks it. Absent is the control's own sentence, in English. */
+speaks it. Unset is the sentence registered for the page's language, then
+the English. `{mode}` is `single`, `range` or `multiple`, so each can have
+its own sentence. */
   badInputMessage?: (HelixHeadlessDatePicker["badInputMessage"]) | undefined;
+  /** The calendar the heading, the days, and the months are written in:
+`gregory`, `buddhist`, `japanese`, `roc`, or `iso8601`, the five whose
+months are the Gregorian months.
+
+Absent is the locale's own where it is one of the five, such as
+`buddhist` for `th-TH` or `japanese` for `ja-JP-u-ca-japanese`, and
+`gregory` for every other, such as `persian` for `fa-IR`, so the heading
+names the Gregorian month the grid shows. The value is `YYYY-MM-DD` in
+every calendar. */
+  calendar?: (HelixHeadlessDatePicker["calendar"]) | undefined;
   /** The month to open on when `month` is not set. */
   "default-month"?: (HelixHeadlessDatePicker["defaultMonth"]) | undefined;
   /** The month to open on when `month` is not set. */
@@ -5093,6 +5457,12 @@ interface. */
   /** The close control's accessible name. Translate it with the rest of your
 interface. */
   dismissLabel?: (HelixHeadlessDialog["dismissLabel"]) | undefined;
+  /** The dialog's name where nothing names it: no `label`, no heading in the
+`header` slot, and no `aria-labelledby` on the host. */
+  "fallback-label"?: (HelixHeadlessDialog["fallbackLabel"]) | undefined;
+  /** The dialog's name where nothing names it: no `label`, no heading in the
+`header` slot, and no `aria-labelledby` on the host. */
+  fallbackLabel?: (HelixHeadlessDialog["fallbackLabel"]) | undefined;
   /** Accessible name for the dialog. When it is empty, the heading in the
 `header` slot names the dialog. */
   label?: (HelixHeadlessDialog["label"]) | undefined;
@@ -5148,20 +5518,23 @@ export type HelixHeadlessDialogVueEvents = {
 };
 
 export type HelixHeadlessDividerVueProps = {
-  /** Whether screen readers announce the line as a separator.
-
-Off by default, and out of the accessibility tree. Most rules on a page
-separate nothing: they underline a heading or close a section that space
-had already closed, and announcing every one as a separator is noise a
-screen-reader user has to walk past.
-
-An opt-in, not a `decorative` opt-out, because a boolean attribute cannot
-be turned off: `decorative="false"` parses as `true`, which would put the
-quiet default out of reach from HTML and leave it settable only as a
-property. An opt-in is absent by default, which every reflected property
-here has to be. */
+  /** Whether screen readers announce the line as a separator, which they now do
+by default.
+
+It dates from when the line was decorative by default. It is still read,
+and it wins over `decorative`, so a divider written with it stays a
+separator. */
   announced?: (HelixHeadlessDivider["announced"]) | undefined;
-  /** The direction the line runs: `horizontal` or `vertical`. */
+  /** Takes the line out of the accessibility tree, for a rule that separates
+nothing: one under a heading, or between the facts of a byline.
+
+Absent, the line is a separator, as `<hr>` is. Radix Separator's opt-out
+has the same name. It turns the role off because a boolean attribute that
+is on by default cannot be turned off from HTML. */
+  decorative?: (HelixHeadlessDivider["decorative"]) | undefined;
+  /** The direction the line runs: `horizontal` or `vertical`.
+
+Unset is horizontal, or across the toolbar the divider sits in. */
   orientation?: (HelixHeadlessDivider["orientation"]) | undefined;
 };
 
@@ -5249,8 +5622,8 @@ words and is already written. */
   /** The locale the chart's own numbers are written in: its axis, its
 percentages and its totals, such as `de` for `1.240` and `32 %`.
 
-Absent uses the runtime's own. The table's cells are shown as the table
-writes them, whatever this says. */
+Absent reads the nearest `lang`, then the runtime's own. The table's
+cells are shown as the table writes them, whatever this says. */
   locale?: (HelixHeadlessDonutChart["locale"]) | undefined;
   /** Where a reading the keys moved to stands among the readings, said after
 it. `{position}` and `{count}` are replaced with the numbers, written in
@@ -5321,6 +5694,12 @@ interface. */
   /** The close control's accessible name. Translate it with the rest of your
 interface. */
   dismissLabel?: (HelixHeadlessDrawer["dismissLabel"]) | undefined;
+  /** The panel's name where nothing names it: no `label`, no heading in the
+`header` slot, and no `aria-labelledby` on the host. */
+  "fallback-label"?: (HelixHeadlessDrawer["fallbackLabel"]) | undefined;
+  /** The panel's name where nothing names it: no `label`, no heading in the
+`header` slot, and no `aria-labelledby` on the host. */
+  fallbackLabel?: (HelixHeadlessDrawer["fallbackLabel"]) | undefined;
   /** Accessible name for the panel. When it is empty, the heading in the
 `header` slot names the panel. */
   label?: (HelixHeadlessDrawer["label"]) | undefined;
@@ -5536,14 +5915,20 @@ filter is the only check the platform makes and a drop never meets it. */
   /** What a reader hears when a drop or a paste adds files, with `{names}` and
 `{count}` filled in. */
   addedText?: (HelixHeadlessFileInput["addedText"]) | undefined;
+  /** A file's size under a kilobyte. `{count}` is how many bytes, written in
+the locale, and each language writes the forms it has. */
+  "bytes-label"?: (HelixHeadlessFileInput["bytesLabel"]) | undefined;
+  /** A file's size under a kilobyte. `{count}` is how many bytes, written in
+the locale, and each language writes the forms it has. */
+  bytesLabel?: (HelixHeadlessFileInput["bytesLabel"]) | undefined;
   /** Which camera or microphone a mobile picker should offer, if any. */
   capture?: (HelixHeadlessFileInput["capture"]) | undefined;
   /** Whether the picker chooses a folder, and the field takes every file in
 it. The platform's `webkitdirectory`. */
   directory?: (HelixHeadlessFileInput["directory"]) | undefined;
-  /** Language tag the sizes are written in.
-
-Absent uses the runtime's own. */
+  /** The locale the words, the sizes, and the numbers and lists in sentences
+are in, as a BCP 47 tag such as `pl`. Empty reads the nearest `lang`, then
+the browser's language. */
   locale?: (HelixHeadlessFileInput["locale"]) | undefined;
   /** The most files the field holds, under `multiple`. Files past it are
 refused. */
@@ -5605,18 +5990,22 @@ browser's message. */
   required?: (HelixHeadlessFileInput["required"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   "value-missing-message"?: (HelixHeadlessFileInput["valueMissingMessage"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
@@ -5682,6 +6071,20 @@ export type HelixHeadlessFilterChipHelixDismissElementEvent =
   HelixHeadlessFilterChipElementEvent<HelixDismissEvent>;
 
 export type HelixHeadlessFilterChipVueProps = {
+  /** The remove button's name, read by screen readers. The chip's own words
+follow it, so several chips are told apart.
+
+"Remove filter" rather than the mixin's "Dismiss", for the reason `Tag`
+gives its own: taking a filter out of a set is a different act from
+closing a message. */
+  "dismiss-label"?: (HelixHeadlessFilterChip["dismissLabel"]) | undefined;
+  /** The remove button's name, read by screen readers. The chip's own words
+follow it, so several chips are told apart.
+
+"Remove filter" rather than the mixin's "Dismiss", for the reason `Tag`
+gives its own: taking a filter out of a set is a different act from
+closing a message. */
+  dismissLabel?: (HelixHeadlessFilterChip["dismissLabel"]) | undefined;
   /** The name of the field the filter is on, as shown on the chip.
 
 The slot's fallback rather than the slot's replacement: a consumer who wants
@@ -5730,20 +6133,6 @@ makes an unusual filter look unusual. */
   operatorLabel?: (HelixHeadlessFilterChip["operatorLabel"]) | undefined;
   /** Whether the element shows a control that dismisses it. */
   dismissible?: (HelixHeadlessFilterChip["dismissible"]) | undefined;
-  /** The dismiss control's label, read by screen readers.
-
-`attribute` is spelled out because Lit lowercases a property name to
-derive one rather than dash-casing it, so this would otherwise be
-reachable only as `dismisslabel`, which nobody would guess and no linter
-would catch. */
-  "dismiss-label"?: (HelixHeadlessFilterChip["dismissLabel"]) | undefined;
-  /** The dismiss control's label, read by screen readers.
-
-`attribute` is spelled out because Lit lowercases a property name to
-derive one rather than dash-casing it, so this would otherwise be
-reachable only as `dismisslabel`, which nobody would guess and no linter
-would catch. */
-  dismissLabel?: (HelixHeadlessFilterChip["dismissLabel"]) | undefined;
 };
 
 export type HelixHeadlessFilterChipVueEvents = {
@@ -5893,13 +6282,21 @@ what you slot and you narrow it. */
 
 Not a label: it goes when typing starts. */
   placeholder?: (HelixHeadlessFilterInput["placeholder"]) | undefined;
-  /** What a reader hears for one suggestion, with `{count}` filled in. */
+  /** What a reader hears for one suggestion, where `suggestions-label` should
+not say it. `{count}` is the count. */
   "suggestion-label"?: (HelixHeadlessFilterInput["suggestionLabel"]) | undefined;
-  /** What a reader hears for one suggestion, with `{count}` filled in. */
+  /** What a reader hears for one suggestion, where `suggestions-label` should
+not say it. `{count}` is the count. */
   suggestionLabel?: (HelixHeadlessFilterInput["suggestionLabel"]) | undefined;
-  /** What a reader hears for any other number of suggestions, with `{count}` filled in. */
+  /** What a reader hears as the panel opens on its suggestions. `{count}` is
+how many, written in the locale, and each language writes the forms it
+has: `{count, plural, one {# sugestia} few {# sugestie} many {# sugestii}
+other {# sugestii}}`. */
   "suggestions-label"?: (HelixHeadlessFilterInput["suggestionsLabel"]) | undefined;
-  /** What a reader hears for any other number of suggestions, with `{count}` filled in. */
+  /** What a reader hears as the panel opens on its suggestions. `{count}` is
+how many, written in the locale, and each language writes the forms it
+has: `{count, plural, one {# sugestia} few {# sugestie} many {# sugestii}
+other {# sugestii}}`. */
   suggestionsLabel?: (HelixHeadlessFilterInput["suggestionsLabel"]) | undefined;
   /** Whether the element starts open. Ignored once `open` is written. */
   "default-open"?: (HelixHeadlessFilterInput["defaultOpen"]) | undefined;
@@ -5934,6 +6331,12 @@ as `+3`, does not say what it does. */
   "max-tags"?: (HelixHeadlessFilterInput["maxTags"] | `${number}`) | undefined;
   /** How many tokens to show before the rest become a count. */
   maxTags?: (HelixHeadlessFilterInput["maxTags"]) | undefined;
+  /** The count of the tokens past `max-tags`, as it is shown, with `{count}`
+for the number, written in the element's locale. */
+  "rest-text"?: (HelixHeadlessFilterInput["restText"]) | undefined;
+  /** The count of the tokens past `max-tags`, as it is shown, with `{count}`
+for the number, written in the element's locale. */
+  restText?: (HelixHeadlessFilterInput["restText"]) | undefined;
   /** The value the control starts with. A form reset returns it to this value,
 and to the `value` attribute where this one is not written, as a native
 control resets to the `value` it declares. */
@@ -5963,18 +6366,22 @@ browser's message. */
   required?: (HelixHeadlessFilterInput["required"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   "value-missing-message"?: (HelixHeadlessFilterInput["valueMissingMessage"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
@@ -6029,6 +6436,14 @@ export type HelixHeadlessFilterInputVueEvents = {
 };
 
 export type HelixHeadlessFormatDateVueProps = {
+  /** The calendar a date is written in: `gregory`, `buddhist`, `japanese`,
+`roc`, or `iso8601`, the calendars Date Picker and Date Input draw.
+
+Absent is the locale's own where it is one of the five, such as
+`buddhist` for `th-TH`, and `gregory` for every other, such as `persian`
+for `fa-IR`, so a date written here reads as the same date a Date Picker
+beside it shows. */
+  calendar?: (HelixHeadlessFormatDate["calendar"]) | undefined;
   /** The timestamp, in any format `Date` can parse.
 
 An ISO string is what an API sends and what `<time datetime>` takes, so it
@@ -6062,6 +6477,14 @@ few characters and a date is not. */
   elapsed?: (HelixHeadlessFormatDate["elapsed"]) | undefined;
   /** How the era is written, such as AD, where a date is shown. */
   era?: (HelixHeadlessFormatDate["era"]) | undefined;
+  /** Draws each field of a date in a part of its own: `weekday`, `day`,
+`month`, `year`, `era`, `hour`, `minute`, `second`, `day-period` and
+`time-zone-name`, so `::part(year)` can set the year apart.
+
+Off by default, which draws the date as one run of text, as Shoelace and
+Web Awesome do. An `elapsed` or `relative` reading is one phrase either
+way. */
+  fields?: (HelixHeadlessFormatDate["fields"]) | undefined;
   /** Draws an `elapsed` or `relative` reading once and leaves it, where it
 would otherwise move on as it goes stale.
 
@@ -6170,13 +6593,33 @@ export type HelixHeadlessGraphHelixGraphZoomElementEvent =
   HelixHeadlessGraphElementEvent<HelixGraphZoomEvent>;
 
 export type HelixHeadlessGraphVueProps = {
-  /** What the list says of a note's count, with `{count}`. */
+  /** The hint shown when the graph, waiting to be pressed with
+`gestures="activate"`, is scrolled or swiped over. */
+  "activate-hint-label"?: (HelixHeadlessGraph["activateHintLabel"]) | undefined;
+  /** The hint shown when the graph, waiting to be pressed with
+`gestures="activate"`, is scrolled or swiped over. */
+  activateHintLabel?: (HelixHeadlessGraph["activateHintLabel"]) | undefined;
+  /** The name of the group of controls, read by screen readers, which names
+what the controls drive rather than the mechanism. */
+  "controls-label"?: (HelixHeadlessGraph["controlsLabel"]) | undefined;
+  /** The name of the group of controls, read by screen readers, which names
+what the controls drive rather than the mechanism. */
+  controlsLabel?: (HelixHeadlessGraph["controlsLabel"]) | undefined;
+  /** What the list says of how many notes it holds. `{count}` is the count,
+written in the locale, and each language writes the forms it has. */
   "count-label"?: (HelixHeadlessGraph["countLabel"]) | undefined;
-  /** What the list says of a note's count, with `{count}`. */
+  /** What the list says of how many notes it holds. `{count}` is the count,
+written in the locale, and each language writes the forms it has. */
   countLabel?: (HelixHeadlessGraph["countLabel"]) | undefined;
   /** How many links from the selected note to show, for its local graph. Unset
 shows every note. The list holds what the drawing shows. */
   depth?: (HelixHeadlessGraph["depth"]) | undefined;
+  /** The graph's name where `label` is empty and the host has no
+`aria-label`. */
+  "fallback-label"?: (HelixHeadlessGraph["fallbackLabel"]) | undefined;
+  /** The graph's name where `label` is empty and the host has no
+`aria-label`. */
+  fallbackLabel?: (HelixHeadlessGraph["fallbackLabel"]) | undefined;
   /** The graph's name, read by screen readers, such as "Research notes".
 Required. */
   label?: (HelixHeadlessGraph["label"]) | undefined;
@@ -6199,6 +6642,22 @@ or hides its notes. Drawn where the notes have two groups or more. */
   "links-to-label"?: (HelixHeadlessGraph["linksToLabel"]) | undefined;
   /** How a note that links to the selected one is described, with `{note}`. */
   linksToLabel?: (HelixHeadlessGraph["linksToLabel"]) | undefined;
+  /** What screen readers hear once the drawing has moved down, after `moved()`. */
+  "moved-down-label"?: (HelixHeadlessGraph["movedDownLabel"]) | undefined;
+  /** What screen readers hear once the drawing has moved down, after `moved()`. */
+  movedDownLabel?: (HelixHeadlessGraph["movedDownLabel"]) | undefined;
+  /** What screen readers hear once the drawing has moved left, after `moved()`. */
+  "moved-left-label"?: (HelixHeadlessGraph["movedLeftLabel"]) | undefined;
+  /** What screen readers hear once the drawing has moved left, after `moved()`. */
+  movedLeftLabel?: (HelixHeadlessGraph["movedLeftLabel"]) | undefined;
+  /** What screen readers hear once the drawing has moved right, after `moved()`. */
+  "moved-right-label"?: (HelixHeadlessGraph["movedRightLabel"]) | undefined;
+  /** What screen readers hear once the drawing has moved right, after `moved()`. */
+  movedRightLabel?: (HelixHeadlessGraph["movedRightLabel"]) | undefined;
+  /** What screen readers hear once the drawing has moved up, after `moved()`. */
+  "moved-up-label"?: (HelixHeadlessGraph["movedUpLabel"]) | undefined;
+  /** What screen readers hear once the drawing has moved up, after `moved()`. */
+  movedUpLabel?: (HelixHeadlessGraph["movedUpLabel"]) | undefined;
   /** Leaves the search and the list out of the frame, behind a button among
 its controls that opens them over the drawing. For a graph shown large,
 such as at the top of a page, where the drawing takes the whole frame. */
@@ -6219,12 +6678,28 @@ such as at the top of a page, where the drawing takes the whole frame. */
   "selected-label"?: (HelixHeadlessGraph["selectedLabel"]) | undefined;
   /** How the selected note is described in the list. */
   selectedLabel?: (HelixHeadlessGraph["selectedLabel"]) | undefined;
-  /** The hint shown when a surface waiting to be pressed is scrolled or
-swiped over, with `gestures="activate"`. Absent is the family's own. */
-  "activate-hint-label"?: (HelixHeadlessGraph["activateHintLabel"]) | undefined;
-  /** The hint shown when a surface waiting to be pressed is scrolled or
-swiped over, with `gestures="activate"`. Absent is the family's own. */
-  activateHintLabel?: (HelixHeadlessGraph["activateHintLabel"]) | undefined;
+  /** The hint shown when one finger swipes over the graph with `gestures="cooperative"`. */
+  "two-finger-hint-label"?: (HelixHeadlessGraph["twoFingerHintLabel"]) | undefined;
+  /** The hint shown when one finger swipes over the graph with `gestures="cooperative"`. */
+  twoFingerHintLabel?: (HelixHeadlessGraph["twoFingerHintLabel"]) | undefined;
+  /** The line shown while the graph, with `gestures="activate"`, has the gestures. */
+  "using-label"?: (HelixHeadlessGraph["usingLabel"]) | undefined;
+  /** The line shown while the graph, with `gestures="activate"`, has the gestures. */
+  usingLabel?: (HelixHeadlessGraph["usingLabel"]) | undefined;
+  /** The hint shown when the wheel scrolls past the graph with
+`gestures="cooperative"`. `{key}` is ⌘ on a Mac and Ctrl elsewhere. */
+  "wheel-hint-label"?: (HelixHeadlessGraph["wheelHintLabel"]) | undefined;
+  /** The hint shown when the wheel scrolls past the graph with
+`gestures="cooperative"`. `{key}` is ⌘ on a Mac and Ctrl elsewhere. */
+  wheelHintLabel?: (HelixHeadlessGraph["wheelHintLabel"]) | undefined;
+  /** What screen readers hear once the drawing has zoomed in, after `moved()`. */
+  "zoomed-in-label"?: (HelixHeadlessGraph["zoomedInLabel"]) | undefined;
+  /** What screen readers hear once the drawing has zoomed in, after `moved()`. */
+  zoomedInLabel?: (HelixHeadlessGraph["zoomedInLabel"]) | undefined;
+  /** What screen readers hear once the drawing has zoomed out, after `moved()`. */
+  "zoomed-out-label"?: (HelixHeadlessGraph["zoomedOutLabel"]) | undefined;
+  /** What screen readers hear once the drawing has zoomed out, after `moved()`. */
+  zoomedOutLabel?: (HelixHeadlessGraph["zoomedOutLabel"]) | undefined;
   /** Which controls to show, as a list such as `pan zoom fullscreen`, or
 `none`. A family can add words of its own.
 
@@ -6247,20 +6722,6 @@ of the frame. The
 stylesheet lays the cluster out by which buttons are in it rather than by
 this attribute, so the two defaults need no rule each. */
   controls?: (HelixHeadlessGraph["controls"]) | undefined;
-  /** The name of the group of controls, read by screen readers.
-
-Absent is the family's own name for it, "Map controls" or "Board
-controls", which names what the controls drive rather than the
-mechanism. Written here to say it in another language, which every other
-string this surface speaks already allowed and this one did not. */
-  "controls-label"?: (HelixHeadlessGraph["controlsLabel"]) | undefined;
-  /** The name of the group of controls, read by screen readers.
-
-Absent is the family's own name for it, "Map controls" or "Board
-controls", which names what the controls drive rather than the
-mechanism. Written here to say it in another language, which every other
-string this surface speaks already allowed and this one did not. */
-  controlsLabel?: (HelixHeadlessGraph["controlsLabel"]) | undefined;
   /** Which corner the controls sit in.
 
 **Configurable because there is no safe default**, which is a collision
@@ -6363,26 +6824,6 @@ at any zoom, and a consumer who wants their own units multiplies by them. */
   "pan-up-label"?: (HelixHeadlessGraph["panUpLabel"]) | undefined;
   /** The pan up button's label. */
   panUpLabel?: (HelixHeadlessGraph["panUpLabel"]) | undefined;
-  /** The hint shown when one finger swipes over a surface with
-`gestures="cooperative"`. Absent is the family's own. */
-  "two-finger-hint-label"?: (HelixHeadlessGraph["twoFingerHintLabel"]) | undefined;
-  /** The hint shown when one finger swipes over a surface with
-`gestures="cooperative"`. Absent is the family's own. */
-  twoFingerHintLabel?: (HelixHeadlessGraph["twoFingerHintLabel"]) | undefined;
-  /** The line shown while a surface with `gestures="activate"` has the
-gestures. Absent is the family's own. */
-  "using-label"?: (HelixHeadlessGraph["usingLabel"]) | undefined;
-  /** The line shown while a surface with `gestures="activate"` has the
-gestures. Absent is the family's own. */
-  usingLabel?: (HelixHeadlessGraph["usingLabel"]) | undefined;
-  /** The hint shown when the wheel scrolls past a surface with
-`gestures="cooperative"`, with `{key}`, which is ⌘ on a Mac and Ctrl
-elsewhere. Absent is the family's own. */
-  "wheel-hint-label"?: (HelixHeadlessGraph["wheelHintLabel"]) | undefined;
-  /** The hint shown when the wheel scrolls past a surface with
-`gestures="cooperative"`, with `{key}`, which is ⌘ on a Mac and Ctrl
-elsewhere. Absent is the family's own. */
-  wheelHintLabel?: (HelixHeadlessGraph["wheelHintLabel"]) | undefined;
   /** The zoom in button's label. */
   "zoom-in-label"?: (HelixHeadlessGraph["zoomInLabel"]) | undefined;
   /** The zoom in button's label. */
@@ -6425,7 +6866,7 @@ export type HelixHeadlessGraphVueEvents = {
   "helix-graph-filter": HelixHeadlessGraphHelixGraphFilterElementEvent;
   /** A layout settled, with where it put each note, sent by `laidOut()`. Keep the positions and pass them back as each note's `x` and `y`, and `z` where a renderer draws in three dimensions. */
   "helix-graph-layout": HelixHeadlessGraphHelixGraphLayoutElementEvent;
-  /** A pan button or arrow key was pressed. `connectGraph` moves the drawing. */
+  /** A pan button or arrow key was pressed. `connectGraph` moves the drawing, then calls `moved()`. */
   "helix-graph-pan": HelixHeadlessGraphHelixGraphPanElementEvent;
   /** The notes, the links, the selection, the depth or the gestures changed. Used by `connectGraph`; pages do not need to listen for it. */
   "helix-graph-part-change": HelixHeadlessGraphHelixGraphPartChangeElementEvent;
@@ -6433,7 +6874,7 @@ export type HelixHeadlessGraphVueEvents = {
   "helix-graph-ready": HelixHeadlessGraphHelixGraphReadyElementEvent;
   /** Something passed between two notes, sent by `signal()`. Used by `connectGraph`; pages do not need to listen for it. */
   "helix-graph-signal": HelixHeadlessGraphHelixGraphSignalElementEvent;
-  /** A zoom button or key was pressed. `connectGraph` zooms the drawing. */
+  /** A zoom button or key was pressed. `connectGraph` zooms the drawing, then calls `moved()`. */
   "helix-graph-zoom": HelixHeadlessGraphHelixGraphZoomElementEvent;
 };
 
@@ -6450,9 +6891,11 @@ export type HelixHeadlessHeatmapHelixResizeElementEvent =
   HelixHeadlessHeatmapElementEvent<HelixResizeEvent>;
 
 export type HelixHeadlessHeatmapVueProps = {
-  /** The word the `overview` puts before the busiest reading. */
+  /** The name the `overview` gives the busiest reading, `{busiestLabel}` in
+`overview-label`. */
   "busiest-label"?: (HelixHeadlessHeatmap["busiestLabel"]) | undefined;
-  /** The word the `overview` puts before the busiest reading. */
+  /** The name the `overview` gives the busiest reading, `{busiestLabel}` in
+`overview-label`. */
   busiestLabel?: (HelixHeadlessHeatmap["busiestLabel"]) | undefined;
   /** Shown when the table has no readings in it.
 
@@ -6503,6 +6946,16 @@ plan around.
 Zero turns the dropping off altogether, which is right for a strip in a
 container that cannot get narrow. */
   minCell?: (HelixHeadlessHeatmap["minCell"]) | undefined;
+  /** The `overview`'s sentence. `{busiestLabel}` and `{totalLabel}` are
+`busiest-label` and `total-label`, `{busiest}` the busiest reading's name
+and its reading as the table writes it, and `{total}` the total of the
+readings drawn, written in the locale. */
+  "overview-label"?: (HelixHeadlessHeatmap["overviewLabel"]) | undefined;
+  /** The `overview`'s sentence. `{busiestLabel}` and `{totalLabel}` are
+`busiest-label` and `total-label`, `{busiest}` the busiest reading's name
+and its reading as the table writes it, and `{total}` the total of the
+readings drawn, written in the locale. */
+  overviewLabel?: (HelixHeadlessHeatmap["overviewLabel"]) | undefined;
   /** How many rows the strip has.
 
 `1` is a status strip and `7` is a calendar week, which are the two readings
@@ -6511,11 +6964,23 @@ calendar heatmap does: a week is a column, so the strip reads along the
 line in weeks, from the right on a right-to-left page, and top to bottom in
 days. */
   rows?: (HelixHeadlessHeatmap["rows"]) | undefined;
-  /** What the `selection` part says after the selection changes, with `{count}` for
-how many cells are selected. */
+  /** What the readout adds for a selected cell, under `selection-mode`, after
+where the cell stands: "Day 1: 0 (1 of 14, selected)". Empty adds
+nothing. */
+  "selected-label"?: (HelixHeadlessHeatmap["selectedLabel"]) | undefined;
+  /** What the readout adds for a selected cell, under `selection-mode`, after
+where the cell stands: "Day 1: 0 (1 of 14, selected)". Empty adds
+nothing. */
+  selectedLabel?: (HelixHeadlessHeatmap["selectedLabel"]) | undefined;
+  /** What the `selection` part says after the selection changes. `{count}` is
+how many cells are selected, written in the locale, and a language that
+needs plural forms writes them: `{count, plural, one {# wybrany} few
+{# wybrane} many {# wybranych} other {# wybranego}}`. */
   "selection-label"?: (HelixHeadlessHeatmap["selectionLabel"]) | undefined;
-  /** What the `selection` part says after the selection changes, with `{count}` for
-how many cells are selected. */
+  /** What the `selection` part says after the selection changes. `{count}` is
+how many cells are selected, written in the locale, and a language that
+needs plural forms writes them: `{count, plural, one {# wybrany} few
+{# wybrane} many {# wybranych} other {# wybranego}}`. */
   selectionLabel?: (HelixHeadlessHeatmap["selectionLabel"]) | undefined;
   /** How many cells a reader can select: `single` or `multiple`.
 
@@ -6525,6 +6990,12 @@ Absent selects nothing, and a press or Space does what it did. */
 
 Absent selects nothing, and a press or Space does what it did. */
   selectionMode?: (HelixHeadlessHeatmap["selectionMode"]) | undefined;
+  /** The strip's name where the chart has none: no `aria-label`, `label`, or
+table caption. */
+  "strip-label"?: (HelixHeadlessHeatmap["stripLabel"]) | undefined;
+  /** The strip's name where the chart has none: no `aria-label`, `label`, or
+table caption. */
+  stripLabel?: (HelixHeadlessHeatmap["stripLabel"]) | undefined;
   /** Lower bounds for the tone buckets, in the order the tones are given.
 
 `thresholds="1 3 6 9"` with `tones="1 2 3 4"` puts 1 and 2 in the ramp's
@@ -6543,9 +7014,11 @@ compare two hues at all. `tones="surface info accent success primary"` for a
 commit count is five unrelated hues for five amounts, which is confetti with
 no order in it. */
   tones?: (HelixHeadlessHeatmap["tones"]) | undefined;
-  /** The word the `overview` puts before the total of the readings drawn. */
+  /** The name the `overview` gives the total of the readings drawn,
+`{totalLabel}` in `overview-label`. */
   "total-label"?: (HelixHeadlessHeatmap["totalLabel"]) | undefined;
-  /** The word the `overview` puts before the total of the readings drawn. */
+  /** The name the `overview` gives the total of the readings drawn,
+`{totalLabel}` in `overview-label`. */
   totalLabel?: (HelixHeadlessHeatmap["totalLabel"]) | undefined;
   /** The selected cells, by the names their rows have in the table, such as
 `2026-06-11`, separated by commas.
@@ -6570,8 +7043,8 @@ words and is already written. */
   /** The locale the chart's own numbers are written in: its axis, its
 percentages and its totals, such as `de` for `1.240` and `32 %`.
 
-Absent uses the runtime's own. The table's cells are shown as the table
-writes them, whatever this says. */
+Absent reads the nearest `lang`, then the runtime's own. The table's
+cells are shown as the table writes them, whatever this says. */
   locale?: (HelixHeadlessHeatmap["locale"]) | undefined;
   /** Where a reading the keys moved to stands among the readings, said after
 it. `{position}` and `{count}` are replaced with the numbers, written in
@@ -6671,7 +7144,11 @@ not text.
 
 Lives here rather than only on `IconButton` so the two share one render.
 An icon-only button without it is a control a screen reader announces as
-"button" and nothing else. */
+"button" and nothing else.
+
+Undefaulted, so a subclass's own default, such as Copy Button's `Copy`, is
+the first value its element receives and so the English its words fall
+back to. */
   label?: (HelixHeadlessIconButton["label"]) | undefined;
   /** Whether the action the button started is still running.
 
@@ -7098,18 +7575,22 @@ browser's message. */
   required?: (HelixHeadlessInput["required"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   "value-missing-message"?: (HelixHeadlessInput["valueMissingMessage"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
@@ -7384,6 +7865,10 @@ interface. */
   /** The close control's accessible name. Translate it with the rest of your
 interface. */
   dismissLabel?: (HelixHeadlessLightbox["dismissLabel"]) | undefined;
+  /** The viewer's name where `label` is empty. */
+  "fallback-label"?: (HelixHeadlessLightbox["fallbackLabel"]) | undefined;
+  /** The viewer's name where `label` is empty. */
+  fallbackLabel?: (HelixHeadlessLightbox["fallbackLabel"]) | undefined;
   /** How long the user can be idle before the header and footer hide, in
 milliseconds.
 
@@ -7417,10 +7902,10 @@ keep the chrome up is the consumer's to decide with this. */
   /** The previous control's accessible name. */
   previousLabel?: (HelixHeadlessLightbox["previousLabel"]) | undefined;
   /** The name of an item with no `label` of its own, with `{index}` and
-`{count}` filled in. */
+`{count}` filled in, written in the locale. */
   "slide-label"?: (HelixHeadlessLightbox["slideLabel"]) | undefined;
   /** The name of an item with no `label` of its own, with `{index}` and
-`{count}` filled in. */
+`{count}` filled in, written in the locale. */
   slideLabel?: (HelixHeadlessLightbox["slideLabel"]) | undefined;
   /** The word screen readers announce in place of an item's role, set as
 `aria-roledescription`. Translate it with the rest of your text, or empty
@@ -7431,14 +7916,14 @@ it to leave the role as `group`. */
 it to leave the role as `group`. */
   slideRoleLabel?: (HelixHeadlessLightbox["slideRoleLabel"]) | undefined;
   /** The status text that says which item is shown, with `{index}`, `{count}`
-and the item's `{label}` filled in.
+and the item's `{label}` filled in, the numbers written in the locale.
 
 Announced rather than only drawn, because the picture changing under a
 reader who cannot see it is otherwise silent. A consumer who has their own
 counter in the chrome can empty this and say it themselves. */
   "status-label"?: (HelixHeadlessLightbox["statusLabel"]) | undefined;
   /** The status text that says which item is shown, with `{index}`, `{count}`
-and the item's `{label}` filled in.
+and the item's `{label}` filled in, the numbers written in the locale.
 
 Announced rather than only drawn, because the picture changing under a
 reader who cannot see it is otherwise silent. A consumer who has their own
@@ -7452,11 +7937,17 @@ counter in the chrome can empty this and say it themselves. */
   "zoom-out-label"?: (HelixHeadlessLightbox["zoomOutLabel"]) | undefined;
   /** The zoom-out control's accessible name. */
   zoomOutLabel?: (HelixHeadlessLightbox["zoomOutLabel"]) | undefined;
-  /** What the live region says once a reader has stopped zooming, with the
-scale as a whole `{percent}` filled in. Empty it to say nothing. */
+  /** What the live region says once a reader has stopped zooming. `{scale,
+number, percent}` writes the scale as a percentage the way the locale
+writes one, such as `150%`, or `150 %` in French. `{percent}` is the same
+scale as a whole number, for a sentence that places the sign itself. Empty
+it to say nothing. */
   "zoom-status-label"?: (HelixHeadlessLightbox["zoomStatusLabel"]) | undefined;
-  /** What the live region says once a reader has stopped zooming, with the
-scale as a whole `{percent}` filled in. Empty it to say nothing. */
+  /** What the live region says once a reader has stopped zooming. `{scale,
+number, percent}` writes the scale as a percentage the way the locale
+writes one, such as `150%`, or `150 %` in French. `{percent}` is the same
+scale as a whole number, for a sentence that places the sign itself. Empty
+it to say nothing. */
   zoomStatusLabel?: (HelixHeadlessLightbox["zoomStatusLabel"]) | undefined;
   /** The `value` of the current item.
 
@@ -7634,8 +8125,8 @@ words and is already written. */
   /** The locale the chart's own numbers are written in: its axis, its
 percentages and its totals, such as `de` for `1.240` and `32 %`.
 
-Absent uses the runtime's own. The table's cells are shown as the table
-writes them, whatever this says. */
+Absent reads the nearest `lang`, then the runtime's own. The table's
+cells are shown as the table writes them, whatever this says. */
   locale?: (HelixHeadlessLineChart["locale"]) | undefined;
   /** Where a reading the keys moved to stands among the readings, said after
 it. `{position}` and `{count}` are replaced with the numbers, written in
@@ -7699,6 +8190,14 @@ Written by a list with `selection-mode` on every row it holds, and unset
 otherwise, which is how a row knows it is a row of a grid. No attribute:
 it is coordination between elements, as `Tag.focusable` is. */
   focusable?: (HelixHeadlessListItem["focusable"]) | undefined;
+  /** The name of the row's grip, written by a `reorderable` list from its
+`move-label`, and unset in a list that does not reorder, which draws no
+grip. No attribute: it is coordination between elements, as `focusable`
+is. */
+  grip?: (HelixHeadlessListItem["grip"]) | undefined;
+  /** Where the row stands in a move, written by a `reorderable` list: the row
+being moved, or the one the drop indicator is beside. Unset otherwise. */
+  move?: (HelixHeadlessListItem["move"]) | undefined;
   /** Whether the row is selected, in a list that selects.
 
 Written by the list from its own `value`, and unset where nothing can be
@@ -7722,8 +8221,24 @@ export type HelixHeadlessListHelixActionElementEvent =
 /** `helix-before-change` event type */
 export type HelixHeadlessListHelixBeforeChangeElementEvent =
   HelixHeadlessListElementEvent<HelixBeforeChangeEvent>;
+/** `helix-before-reorder` event type */
+export type HelixHeadlessListHelixBeforeReorderElementEvent =
+  HelixHeadlessListElementEvent<HelixBeforeReorderEvent>;
+/** `helix-reorder` event type */
+export type HelixHeadlessListHelixReorderElementEvent =
+  HelixHeadlessListElementEvent<HelixReorderEvent>;
 
 export type HelixHeadlessListVueProps = {
+  /** What screen readers hear when a held row is put back, or a move is
+refused, in a `reorderable` list. */
+  "canceled-label"?: (HelixHeadlessList["canceledLabel"]) | undefined;
+  /** What screen readers hear when a held row is put back, or a move is
+refused, in a `reorderable` list. */
+  canceledLabel?: (HelixHeadlessList["canceledLabel"]) | undefined;
+  /** What screen readers hear when a row is dropped, in a `reorderable` list. */
+  "dropped-label"?: (HelixHeadlessList["droppedLabel"]) | undefined;
+  /** What screen readers hear when a row is dropped, in a `reorderable` list. */
+  droppedLabel?: (HelixHeadlessList["droppedLabel"]) | undefined;
   /** The kind of list, which follows from the content.
 
 On the headless tier because it is meaning rather than decoration, the same
@@ -7747,6 +8262,29 @@ has to survive with the stylesheet turned off.
   kind?: (HelixHeadlessList["kind"]) | undefined;
   /** The list's name, read by screen readers. */
   label?: (HelixHeadlessList["label"]) | undefined;
+  /** What screen readers hear each time an arrow key moves a held row, in a
+`reorderable` list. `{name}` is the row's words, `{position}` the place it
+would go, counting from 1, and `{count}` the number of rows. */
+  "moved-label"?: (HelixHeadlessList["movedLabel"]) | undefined;
+  /** What screen readers hear each time an arrow key moves a held row, in a
+`reorderable` list. `{name}` is the row's words, `{position}` the place it
+would go, counting from 1, and `{count}` the number of rows. */
+  movedLabel?: (HelixHeadlessList["movedLabel"]) | undefined;
+  /** The name of each row's grip, in a `reorderable` list. `{name}` is
+replaced with the row's words. */
+  "move-label"?: (HelixHeadlessList["moveLabel"]) | undefined;
+  /** The name of each row's grip, in a `reorderable` list. `{name}` is
+replaced with the row's words. */
+  moveLabel?: (HelixHeadlessList["moveLabel"]) | undefined;
+  /** What screen readers hear when a key or a click picks up a row, in a
+`reorderable` list. `{name}` is the row's words. */
+  "picked-up-label"?: (HelixHeadlessList["pickedUpLabel"]) | undefined;
+  /** What screen readers hear when a key or a click picks up a row, in a
+`reorderable` list. `{name}` is the row's words. */
+  pickedUpLabel?: (HelixHeadlessList["pickedUpLabel"]) | undefined;
+  /** Lets you move rows by dragging a grip, or with the keys. The list moves no
+row itself: you move your data on `helix-reorder`. */
+  reorderable?: (HelixHeadlessList["reorderable"]) | undefined;
   /** Numbers an ordered list downward, so the count falls row by row and ends at
 its last row, as `<ol reversed>` does. */
   reversed?: (HelixHeadlessList["reversed"]) | undefined;
@@ -7793,6 +8331,10 @@ export type HelixHeadlessListVueEvents = {
   "helix-action": HelixHeadlessListHelixActionElementEvent;
   /** Fired before a press changes which rows are selected, with the `value` it would leave. Cancelable. */
   "helix-before-change": HelixHeadlessListHelixBeforeChangeElementEvent;
+  /** Fired when a row is dropped at a new place, in a `reorderable` list, with every row's value in the new order. Cancelable: cancel it to keep the row where it is. */
+  "helix-before-reorder": HelixHeadlessListHelixBeforeReorderElementEvent;
+  /** Fired after `helix-before-reorder` when nobody canceled it. Move your rows to the order in `keys`. Cancelable: cancel it to say the move did not happen. */
+  "helix-reorder": HelixHeadlessListHelixReorderElementEvent;
 };
 
 /** `HelixHeadlessListbox` component event */
@@ -7803,20 +8345,30 @@ export type HelixHeadlessListboxElementEvent<E = Event> = TypedEvent<
 /** `helix-before-change` event type */
 export type HelixHeadlessListboxHelixBeforeChangeElementEvent =
   HelixHeadlessListboxElementEvent<HelixBeforeChangeEvent>;
+/** `helix-before-reorder` event type */
+export type HelixHeadlessListboxHelixBeforeReorderElementEvent =
+  HelixHeadlessListboxElementEvent<HelixBeforeReorderEvent>;
 /** `helix-filter` event type */
 export type HelixHeadlessListboxHelixFilterElementEvent =
   HelixHeadlessListboxElementEvent<HelixFilterEvent>;
 /** `helix-load-more` event type */
 export type HelixHeadlessListboxHelixLoadMoreElementEvent =
   HelixHeadlessListboxElementEvent<HelixLoadMoreEvent>;
+/** `helix-reorder` event type */
+export type HelixHeadlessListboxHelixReorderElementEvent =
+  HelixHeadlessListboxElementEvent<HelixReorderEvent>;
 
 export type HelixHeadlessListboxVueProps = {
-  /** What the browser may autofill in the text field, as a platform token.
+  /** What a browser's autofill may choose, as a platform token such as
+`country` or `cc-exp-month`, as a native `<select>` takes it.
 
-**Defaults to `off`, which is not the platform's default and is the
-point.** The field filters a list rather than collecting a value, so a
-browser offering to fill it with a saved address is competing for the same
-keystrokes as the listbox. A consumer who wants autofill can still ask. */
+Set, the list draws a hidden native `<select>` with the same options for
+the browser to fill, as React Aria's `HiddenSelect` does, and a fill
+chooses the option. `off`, the default, draws none.
+
+**The filter field is never filled.** It narrows the list rather than
+collecting a value, so a browser offering it a saved address competes
+with the reader for the same keystrokes: it is always `off`. */
   autocomplete?: (HelixHeadlessListbox["autocomplete"]) | undefined;
   /** The filter text the list starts with, when `filter` is not set. */
   "default-filter"?: (HelixHeadlessListbox["defaultFilter"]) | undefined;
@@ -7870,14 +8422,27 @@ act on the list the reader expects. */
   "filter-label"?: (HelixHeadlessListbox["filterLabel"]) | undefined;
   /** Placeholder text for the filter field. */
   filterLabel?: (HelixHeadlessListbox["filterLabel"]) | undefined;
+  /** How the options are laid out, which the arrow keys follow: `stack`, one
+under another, or `grid`, in rows and columns, as React Aria's `ListBox`
+lays out cards or photos. With `grid`, Up and Down move within a column,
+and Left and Right along the list, mirrored right to left.
+
+The columns are the stylesheet's: the styled tier draws them at
+`--listbox-column-min-inline-size` or wider, and a headless list lays out
+`::part(items)` as it likes, since the keys read where each option is
+drawn. A list of `items` stays a stack. Left out, the list is a stack,
+and the host carries no attribute for it. */
+  layout?: (HelixHeadlessListbox["layout"]) | undefined;
   /** What the list says when its options could not be loaded, such as after a
-request to a server fails. Empty is no error.
+request to a server fails. Empty, null or no attribute is no error, so
+removing the attribute clears it.
 
 Set, it shows under any options there are, in place of `empty-text` and
 `loading-text`, and a screen reader hears it. Clear it when you ask again. */
   "load-error"?: (HelixHeadlessListbox["loadError"]) | undefined;
   /** What the list says when its options could not be loaded, such as after a
-request to a server fails. Empty is no error.
+request to a server fails. Empty, null or no attribute is no error, so
+removing the attribute clears it.
 
 Set, it shows under any options there are, in place of `empty-text` and
 `loading-text`, and a screen reader hears it. Clear it when you ask again. */
@@ -7889,7 +8454,10 @@ By default a single-choice list chooses as the arrows move, as a radio
 group does. Select and Time Input set this on the list in their panel, so
 a reader can move through the options before closing the panel on one. */
   manual?: (HelixHeadlessListbox["manual"]) | undefined;
-  /** Whether more than one option can be chosen. */
+  /** Whether more than one option can be chosen.
+
+A press then toggles the option pressed, and Shift with a press adds every
+option from the one last chosen to it, as React Aria's list does. */
   multiple?: (HelixHeadlessListbox["multiple"]) | undefined;
   /** The text shown when a filter hides every option of a list that has some.
 
@@ -7901,26 +8469,43 @@ matches what you typed" from "there is nothing here". */
 Absent, the list says `empty-text` in both cases. Set it to tell "nothing
 matches what you typed" from "there is nothing here". */
   noResultsText?: (HelixHeadlessListbox["noResultsText"]) | undefined;
-  /** What a screen reader hears when a filter leaves one option. `{count}` is
-the count. */
+  /** Lets a reader move options, once `@fusion.dev/helix/listbox/reorder` (or
+`@fusion.dev/helix-headless/listbox/reorder`) is imported: Alt with an
+arrow moves the highlighted option, and a pointer drags one. The list
+moves no option itself: you move your options, or your `items`, on
+`helix-reorder`. Without that import it does nothing, so a list that never
+moves options carries none of the code. */
+  reorderable?: (HelixHeadlessListbox["reorderable"]) | undefined;
+  /** What a screen reader hears when a filter leaves one option, where
+`results-label` should not say it. `{count}` is the count. */
   "result-label"?: (HelixHeadlessListbox["resultLabel"]) | undefined;
-  /** What a screen reader hears when a filter leaves one option. `{count}` is
-the count. */
+  /** What a screen reader hears when a filter leaves one option, where
+`results-label` should not say it. `{count}` is the count. */
   resultLabel?: (HelixHeadlessListbox["resultLabel"]) | undefined;
-  /** What a screen reader hears when a filter leaves any other number of
-options. `{count}` is the count.
-
-**Two sentences, chosen by `Intl.PluralRules`**, which is Data Table's
-pair: a language with more forms than two picks the one for its `one` and
-writes the rest here. */
+  /** What a screen reader hears when a filter narrows the list. `{count}` is
+how many options are left, written in the locale, and each language
+writes the forms it has: `{count, plural, one {# wynik} few {# wyniki}
+many {# wyników} other {# wyniku}}`. */
   "results-label"?: (HelixHeadlessListbox["resultsLabel"]) | undefined;
-  /** What a screen reader hears when a filter leaves any other number of
-options. `{count}` is the count.
-
-**Two sentences, chosen by `Intl.PluralRules`**, which is Data Table's
-pair: a language with more forms than two picks the one for its `one` and
-writes the rest here. */
+  /** What a screen reader hears when a filter narrows the list. `{count}` is
+how many options are left, written in the locale, and each language
+writes the forms it has: `{count, plural, one {# wynik} few {# wyniki}
+many {# wyników} other {# wyniku}}`. */
   resultsLabel?: (HelixHeadlessListbox["resultsLabel"]) | undefined;
+  /** What VoiceOver hears as the highlight reaches a chosen option from the
+filter field, on Apple devices. `{name}` is the option's words. */
+  "selected-label"?: (HelixHeadlessListbox["selectedLabel"]) | undefined;
+  /** What VoiceOver hears as the highlight reaches a chosen option from the
+filter field, on Apple devices. `{name}` is the option's words. */
+  selectedLabel?: (HelixHeadlessListbox["selectedLabel"]) | undefined;
+  /** The message reported when the field is required and no option is chosen.
+Absent, or empty, is this sentence, or the words registered for the page's
+locale. */
+  "value-missing-message"?: (HelixHeadlessListbox["valueMissingMessage"]) | undefined;
+  /** The message reported when the field is required and no option is chosen.
+Absent, or empty, is this sentence, or the words registered for the page's
+locale. */
+  valueMissingMessage?: (HelixHeadlessListbox["valueMissingMessage"]) | undefined;
   /** Whether the rows are still loading.
 
 Reflected, because a stylesheet needs it: the rows that are already there
@@ -7958,24 +8543,6 @@ browser's message. */
   label?: (HelixHeadlessListbox["label"]) | undefined;
   /** Whether the field needs a value before the form can submit. */
   required?: (HelixHeadlessListbox["required"]) | undefined;
-  /** The message shown when the field is required and empty.
-
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
-and this one was the English a form in another language still spoke in
-the bubble it raises on submit: `feedback` replaces the message under
-the field and does not reach that one. */
-  "value-missing-message"?: (HelixHeadlessListbox["valueMissingMessage"]) | undefined;
-  /** The message shown when the field is required and empty.
-
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
-and this one was the English a form in another language still spoke in
-the bubble it raises on submit: `feedback` replaces the message under
-the field and does not reach that one. */
-  valueMissingMessage?: (HelixHeadlessListbox["valueMissingMessage"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -8002,6 +8569,23 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixHeadlessListbox["name"]) | undefined;
+  /** The options as data, for a list too long to draw whole: each a value,
+which is also its words, or a record with a `value`, a `label` and
+`disabled`. Set, the list draws only the options in sight, and the ones
+you write as children are not read.
+
+**Every option is still reachable.** The keyboard, the typeahead, the
+filter and the value work over the whole set, and the option the keyboard
+is on is drawn wherever it is, so a screen reader is told about it. Each
+drawn option says its place in the set (`aria-posinset`, `aria-setsize`).
+React Aria virtualizes a `ListBox` with its `Virtualizer`; this is core's
+`VirtualizeController`.
+
+**The list needs a height to scroll in**: the styled tier's
+`--listbox-max-block-size`, or a `max-block-size` on `::part(items)` in the
+headless tier. Import the Option family as well, whose elements are drawn.
+A server sends the list empty, and the options are drawn once it hydrates. */
+  items?: (HelixHeadlessListbox["items"]) | undefined;
   /** Which option is chosen, as an index, or `-1` where none is.
 
 `<select>`'s own pair, and this control is what stands in for one. The
@@ -8020,10 +8604,14 @@ export type HelixHeadlessListboxVueEvents = {
   change: HelixHeadlessListboxElementEvent;
   /** Fired when the value is about to change, and cancelable. */
   "helix-before-change": HelixHeadlessListboxHelixBeforeChangeElementEvent;
+  /** Fired when an option is dropped at a new place, in a `reorderable` list with `@fusion.dev/helix/listbox/reorder` imported, with every value in the new order. Cancelable: cancel it to keep the option where it is. */
+  "helix-before-reorder": HelixHeadlessListboxHelixBeforeReorderElementEvent;
   /** Fired before the list is filtered, and cancelable. */
   "helix-filter": HelixHeadlessListboxHelixFilterElementEvent;
   /** Fired once the list is scrolled within a screen of its end, once for each number of options, and not while `loading` is set. Add the next page of options and set `loading` while you fetch it. */
   "helix-load-more": HelixHeadlessListboxHelixLoadMoreElementEvent;
+  /** Fired after `helix-before-reorder` when nobody canceled it. Move your options, or your `items`, to the order in `keys`. Cancelable: cancel it to say the move did not happen. */
+  "helix-reorder": HelixHeadlessListboxHelixReorderElementEvent;
   /** Fired after the value changes. */
   input: HelixHeadlessListboxElementEvent;
 };
@@ -8202,9 +8790,15 @@ export type HelixHeadlessMapMarkerVueProps = {
   /** Marks the place as passed, such as a stop already visited. The marker is
 drawn muted, and its name is followed by `passed-label`. */
   passed?: (HelixHeadlessMapMarker["passed"]) | undefined;
-  /** The word added after a passed place's name. Defaults to "passed". */
+  /** What a passed place is called. `{label}` is its name.
+
+A word without `{label}`, such as `visited`, is written after the name
+with a comma, as before the sentence held the name. */
   "passed-label"?: (HelixHeadlessMapMarker["passedLabel"]) | undefined;
-  /** The word added after a passed place's name. Defaults to "passed". */
+  /** What a passed place is called. `{label}` is its name.
+
+A word without `{label}`, such as `visited`, is written after the name
+with a comma, as before the sentence held the name. */
   passedLabel?: (HelixHeadlessMapMarker["passedLabel"]) | undefined;
 };
 
@@ -8393,16 +8987,32 @@ export type HelixHeadlessMapHelixToggleElementEvent =
   HelixHeadlessMapElementEvent<HelixToggleEvent>;
 
 export type HelixHeadlessMapVueProps = {
+  /** The hint shown when the map, waiting to be pressed with
+`gestures="activate"`, is scrolled or swiped over. */
+  "activate-hint-label"?: (HelixHeadlessMap["activateHintLabel"]) | undefined;
+  /** The hint shown when the map, waiting to be pressed with
+`gestures="activate"`, is scrolled or swiped over. */
+  activateHintLabel?: (HelixHeadlessMap["activateHintLabel"]) | undefined;
   /** The map's rotation, in degrees clockwise from north. `connectMap` keeps it
 current, and the Face north button's needle turns with it. */
   bearing?: (HelixHeadlessMap["bearing"]) | undefined;
   /** Combines markers that would overlap into one count. Counts split apart as
 the map zooms in, and pressing one zooms in to its places. */
   cluster?: (HelixHeadlessMap["cluster"]) | undefined;
+  /** The name of the group of controls, read by screen readers, which names
+what the controls drive rather than the mechanism. */
+  "controls-label"?: (HelixHeadlessMap["controlsLabel"]) | undefined;
+  /** The name of the group of controls, read by screen readers, which names
+what the controls drive rather than the mechanism. */
+  controlsLabel?: (HelixHeadlessMap["controlsLabel"]) | undefined;
   /** The Face north button's label. */
   "face-north-label"?: (HelixHeadlessMap["faceNorthLabel"]) | undefined;
   /** The Face north button's label. */
   faceNorthLabel?: (HelixHeadlessMap["faceNorthLabel"]) | undefined;
+  /** The map's name where `label` is empty and the host has no `aria-label`. */
+  "fallback-label"?: (HelixHeadlessMap["fallbackLabel"]) | undefined;
+  /** The map's name where `label` is empty and the host has no `aria-label`. */
+  fallbackLabel?: (HelixHeadlessMap["fallbackLabel"]) | undefined;
   /** What screen readers hear when the map is tilted back to looking straight down. */
   "flat-label"?: (HelixHeadlessMap["flatLabel"]) | undefined;
   /** What screen readers hear when the map is tilted back to looking straight down. */
@@ -8473,24 +9083,44 @@ above `0`. */
   /** The Standard map type's name. */
   standardLabel?: (HelixHeadlessMap["standardLabel"]) | undefined;
   /** What screen readers hear when the map is tilted. `{degrees}` is the tilt
-from looking straight down. */
+from looking straight down, written in the locale, and each language
+writes the forms it has. */
   "tilted-label"?: (HelixHeadlessMap["tiltedLabel"]) | undefined;
   /** What screen readers hear when the map is tilted. `{degrees}` is the tilt
-from looking straight down. */
+from looking straight down, written in the locale, and each language
+writes the forms it has. */
   tiltedLabel?: (HelixHeadlessMap["tiltedLabel"]) | undefined;
   /** The 3D button's label. */
   "tilt-label"?: (HelixHeadlessMap["tiltLabel"]) | undefined;
   /** The 3D button's label. */
   tiltLabel?: (HelixHeadlessMap["tiltLabel"]) | undefined;
   /** What screen readers hear when the map is turned. `{degrees}` is the way the
-top of the map faces, clockwise from north. */
+top of the map faces, clockwise from north, written in the locale, and
+each language writes the forms it has. */
   "turned-label"?: (HelixHeadlessMap["turnedLabel"]) | undefined;
   /** What screen readers hear when the map is turned. `{degrees}` is the way the
-top of the map faces, clockwise from north. */
+top of the map faces, clockwise from north, written in the locale, and
+each language writes the forms it has. */
   turnedLabel?: (HelixHeadlessMap["turnedLabel"]) | undefined;
-  /** What screen readers hear after a zoom. `{level}` is the zoom level. */
+  /** The hint shown when one finger swipes over the map with `gestures="cooperative"`. */
+  "two-finger-hint-label"?: (HelixHeadlessMap["twoFingerHintLabel"]) | undefined;
+  /** The hint shown when one finger swipes over the map with `gestures="cooperative"`. */
+  twoFingerHintLabel?: (HelixHeadlessMap["twoFingerHintLabel"]) | undefined;
+  /** The line shown while the map, with `gestures="activate"`, has the gestures. */
+  "using-label"?: (HelixHeadlessMap["usingLabel"]) | undefined;
+  /** The line shown while the map, with `gestures="activate"`, has the gestures. */
+  usingLabel?: (HelixHeadlessMap["usingLabel"]) | undefined;
+  /** The hint shown when the wheel scrolls past the map with
+`gestures="cooperative"`. `{key}` is ⌘ on a Mac and Ctrl elsewhere. */
+  "wheel-hint-label"?: (HelixHeadlessMap["wheelHintLabel"]) | undefined;
+  /** The hint shown when the wheel scrolls past the map with
+`gestures="cooperative"`. `{key}` is ⌘ on a Mac and Ctrl elsewhere. */
+  wheelHintLabel?: (HelixHeadlessMap["wheelHintLabel"]) | undefined;
+  /** What screen readers hear after a zoom. `{level}` is the zoom level,
+written in the locale. */
   "zoomed-label"?: (HelixHeadlessMap["zoomedLabel"]) | undefined;
-  /** What screen readers hear after a zoom. `{level}` is the zoom level. */
+  /** What screen readers hear after a zoom. `{level}` is the zoom level,
+written in the locale. */
   zoomedLabel?: (HelixHeadlessMap["zoomedLabel"]) | undefined;
   /** How far the map is zoomed, in its renderer's levels. `connectMap` keeps it
 current, and the map says it after a zoom. */
@@ -8498,12 +9128,6 @@ current, and the map says it after a zoom. */
   /** How far the map is zoomed, in its renderer's levels. `connectMap` keeps it
 current, and the map says it after a zoom. */
   zoomLevel?: (HelixHeadlessMap["zoomLevel"]) | undefined;
-  /** The hint shown when a surface waiting to be pressed is scrolled or
-swiped over, with `gestures="activate"`. Absent is the family's own. */
-  "activate-hint-label"?: (HelixHeadlessMap["activateHintLabel"]) | undefined;
-  /** The hint shown when a surface waiting to be pressed is scrolled or
-swiped over, with `gestures="activate"`. Absent is the family's own. */
-  activateHintLabel?: (HelixHeadlessMap["activateHintLabel"]) | undefined;
   /** Which controls to show, as a list such as `pan zoom fullscreen`, or
 `none`. A family can add words of its own.
 
@@ -8526,20 +9150,6 @@ of the frame. The
 stylesheet lays the cluster out by which buttons are in it rather than by
 this attribute, so the two defaults need no rule each. */
   controls?: (HelixHeadlessMap["controls"]) | undefined;
-  /** The name of the group of controls, read by screen readers.
-
-Absent is the family's own name for it, "Map controls" or "Board
-controls", which names what the controls drive rather than the
-mechanism. Written here to say it in another language, which every other
-string this surface speaks already allowed and this one did not. */
-  "controls-label"?: (HelixHeadlessMap["controlsLabel"]) | undefined;
-  /** The name of the group of controls, read by screen readers.
-
-Absent is the family's own name for it, "Map controls" or "Board
-controls", which names what the controls drive rather than the
-mechanism. Written here to say it in another language, which every other
-string this surface speaks already allowed and this one did not. */
-  controlsLabel?: (HelixHeadlessMap["controlsLabel"]) | undefined;
   /** Which corner the controls sit in.
 
 **Configurable because there is no safe default**, which is a collision
@@ -8642,26 +9252,6 @@ at any zoom, and a consumer who wants their own units multiplies by them. */
   "pan-up-label"?: (HelixHeadlessMap["panUpLabel"]) | undefined;
   /** The pan up button's label. */
   panUpLabel?: (HelixHeadlessMap["panUpLabel"]) | undefined;
-  /** The hint shown when one finger swipes over a surface with
-`gestures="cooperative"`. Absent is the family's own. */
-  "two-finger-hint-label"?: (HelixHeadlessMap["twoFingerHintLabel"]) | undefined;
-  /** The hint shown when one finger swipes over a surface with
-`gestures="cooperative"`. Absent is the family's own. */
-  twoFingerHintLabel?: (HelixHeadlessMap["twoFingerHintLabel"]) | undefined;
-  /** The line shown while a surface with `gestures="activate"` has the
-gestures. Absent is the family's own. */
-  "using-label"?: (HelixHeadlessMap["usingLabel"]) | undefined;
-  /** The line shown while a surface with `gestures="activate"` has the
-gestures. Absent is the family's own. */
-  usingLabel?: (HelixHeadlessMap["usingLabel"]) | undefined;
-  /** The hint shown when the wheel scrolls past a surface with
-`gestures="cooperative"`, with `{key}`, which is ⌘ on a Mac and Ctrl
-elsewhere. Absent is the family's own. */
-  "wheel-hint-label"?: (HelixHeadlessMap["wheelHintLabel"]) | undefined;
-  /** The hint shown when the wheel scrolls past a surface with
-`gestures="cooperative"`, with `{key}`, which is ⌘ on a Mac and Ctrl
-elsewhere. Absent is the family's own. */
-  wheelHintLabel?: (HelixHeadlessMap["wheelHintLabel"]) | undefined;
   /** The zoom in button's label. */
   "zoom-in-label"?: (HelixHeadlessMap["zoomInLabel"]) | undefined;
   /** The zoom in button's label. */
@@ -9124,12 +9714,16 @@ no reader. */
   /** The words each band is said with under `live`, by its name, written as
 JSON in the attribute: `band-labels='{"poor":"Almost full"}'`.
 
-A band left out keeps its default: "Good", "Fair" or "Poor". */
+A band left out keeps its default: "Good", "Fair" or "Poor". Reading the
+property gives every band's words, yours over the registry's over the
+English. */
   "band-labels"?: (HelixHeadlessMeter["bandLabels"]) | undefined;
   /** The words each band is said with under `live`, by its name, written as
 JSON in the attribute: `band-labels='{"poor":"Almost full"}'`.
 
-A band left out keeps its default: "Good", "Fair" or "Poor". */
+A band left out keeps its default: "Good", "Fair" or "Poor". Reading the
+property gives every band's words, yours over the registry's over the
+English. */
   bandLabels?: (HelixHeadlessMeter["bandLabels"]) | undefined;
   /** `Intl.NumberFormat` options the reading is written with, as React Aria's
 Meter and ProgressBar take them: a unit, a currency, or a number of
@@ -9173,9 +9767,17 @@ For a meter whose value changes while it is on screen. Off by default,
 because a meter that reads a fixed level has nothing new to say. A meter
 with no bands says nothing. */
   live?: (HelixHeadlessMeter["live"]) | undefined;
-  /** The locale the percentage is written in, such as `fr` for `72 %`.
-
-Absent uses the runtime's own. */
+  /** What `live` says as the reading moves into another band. `{reading}` is
+the reading as it is shown, and `{band}` the band's words from
+`band-labels`. */
+  "live-label"?: (HelixHeadlessMeter["liveLabel"]) | undefined;
+  /** What `live` says as the reading moves into another band. `{reading}` is
+the reading as it is shown, and `{band}` the band's words from
+`band-labels`. */
+  liveLabel?: (HelixHeadlessMeter["liveLabel"]) | undefined;
+  /** The locale the words and the percentage are in, such as `fr` for `72 %`.
+
+Absent reads the nearest `lang`, then the runtime's own. */
   locale?: (HelixHeadlessMeter["locale"]) | undefined;
   /** Top of the low band.
 
@@ -9384,14 +9986,22 @@ its place. Translate it with the rest of your interface. */
 `attribute` is spelled out because Lit lowercases a property name to
 derive one rather than dash-casing it, so this would otherwise be
 reachable only as `dismisslabel`, which nobody would guess and no linter
-would catch. */
+would catch.
+
+A word property: register it for a locale under the host's key. A family
+that names the control otherwise, such as Tag's `Remove {label}`,
+declares its own English with `@words` above the override. */
   "dismiss-label"?: (HelixHeadlessNotification["dismissLabel"]) | undefined;
   /** The dismiss control's label, read by screen readers.
 
 `attribute` is spelled out because Lit lowercases a property name to
 derive one rather than dash-casing it, so this would otherwise be
 reachable only as `dismisslabel`, which nobody would guess and no linter
-would catch. */
+would catch.
+
+A word property: register it for a locale under the host's key. A family
+that names the control otherwise, such as Tag's `Remove {label}`,
+declares its own English with `@words` above the override. */
   dismissLabel?: (HelixHeadlessNotification["dismissLabel"]) | undefined;
 };
 
@@ -9418,8 +10028,26 @@ export type HelixHeadlessNotificationsHelixReadElementEvent =
   HelixHeadlessNotificationsElementEvent<HelixReadEvent>;
 
 export type HelixHeadlessNotificationsVueProps = {
+  /** The region's name where `label` is empty. */
+  "fallback-label"?: (HelixHeadlessNotifications["fallbackLabel"]) | undefined;
+  /** The region's name where `label` is empty. */
+  fallbackLabel?: (HelixHeadlessNotifications["fallbackLabel"]) | undefined;
   /** The feed's name, read by screen readers. */
   label?: (HelixHeadlessNotifications["label"]) | undefined;
+  /** What the feed says when a page of it could not be loaded, such as after a
+request to a server fails. Empty, null or no attribute is no error, so
+removing the attribute clears it.
+
+Set, it shows under the rows there are, in place of `empty-text` and
+`loading-text`, and a screen reader hears it. Clear it when you ask again. */
+  "load-error"?: (HelixHeadlessNotifications["loadError"]) | undefined;
+  /** What the feed says when a page of it could not be loaded, such as after a
+request to a server fails. Empty, null or no attribute is no error, so
+removing the attribute clears it.
+
+Set, it shows under the rows there are, in place of `empty-text` and
+`loading-text`, and a screen reader hears it. Clear it when you ask again. */
+  loadError?: (HelixHeadlessNotifications["loadError"]) | undefined;
   /** Whether to draw a button after the list that asks for the next page, by
 sending `helix-load-more`. Take it off once there is nothing more. */
   "load-more"?: (HelixHeadlessNotifications["loadMore"]) | undefined;
@@ -9492,7 +10120,8 @@ number.
 **Every sentence a control raises in the browser's bubble is a property**,
 named for the validity flag it reports, so a form in another language
 speaks it: `feedback` replaces the message under the field and does not
-reach the bubble. Absent is the control's own sentence, in English. */
+reach the bubble. Unset is the sentence registered for the page's
+language, then the English. */
   "bad-input-message"?: (HelixHeadlessNumberInput["badInputMessage"]) | undefined;
   /** The message the browser shows when the field holds something that is not a
 number.
@@ -9500,7 +10129,8 @@ number.
 **Every sentence a control raises in the browser's bubble is a property**,
 named for the validity flag it reports, so a form in another language
 speaks it: `feedback` replaces the message under the field and does not
-reach the bubble. Absent is the control's own sentence, in English. */
+reach the bubble. Unset is the sentence registered for the page's
+language, then the English. */
   badInputMessage?: (HelixHeadlessNumberInput["badInputMessage"]) | undefined;
   /** The name of the step down button, read by screen readers. */
   "decrement-label"?: (HelixHeadlessNumberInput["decrementLabel"]) | undefined;
@@ -9558,16 +10188,16 @@ Absent has no floor. */
 Not a label: it goes when typing starts. */
   placeholder?: (HelixHeadlessNumberInput["placeholder"]) | undefined;
   /** The message the browser shows when the number is above `max`, with `{max}`
-filled in. */
+filled in, written in the locale. */
   "range-overflow-message"?: (HelixHeadlessNumberInput["rangeOverflowMessage"]) | undefined;
   /** The message the browser shows when the number is above `max`, with `{max}`
-filled in. */
+filled in, written in the locale. */
   rangeOverflowMessage?: (HelixHeadlessNumberInput["rangeOverflowMessage"]) | undefined;
   /** The message the browser shows when the number is below `min`, with `{min}`
-filled in. */
+filled in, written in the locale. */
   "range-underflow-message"?: (HelixHeadlessNumberInput["rangeUnderflowMessage"]) | undefined;
   /** The message the browser shows when the number is below `min`, with `{min}`
-filled in. */
+filled in, written in the locale. */
   rangeUnderflowMessage?: (HelixHeadlessNumberInput["rangeUnderflowMessage"]) | undefined;
   /** Prevents editing. The value is still submitted with the form. */
   readonly?: (HelixHeadlessNumberInput["readOnly"]) | undefined;
@@ -9592,10 +10222,12 @@ showing dollars keeps the cents typed into it. Without `format-options`
 the grid is whole numbers, as in a native number field. */
   step?: (HelixHeadlessNumberInput["step"]) | undefined;
   /** The message the browser shows when the number is off the step grid, with
-`{below}` and `{above}` filled in with the nearest valid values. */
+`{below}` and `{above}` filled in with the nearest valid values, written in
+the locale. */
   "step-mismatch-message"?: (HelixHeadlessNumberInput["stepMismatchMessage"]) | undefined;
   /** The message the browser shows when the number is off the step grid, with
-`{below}` and `{above}` filled in with the nearest valid values. */
+`{below}` and `{above}` filled in with the nearest valid values, written in
+the locale. */
   stepMismatchMessage?: (HelixHeadlessNumberInput["stepMismatchMessage"]) | undefined;
   /** What a screen reader says for the value, with `{value}` filled in, such as
 `{value} kilograms`.
@@ -9644,18 +10276,22 @@ browser's message. */
   required?: (HelixHeadlessNumberInput["required"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   "value-missing-message"?: (HelixHeadlessNumberInput["valueMissingMessage"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
@@ -9787,21 +10423,33 @@ Read once the document exists, and again whenever this changes. Text that
 does not parse leaves the inspector empty rather than throwing, since a
 page's markup should not take the page down over a comma. */
   for?: (HelixHeadlessObjectInspector["for"]) | undefined;
-  /** How an array of one entry counts it. `{count}` is replaced with the count. */
+  /** How an array of one entry counts it, where `items-label` should not say
+it. `{count}` is the count. */
   "item-label"?: (HelixHeadlessObjectInspector["itemLabel"]) | undefined;
-  /** How an array of one entry counts it. `{count}` is replaced with the count. */
+  /** How an array of one entry counts it, where `items-label` should not say
+it. `{count}` is the count. */
   itemLabel?: (HelixHeadlessObjectInspector["itemLabel"]) | undefined;
-  /** How an array of any other number of entries counts them. `{count}` is replaced with the count. */
+  /** How an array counts its entries. `{count}` is the count, written in the
+locale, and each language writes the forms it has: `{count, plural, one
+{# element} few {# elementy} many {# elementów} other {# elementu}}`. */
   "items-label"?: (HelixHeadlessObjectInspector["itemsLabel"]) | undefined;
-  /** How an array of any other number of entries counts them. `{count}` is replaced with the count. */
+  /** How an array counts its entries. `{count}` is the count, written in the
+locale, and each language writes the forms it has: `{count, plural, one
+{# element} few {# elementy} many {# elementów} other {# elementu}}`. */
   itemsLabel?: (HelixHeadlessObjectInspector["itemsLabel"]) | undefined;
-  /** How an object of one key counts it. `{count}` is replaced with the count. */
+  /** How an object of one key counts it, where `keys-label` should not say it.
+`{count}` is the count. */
   "key-label"?: (HelixHeadlessObjectInspector["keyLabel"]) | undefined;
-  /** How an object of one key counts it. `{count}` is replaced with the count. */
+  /** How an object of one key counts it, where `keys-label` should not say it.
+`{count}` is the count. */
   keyLabel?: (HelixHeadlessObjectInspector["keyLabel"]) | undefined;
-  /** How an object of any other number of keys counts them. `{count}` is replaced with the count. */
+  /** How an object counts its keys. `{count}` is the count, written in the
+locale, and each language writes the forms it has: `{count, plural, one
+{# klucz} few {# klucze} many {# kluczy} other {# klucza}}`. */
   "keys-label"?: (HelixHeadlessObjectInspector["keysLabel"]) | undefined;
-  /** How an object of any other number of keys counts them. `{count}` is replaced with the count. */
+  /** How an object counts its keys. `{count}` is the count, written in the
+locale, and each language writes the forms it has: `{count, plural, one
+{# klucz} few {# klucze} many {# kluczy} other {# klucza}}`. */
   keysLabel?: (HelixHeadlessObjectInspector["keysLabel"]) | undefined;
   /** Accessible name for the tree, and the text of the header where there is one. */
   label?: (HelixHeadlessObjectInspector["label"]) | undefined;
@@ -9829,15 +10477,21 @@ who set the property. This button is positioned out of the flow and takes no
 room, so nothing selects on it, and reflection exists so that a selector can
 reach a value. */
   noCopy?: (HelixHeadlessObjectInspector["noCopy"]) | undefined;
-  /** What a screen reader hears when a filter matches one entry. `{count}` is the count. */
+  /** What a screen reader hears when a filter matches one entry, where
+`results-label` should not say it. `{count}` is the count. */
   "result-label"?: (HelixHeadlessObjectInspector["resultLabel"]) | undefined;
-  /** What a screen reader hears when a filter matches one entry. `{count}` is the count. */
+  /** What a screen reader hears when a filter matches one entry, where
+`results-label` should not say it. `{count}` is the count. */
   resultLabel?: (HelixHeadlessObjectInspector["resultLabel"]) | undefined;
-  /** What a screen reader hears when a filter matches any other number of
-entries. `{count}` is the count. The two are chosen by `Intl.PluralRules`. */
+  /** What a screen reader hears when a filter matches entries. `{count}` is
+how many, written in the locale, and each language writes the forms it
+has: `{count, plural, one {# wynik} few {# wyniki} many {# wyników}
+other {# wyniku}}`. */
   "results-label"?: (HelixHeadlessObjectInspector["resultsLabel"]) | undefined;
-  /** What a screen reader hears when a filter matches any other number of
-entries. `{count}` is the count. The two are chosen by `Intl.PluralRules`. */
+  /** What a screen reader hears when a filter matches entries. `{count}` is
+how many, written in the locale, and each language writes the forms it
+has: `{count, plural, one {# wynik} few {# wyniki} many {# wyników}
+other {# wyniku}}`. */
   resultsLabel?: (HelixHeadlessObjectInspector["resultsLabel"]) | undefined;
   /** The tree's accessible name when `label` is empty and the host names it
 with neither `aria-label` nor `aria-labelledby`. */
@@ -10176,7 +10830,8 @@ one, and the back button works without the consumer wiring anything. */
   "last-label"?: (HelixHeadlessPagination["lastLabel"]) | undefined;
   /** Accessible name for the control that jumps to the last page. */
   lastLabel?: (HelixHeadlessPagination["lastLabel"]) | undefined;
-  /** Locale for the page numbers. Absent uses the runtime's own.
+  /** The locale the words and the page numbers are in, as a BCP 47 tag such as
+`de`. Empty reads the nearest `lang`, then the browser's language.
 
 The same property the calendar takes, doing the same job one layer down:
 the templates make the *words* the consumer's, and this makes the *numbers*
@@ -10290,9 +10945,8 @@ export type HelixHeadlessPaginationSizeVueProps = {
   defaultValue?: (HelixHeadlessPaginationSize["defaultValue"]) | undefined;
   /** The label beside the control. */
   label?: (HelixHeadlessPaginationSize["label"]) | undefined;
-  /** Locale for the numbers.
-
-Absent uses the runtime's own. */
+  /** The locale the words and the numbers are in, as a BCP 47 tag such as
+`de`. Empty reads the nearest `lang`, then the browser's language. */
   locale?: (HelixHeadlessPaginationSize["locale"]) | undefined;
   /** The sizes offered, comma separated.
 
@@ -10345,7 +10999,7 @@ export type HelixHeadlessPaginationSizeVueEvents = {
 
 export type HelixHeadlessPaginationSummaryVueProps = {
   /** The text shown. `{from}`, `{to}`, and `{total}` are replaced with the first
-item, the last item, and the item count.
+item, the last item, and the item count, written in the locale.
 
 A template rather than a prefix and a suffix, because word order is not
 universal: `format="{total} 件中 {from}-{to} 件"` is one attribute here and
@@ -10359,9 +11013,8 @@ of the element, so calling it `label` put one word on three jobs inside one
 family. The root's templates are `pageLabel`, `statusLabel` and `gapLabel`,
 which each label something; this labels nothing, it *is* the thing. */
   format?: (HelixHeadlessPaginationSummary["format"]) | undefined;
-  /** Locale for the numbers.
-
-Absent uses the runtime's own. */
+  /** The locale the words and the numbers are in, as a BCP 47 tag such as
+`de`. Empty reads the nearest `lang`, then the browser's language. */
   locale?: (HelixHeadlessPaginationSummary["locale"]) | undefined;
   /** The current page, counting from one. */
   page?: (HelixHeadlessPaginationSummary["page"]) | undefined;
@@ -10427,11 +11080,13 @@ a row of boxes. */
   readonly?: (HelixHeadlessPinInput["readOnly"]) | undefined;
   /** Whether the field blocks input. A read-only code still submits its value. */
   readOnly?: (HelixHeadlessPinInput["readOnly"]) | undefined;
-  /** The message shown when the code is started and not finished, with
-`{length}` filled in. When it is unset, an English default is shown. */
+  /** The message shown when the code is started and not finished. `{length}`
+is how many characters the code has, written in the locale, and each
+language writes the forms it has. */
   "too-short-message"?: (HelixHeadlessPinInput["tooShortMessage"]) | undefined;
-  /** The message shown when the code is started and not finished, with
-`{length}` filled in. When it is unset, an English default is shown. */
+  /** The message shown when the code is started and not finished. `{length}`
+is how many characters the code has, written in the locale, and each
+language writes the forms it has. */
   tooShortMessage?: (HelixHeadlessPinInput["tooShortMessage"]) | undefined;
   /** The characters a box accepts, which also sets the keyboard a phone shows.
 
@@ -10482,18 +11137,22 @@ browser's message. */
   required?: (HelixHeadlessPinInput["required"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   "value-missing-message"?: (HelixHeadlessPinInput["valueMissingMessage"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
@@ -10558,8 +11217,14 @@ export type HelixHeadlessPopoverVueProps = {
 Off by default, which is the house style: a panel that opens from its
 trigger already reads as belonging to it. */
   arrow?: (HelixHeadlessPopover["arrow"]) | undefined;
-  /** The panel's name, read by screen readers. Left at `Popover`, the first
-heading in the panel names it instead. */
+  /** The panel's name where nothing else names it: no `label`, no heading in
+the panel, and no `aria-labelledby` on the host. */
+  "fallback-label"?: (HelixHeadlessPopover["fallbackLabel"]) | undefined;
+  /** The panel's name where nothing else names it: no `label`, no heading in
+the panel, and no `aria-labelledby` on the host. */
+  fallbackLabel?: (HelixHeadlessPopover["fallbackLabel"]) | undefined;
+  /** The panel's name, read by screen readers. Left empty, the first heading in
+the panel names it, and then `fallback-label`. */
   label?: (HelixHeadlessPopover["label"]) | undefined;
   /** Keeps `Tab` inside the panel while it is open, marks the panel
 `aria-modal`, and hides the rest of the page from screen readers. A press
@@ -10663,9 +11328,9 @@ place in the layout when the answer arrives and it becomes determinate. */
 A visible label in the `label` slot names it instead, with the words it
 shows, so the name and the label cannot disagree. */
   label?: (HelixHeadlessProgress["label"]) | undefined;
-  /** The locale the percentage is written in, such as `fr` for `72 %`.
+  /** The locale the words and the percentage are in, such as `fr` for `72 %`.
 
-Absent uses the runtime's own. */
+Absent reads the nearest `lang`, then the runtime's own. */
   locale?: (HelixHeadlessProgress["locale"]) | undefined;
   /** The total the work is measured against. */
   max?: (HelixHeadlessProgress["max"]) | undefined;
@@ -10743,11 +11408,17 @@ export type HelixHeadlessQrCodeElementEvent<E = Event> = TypedEvent<
 >;
 
 export type HelixHeadlessQrCodeVueProps = {
-  /** The words a code with no `label` is named by, followed by its value where
-the value is a web address. */
+  /** The name of a code with no `label` whose value is a web address.
+`{code}` is `code-label` and `{address}` the address. */
+  "address-label"?: (HelixHeadlessQrCode["addressLabel"]) | undefined;
+  /** The name of a code with no `label` whose value is a web address.
+`{code}` is `code-label` and `{address}` the address. */
+  addressLabel?: (HelixHeadlessQrCode["addressLabel"]) | undefined;
+  /** The words a code with no `label` is named by, with its value where the
+value is a web address, as `address-label` says. */
   "code-label"?: (HelixHeadlessQrCode["codeLabel"]) | undefined;
-  /** The words a code with no `label` is named by, followed by its value where
-the value is a web address. */
+  /** The words a code with no `label` is named by, with its value where the
+value is a web address, as `address-label` says. */
   codeLabel?: (HelixHeadlessQrCode["codeLabel"]) | undefined;
   /** The error correction level, which sets how much of the code can be lost
 and still scan.
@@ -10834,6 +11505,14 @@ Home and End move focus between the radios and choose nothing, so a reader
 can hear every choice, and Tab still reaches the answer. The group says
 `aria-readonly`. A script can still set `value`. */
   readOnly?: (HelixHeadlessRadioGroup["readOnly"]) | undefined;
+  /** The message reported when the field is required and no option is chosen.
+Absent, or empty, is this sentence, or the words registered for the page's
+locale. */
+  "value-missing-message"?: (HelixHeadlessRadioGroup["valueMissingMessage"]) | undefined;
+  /** The message reported when the field is required and no option is chosen.
+Absent, or empty, is this sentence, or the words registered for the page's
+locale. */
+  valueMissingMessage?: (HelixHeadlessRadioGroup["valueMissingMessage"]) | undefined;
   /** The value the control starts with. A form reset returns it to this value,
 and to the `value` attribute where this one is not written, as a native
 control resets to the `value` it declares. */
@@ -10861,24 +11540,6 @@ browser's message. */
   label?: (HelixHeadlessRadioGroup["label"]) | undefined;
   /** Whether the field needs a value before the form can submit. */
   required?: (HelixHeadlessRadioGroup["required"]) | undefined;
-  /** The message shown when the field is required and empty.
-
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
-and this one was the English a form in another language still spoke in
-the bubble it raises on submit: `feedback` replaces the message under
-the field and does not reach that one. */
-  "value-missing-message"?: (HelixHeadlessRadioGroup["valueMissingMessage"]) | undefined;
-  /** The message shown when the field is required and empty.
-
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
-and this one was the English a form in another language still spoke in
-the bubble it raises on submit: `feedback` replaces the message under
-the field and does not reach that one. */
-  valueMissingMessage?: (HelixHeadlessRadioGroup["valueMissingMessage"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -11064,13 +11725,13 @@ leaving a rating with nothing to press. A property that silently accepts
 nonsense is the fault this pays off, so neither case is quietly ignored. */
   min?: (HelixHeadlessRating["min"]) | undefined;
   /** The name of each mark a reader can choose, with `{score}` and `{max}`
-filled in. Set it to translate "3 out of 5".
+filled in, written in the locale. Set it to translate "3 out of 5".
 
 Also what a read-only rating says for its score where `value-text` is
 empty. */
   "option-label"?: (HelixHeadlessRating["optionLabel"]) | undefined;
   /** The name of each mark a reader can choose, with `{score}` and `{max}`
-filled in. Set it to translate "3 out of 5".
+filled in, written in the locale. Set it to translate "3 out of 5".
 
 Also what a read-only rating says for its score where `value-text` is
 empty. */
@@ -11112,6 +11773,14 @@ reader's own cursor would be worse than no label. */
 `0.5` is the half star, and it is the reason the value is a number rather
 than an index: with halves, five marks are ten answers. */
   step?: (HelixHeadlessRating["step"]) | undefined;
+  /** The message reported when the field is required and no rating is chosen.
+Absent, or empty, is this sentence, or the words registered for the page's
+locale. */
+  "value-missing-message"?: (HelixHeadlessRating["valueMissingMessage"]) | undefined;
+  /** The message reported when the field is required and no rating is chosen.
+Absent, or empty, is this sentence, or the words registered for the page's
+locale. */
+  valueMissingMessage?: (HelixHeadlessRating["valueMissingMessage"]) | undefined;
   /** The text screen readers read for the score, in place of "3.5 out of 5".
 
 A rating out of five is one of the few places a screen reader gets a worse
@@ -11153,24 +11822,6 @@ browser's message. */
   label?: (HelixHeadlessRating["label"]) | undefined;
   /** Whether the field needs a value before the form can submit. */
   required?: (HelixHeadlessRating["required"]) | undefined;
-  /** The message shown when the field is required and empty.
-
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
-and this one was the English a form in another language still spoke in
-the bubble it raises on submit: `feedback` replaces the message under
-the field and does not reach that one. */
-  "value-missing-message"?: (HelixHeadlessRating["valueMissingMessage"]) | undefined;
-  /** The message shown when the field is required and empty.
-
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
-and this one was the English a form in another language still spoke in
-the bubble it raises on submit: `feedback` replaces the message under
-the field and does not reach that one. */
-  valueMissingMessage?: (HelixHeadlessRating["valueMissingMessage"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -11219,9 +11870,11 @@ export type HelixHeadlessRatingVueEvents = {
 };
 
 export type HelixHeadlessScatterChartVueProps = {
-  /** The word the summary uses for the strength of the relation. */
+  /** The word for the strength of the relation, `{correlationLabel}` in
+`series-label`. */
   "correlation-label"?: (HelixHeadlessScatterChart["correlationLabel"]) | undefined;
-  /** The word the summary uses for the strength of the relation. */
+  /** The word for the strength of the relation, `{correlationLabel}` in
+`series-label`. */
   correlationLabel?: (HelixHeadlessScatterChart["correlationLabel"]) | undefined;
   /** Which gridlines are drawn across the plot, if any.
 
@@ -11230,10 +11883,30 @@ Both axes are measured, so the values name an axis rather than a role:
 anything unrecognized, means `both`, since neither axis is the one a scatter
 is read along. */
   gridlines?: (HelixHeadlessScatterChart["gridlines"]) | undefined;
-  /** The word the summary uses for a row when it counts them. */
+  /** The word for the rows a series rests on, `{pointsLabel}` in
+`series-label`. `{count}` is how many, so the word takes its plural
+forms: `{count, plural, one {punkt} few {punkty} other {punktów}}`. */
   "points-label"?: (HelixHeadlessScatterChart["pointsLabel"]) | undefined;
-  /** The word the summary uses for a row when it counts them. */
+  /** The word for the rows a series rests on, `{pointsLabel}` in
+`series-label`. `{count}` is how many, so the word takes its plural
+forms: `{count, plural, one {punkt} few {punkty} other {punktów}}`. */
   pointsLabel?: (HelixHeadlessScatterChart["pointsLabel"]) | undefined;
+  /** What the summary says of each series. `{y}` is what the series measures up,
+`{x}` what the chart measures across, `{count}` how many rows it rests on,
+written in the locale, `{pointsLabel}` the word for them, and
+`{correlation}` its correlation, or `none` where there are fewer than
+three points or no spread to measure, so each case is a whole sentence:
+`{correlation, select, none {...} other {...}}`. `{correlationLabel}` is
+`correlation-label`. */
+  "series-label"?: (HelixHeadlessScatterChart["seriesLabel"]) | undefined;
+  /** What the summary says of each series. `{y}` is what the series measures up,
+`{x}` what the chart measures across, `{count}` how many rows it rests on,
+written in the locale, `{pointsLabel}` the word for them, and
+`{correlation}` its correlation, or `none` where there are fewer than
+three points or no spread to measure, so each case is a whole sentence:
+`{correlation, select, none {...} other {...}}`. `{correlationLabel}` is
+`correlation-label`. */
+  seriesLabel?: (HelixHeadlessScatterChart["seriesLabel"]) | undefined;
   /** The heading of a column whose numbers size the points, such as
 `Population`, which makes the chart a bubble chart.
 
@@ -11273,8 +11946,8 @@ words and is already written. */
   /** The locale the chart's own numbers are written in: its axis, its
 percentages and its totals, such as `de` for `1.240` and `32 %`.
 
-Absent uses the runtime's own. The table's cells are shown as the table
-writes them, whatever this says. */
+Absent reads the nearest `lang`, then the runtime's own. The table's
+cells are shown as the table writes them, whatever this says. */
   locale?: (HelixHeadlessScatterChart["locale"]) | undefined;
   /** Where a reading the keys moved to stands among the readings, said after
 it. `{position}` and `{count}` are replaced with the numbers, written in
@@ -11363,6 +12036,14 @@ export type HelixHeadlessSelectToggleElementEvent =
   HelixHeadlessSelectElementEvent<ToggleEvent>;
 
 export type HelixHeadlessSelectVueProps = {
+  /** What a browser's autofill may fill in, as a platform token such as
+`country` or `cc-exp-month`, as on a native `<select>`.
+
+Set, the select keeps a hidden native `<select>` with the same options for
+the browser to fill, as React Aria's `HiddenSelect` does, and takes the
+option the browser picks, by its value or its words, as the value. Empty
+draws no hidden select, and a browser fills nothing. */
+  autocomplete?: (HelixHeadlessSelect["autocomplete"]) | undefined;
   /** The text shown when no options match the filter. */
   "empty-text"?: (HelixHeadlessSelect["emptyText"]) | undefined;
   /** The text shown when no options match the filter. */
@@ -11414,6 +12095,14 @@ round it, and a short move reaches the options either side. Near an edge
 of the screen the list moves to stay on it, so the option may sit beside
 the trigger rather than on it. It follows the page as it scrolls. */
   position?: (HelixHeadlessSelect["position"]) | undefined;
+  /** The message reported when the field is required and nothing is chosen.
+Absent, or empty, is this sentence, or the words registered for the page's
+locale. */
+  "value-missing-message"?: (HelixHeadlessSelect["valueMissingMessage"]) | undefined;
+  /** The message reported when the field is required and nothing is chosen.
+Absent, or empty, is this sentence, or the words registered for the page's
+locale. */
+  valueMissingMessage?: (HelixHeadlessSelect["valueMissingMessage"]) | undefined;
   /** Whether the element starts open. Ignored once `open` is written. */
   "default-open"?: (HelixHeadlessSelect["defaultOpen"]) | undefined;
   /** Whether the element starts open. Ignored once `open` is written. */
@@ -11458,24 +12147,6 @@ browser's message. */
   label?: (HelixHeadlessSelect["label"]) | undefined;
   /** Whether the field needs a value before the form can submit. */
   required?: (HelixHeadlessSelect["required"]) | undefined;
-  /** The message shown when the field is required and empty.
-
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
-and this one was the English a form in another language still spoke in
-the bubble it raises on submit: `feedback` replaces the message under
-the field and does not reach that one. */
-  "value-missing-message"?: (HelixHeadlessSelect["valueMissingMessage"]) | undefined;
-  /** The message shown when the field is required and empty.
-
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
-and this one was the English a form in another language still spoke in
-the bubble it raises on submit: `feedback` replaces the message under
-the field and does not reach that one. */
-  valueMissingMessage?: (HelixHeadlessSelect["valueMissingMessage"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -11608,8 +12279,8 @@ attribute.
 <helix-slider format-options='{"style":"currency","currency":"USD"}'></helix-slider>
 ``` */
   formatOptions?: (HelixHeadlessSlider["formatOptions"]) | undefined;
-  /** The locale `format-options` writes the value in, such as `de-DE`. Empty is
-the reader's own. */
+  /** The locale the value and the words are written in, such as `de-DE`. Empty
+reads the nearest `lang`, then the browser's language. */
   locale?: (HelixHeadlessSlider["locale"]) | undefined;
   /** Shows the value at each mark. */
   "marker-labels"?: (HelixHeadlessSlider["markerLabels"]) | undefined;
@@ -11732,18 +12403,22 @@ browser's message. */
   required?: (HelixHeadlessSlider["required"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   "value-missing-message"?: (HelixHeadlessSlider["valueMissingMessage"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
@@ -11833,11 +12508,11 @@ the accessible representation of a sparkline, and a list of the fourteen
 numbers is not. Absent, the drawing is hidden from a screen reader rather
 than announced without a name. */
   label?: (HelixHeadlessSparkline["label"]) | undefined;
-  /** The locale the readout's numbers and positions are written in, such as
-`de` for `1.240`.
+  /** The locale the words, the readout's numbers and positions are in, such
+as `de` for `1.240`.
 
-Absent uses the runtime's own. A table's cells are shown as the table
-writes them, whatever this says. */
+Absent reads the nearest `lang`, then the runtime's own. A table's cells
+are shown as the table writes them, whatever this says. */
   locale?: (HelixHeadlessSparkline["locale"]) | undefined;
   /** Which readings take a mark of their own: `high`, `low`, or both,
 separated by spaces.
@@ -11918,6 +12593,13 @@ not. */
 
 export type HelixHeadlessSparklineVueEvents = {};
 
+export type HelixHeadlessSpeedDialGroupVueProps = {
+  /** The group's name, drawn above its actions and read by screen readers. */
+  label?: (HelixHeadlessSpeedDialGroup["label"]) | undefined;
+};
+
+export type HelixHeadlessSpeedDialGroupVueEvents = {};
+
 /** `HelixHeadlessSpeedDialItem` component event */
 export type HelixHeadlessSpeedDialItemElementEvent<E = Event> = TypedEvent<
   HelixHeadlessSpeedDialItem,
@@ -11930,6 +12612,10 @@ export type HelixHeadlessSpeedDialItemHelixSelectElementEvent =
 export type HelixHeadlessSpeedDialItemVueProps = {
   /** Whether the action is disabled, so it cannot be chosen. */
   disabled?: (HelixHeadlessSpeedDialItem["disabled"]) | undefined;
+  /** The action's keyboard shortcut as a chord, such as `mod+s`, carried as
+`aria-keyshortcuts` and drawn after the name. `mod` is Command on an Apple
+keyboard and Control elsewhere. Showing a shortcut does not bind it. */
+  shortcut?: (HelixHeadlessSpeedDialItem["shortcut"]) | undefined;
   /** The action's value, sent in `helix-select` when the action is chosen. */
   value?: (HelixHeadlessSpeedDialItem["value"]) | undefined;
 };
@@ -11960,8 +12646,32 @@ export type HelixHeadlessSpeedDialToggleElementEvent =
 export type HelixHeadlessSpeedDialVueProps = {
   /** Accessible name for the trigger and the set of actions it opens. */
   label?: (HelixHeadlessSpeedDial["label"]) | undefined;
+  /** The description the trigger gives under `open-on="long-press"`, saying how
+its actions are reached.
+
+A slotted trigger is described by the dial, which carries the words as
+its own label for that: a Helix button's inner control at once, and a
+plain element of yours once a reader reaches it, after hydration, unless
+you described or labeled it yourself. */
+  "long-press-label"?: (HelixHeadlessSpeedDial["longPressLabel"]) | undefined;
+  /** The description the trigger gives under `open-on="long-press"`, saying how
+its actions are reached.
+
+A slotted trigger is described by the dial, which carries the words as
+its own label for that: a Helix button's inner control at once, and a
+plain element of yours once a reader reaches it, after hydration, unless
+you described or labeled it yourself. */
+  longPressLabel?: (HelixHeadlessSpeedDial["longPressLabel"]) | undefined;
   /** Space between the trigger and the actions, in pixels. */
   offset?: (HelixHeadlessSpeedDial["offset"]) | undefined;
+  /** What opens the dial. `click` opens it on a press of the trigger. Under
+`long-press`, a press is the trigger's own action, and the dial opens on a
+press held for half a second, or on Alt+Down or Alt+Up. */
+  "open-on"?: (HelixHeadlessSpeedDial["openOn"]) | undefined;
+  /** What opens the dial. `click` opens it on a press of the trigger. Under
+`long-press`, a press is the trigger's own action, and the dial opens on a
+press held for half a second, or on Alt+Down or Alt+Up. */
+  openOn?: (HelixHeadlessSpeedDial["openOn"]) | undefined;
   /** The direction the actions open in. They move to another side if that side
 does not fit.
 
@@ -12147,7 +12857,7 @@ export type HelixHeadlessSplitterVueEvents = {
   "helix-collapse": HelixHeadlessSplitterHelixCollapseElementEvent;
   /** Fired after the divider settles somewhere new, with the new position. */
   "helix-resized": HelixHeadlessSplitterHelixResizedElementEvent;
-  /** Fired each time a drag moves the divider, before it settles, as a range input does while it is dragged. Read `position` for where it is now. */
+  /** Fired each time the divider moves, as a range input does: on each step of a drag, and before `helix-resized` for a key, a double click or a corner. Read `position` for where it is now. */
   input: HelixHeadlessSplitterElementEvent;
 };
 
@@ -12225,11 +12935,15 @@ in both. Of those four combinations three are ones nobody should pick, and
 a property whose job is mostly to be left alone is a property that mostly
 catches people out. */
   orientation?: (HelixHeadlessSteps["orientation"]) | undefined;
-  /** What the `progress` part says to a screen reader, with `{percent}` filled
-in with `progress`. */
+  /** What the `progress` part says to a screen reader. `{share, number,
+percent}` writes `progress` as a percentage the way the locale writes one,
+such as `40%`, or `40 %` in French. `{percent}` is `progress` as a whole
+number, for a sentence that places the sign itself. */
   "progress-label"?: (HelixHeadlessSteps["progressLabel"]) | undefined;
-  /** What the `progress` part says to a screen reader, with `{percent}` filled
-in with `progress`. */
+  /** What the `progress` part says to a screen reader. `{share, number,
+percent}` writes `progress` as a percentage the way the locale writes one,
+such as `40%`, or `40 %` in French. `{percent}` is `progress` as a whole
+number, for a sentence that places the sign itself. */
   progressLabel?: (HelixHeadlessSteps["progressLabel"]) | undefined;
   /** What each step is marked with.
 
@@ -12286,6 +13000,16 @@ export type HelixHeadlessStepHelixSelectElementEvent =
 export type HelixHeadlessStepVueProps = {
   /** Whether this stage is finished. */
   complete?: (HelixHeadlessStep["complete"]) | undefined;
+  /** What a screen reader hears when the stage is finished while the page is
+open. `{name}` is the stage's name and `{complete}` is `complete-label`, so
+a language can write the whole sentence in its own order. A stage with no
+name says `complete-label` alone. */
+  "completed-label"?: (HelixHeadlessStep["completedLabel"]) | undefined;
+  /** What a screen reader hears when the stage is finished while the page is
+open. `{name}` is the stage's name and `{complete}` is `complete-label`, so
+a language can write the whole sentence in its own order. A stage with no
+name says `complete-label` alone. */
+  completedLabel?: (HelixHeadlessStep["completedLabel"]) | undefined;
   /** The words that tell a screen reader the stage is finished. Translate it
 with the page. */
   "complete-label"?: (HelixHeadlessStep["completeLabel"]) | undefined;
@@ -12320,6 +13044,14 @@ export type HelixHeadlessSwitchHelixBeforeToggleElementEvent =
 export type HelixHeadlessSwitchVueProps = {
   /** Value submitted when the switch is on. */
   value?: (HelixHeadlessSwitch["value"]) | undefined;
+  /** The message reported when the field is required and the switch is off.
+Absent, or empty, is this sentence, or the words registered for the page's
+locale. */
+  "value-missing-message"?: (HelixHeadlessSwitch["valueMissingMessage"]) | undefined;
+  /** The message reported when the field is required and the switch is off.
+Absent, or empty, is this sentence, or the words registered for the page's
+locale. */
+  valueMissingMessage?: (HelixHeadlessSwitch["valueMissingMessage"]) | undefined;
   /** Whether the control is checked.
 
 One property rather than two. Writing always applies;
@@ -12371,24 +13103,6 @@ browser's message. */
   label?: (HelixHeadlessSwitch["label"]) | undefined;
   /** Whether the field needs a value before the form can submit. */
   required?: (HelixHeadlessSwitch["required"]) | undefined;
-  /** The message shown when the field is required and empty.
-
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
-and this one was the English a form in another language still spoke in
-the bubble it raises on submit: `feedback` replaces the message under
-the field and does not reach that one. */
-  "value-missing-message"?: (HelixHeadlessSwitch["valueMissingMessage"]) | undefined;
-  /** The message shown when the field is required and empty.
-
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
-and this one was the English a form in another language still spoke in
-the bubble it raises on submit: `feedback` replaces the message under
-the field and does not reach that one. */
-  valueMissingMessage?: (HelixHeadlessSwitch["valueMissingMessage"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -12461,14 +13175,16 @@ after a column moves is a sort a consumer cannot store in a URL.
 Empty on a column that is purely presentational, an actions column say, and
 such a column is never sortable however it is marked. */
   field?: (HelixHeadlessTableColumn["field"]) | undefined;
-  /** The accessible name of the grip that moves the column. `{name}` is replaced
-with the heading text.
+  /** The accessible name of the grip that moves the column. `{name}` is the
+heading text, and `{named}` is `no` for a column without one, so the
+sentence for it can name the column another way.
 
 **Every word a column speaks is a property**, so a table in another
 language hears its own rather than English around its own headings. */
   "move-label"?: (HelixHeadlessTableColumn["moveLabel"]) | undefined;
-  /** The accessible name of the grip that moves the column. `{name}` is replaced
-with the heading text.
+  /** The accessible name of the grip that moves the column. `{name}` is the
+heading text, and `{named}` is `no` for a column without one, so the
+sentence for it can name the column another way.
 
 **Every word a column speaks is a property**, so a table in another
 language hears its own rather than English around its own headings. */
@@ -12481,10 +13197,10 @@ it has focus, a step at a time and four with Shift. The width lands in
 stores the widths can take the decision. */
   resizable?: (HelixHeadlessTableColumn["resizable"]) | undefined;
   /** The accessible name of the separator that resizes the column. `{name}` is
-replaced with the heading text. */
+the heading text, and `{named}` is `no` for a column without one. */
   "resize-label"?: (HelixHeadlessTableColumn["resizeLabel"]) | undefined;
   /** The accessible name of the separator that resizes the column. `{name}` is
-replaced with the heading text. */
+the heading text, and `{named}` is `no` for a column without one. */
   resizeLabel?: (HelixHeadlessTableColumn["resizeLabel"]) | undefined;
   /** Makes this column's cells the headers of their rows, in `DataTable`.
 
@@ -12602,10 +13318,12 @@ and lets that column wrap. A headless consumer owns the overflow either
 way, that being paint, and gets the honest track list. */
   width?: (HelixHeadlessTableColumn["width"]) | undefined;
   /** The text screen readers announce for the column's width. `{width}` is
-replaced with the width. */
+the width in pixels, written in the locale, and each language writes the
+forms it has. */
   "width-label"?: (HelixHeadlessTableColumn["widthLabel"]) | undefined;
   /** The text screen readers announce for the column's width. `{width}` is
-replaced with the width. */
+the width in pixels, written in the locale, and each language writes the
+forms it has. */
   widthLabel?: (HelixHeadlessTableColumn["widthLabel"]) | undefined;
   /** A function that reads the cell's content from a row, for cells that `field`
 alone cannot read.
@@ -12638,6 +13356,12 @@ export type HelixHeadlessTableElementEvent<E = Event> = TypedEvent<
   HelixHeadlessTable,
   E
 >;
+/** `helix-before-reorder` event type */
+export type HelixHeadlessTableHelixBeforeReorderElementEvent =
+  HelixHeadlessTableElementEvent<HelixBeforeReorderEvent>;
+/** `helix-reorder` event type */
+export type HelixHeadlessTableHelixReorderElementEvent =
+  HelixHeadlessTableElementEvent<HelixReorderEvent>;
 /** `helix-select` event type */
 export type HelixHeadlessTableHelixSelectElementEvent =
   HelixHeadlessTableElementEvent<HelixSelectEvent>;
@@ -12652,10 +13376,16 @@ export type HelixHeadlessTableHelixSortedElementEvent =
   HelixHeadlessTableElementEvent<HelixSortedEvent>;
 
 export type HelixHeadlessTableVueProps = {
-  /** The word for an ascending sort, in `sorted-label`. */
+  /** The word for an ascending sort, in a `sorted-label` that writes `{order}`. */
   "ascending-label"?: (HelixHeadlessTable["ascendingLabel"]) | undefined;
-  /** The word for an ascending sort, in `sorted-label`. */
+  /** The word for an ascending sort, in a `sorted-label` that writes `{order}`. */
   ascendingLabel?: (HelixHeadlessTable["ascendingLabel"]) | undefined;
+  /** What screen readers hear when a held row is put back, or a move is
+refused, in a `reorderable` table. */
+  "canceled-label"?: (HelixHeadlessTable["canceledLabel"]) | undefined;
+  /** What screen readers hear when a held row is put back, or a move is
+refused, in a `reorderable` table. */
+  canceledLabel?: (HelixHeadlessTable["canceledLabel"]) | undefined;
   /** The column widths as one track list, written once on the table.
 
 With `TableColumn` children, each track sizes the column in its place, a
@@ -12695,15 +13425,60 @@ is set. */
   "default-sort"?: (HelixHeadlessTable["defaultSort"]) | undefined;
   /** The starting sort order, used until `sort` is set. */
   defaultSort?: (HelixHeadlessTable["defaultSort"]) | undefined;
-  /** The word for a descending sort, in `sorted-label`. */
+  /** The word for a descending sort, in a `sorted-label` that writes `{order}`. */
   "descending-label"?: (HelixHeadlessTable["descendingLabel"]) | undefined;
-  /** The word for a descending sort, in `sorted-label`. */
+  /** The word for a descending sort, in a `sorted-label` that writes `{order}`. */
   descendingLabel?: (HelixHeadlessTable["descendingLabel"]) | undefined;
+  /** What screen readers hear when a held row is dropped, in a `reorderable` table. */
+  "dropped-label"?: (HelixHeadlessTable["droppedLabel"]) | undefined;
+  /** What screen readers hear when a held row is dropped, in a `reorderable` table. */
+  droppedLabel?: (HelixHeadlessTable["droppedLabel"]) | undefined;
+  /** The table's name where neither `label` nor an `aria-label` or
+`aria-labelledby` on the host gives it one. */
+  "fallback-label"?: (HelixHeadlessTable["fallbackLabel"]) | undefined;
+  /** The table's name where neither `label` nor an `aria-label` or
+`aria-labelledby` on the host gives it one. */
+  fallbackLabel?: (HelixHeadlessTable["fallbackLabel"]) | undefined;
+  /** Makes the table a grid: one tab stop, and the arrow keys, Home, End and the
+Page keys move focus between its cells, the headings included. Enter moves
+into a cell's controls, and Tab leaves the table.
+
+Off by default, where the table is a static `table` and Tab reaches each
+link and control in it. On, the table writes a `tabindex` onto each of its
+cells, which is the one way a cell of your markup can take focus. */
+  grid?: (HelixHeadlessTable["grid"]) | undefined;
   /** Accessible name for the table.
 
 An `aria-label` or `aria-labelledby` on the host names the table too, and
 wins over this. */
   label?: (HelixHeadlessTable["label"]) | undefined;
+  /** What screen readers hear each time a key moves a held row, in a
+`reorderable` table. `{name}` is the row's words, `{position}` the place it
+would go, counting from 1, and `{count}` the number of rows. */
+  "moved-label"?: (HelixHeadlessTable["movedLabel"]) | undefined;
+  /** What screen readers hear each time a key moves a held row, in a
+`reorderable` table. `{name}` is the row's words, `{position}` the place it
+would go, counting from 1, and `{count}` the number of rows. */
+  movedLabel?: (HelixHeadlessTable["movedLabel"]) | undefined;
+  /** The name of a row's grip, in a `reorderable` table. `{row}` is replaced
+with the words of the row's first cell. */
+  "move-row-label"?: (HelixHeadlessTable["moveRowLabel"]) | undefined;
+  /** The name of a row's grip, in a `reorderable` table. `{row}` is replaced
+with the words of the row's first cell. */
+  moveRowLabel?: (HelixHeadlessTable["moveRowLabel"]) | undefined;
+  /** What screen readers hear when a key or a click picks up a row, in a
+`reorderable` table. `{name}` is the row's words. */
+  "picked-up-label"?: (HelixHeadlessTable["pickedUpLabel"]) | undefined;
+  /** What screen readers hear when a key or a click picks up a row, in a
+`reorderable` table. `{name}` is the row's words. */
+  pickedUpLabel?: (HelixHeadlessTable["pickedUpLabel"]) | undefined;
+  /** Adds a column of grips that move rows, by dragging or with the keys. The
+table moves no row itself: you move your rows on `helix-reorder`. */
+  reorderable?: (HelixHeadlessTable["reorderable"]) | undefined;
+  /** The name of the heading over the row grips, in a `reorderable` table. */
+  "row-grips-label"?: (HelixHeadlessTable["rowGripsLabel"]) | undefined;
+  /** The name of the heading over the row grips, in a `reorderable` table. */
+  rowGripsLabel?: (HelixHeadlessTable["rowGripsLabel"]) | undefined;
   /** Adds a column of checkboxes for selecting rows. Each row is known by its
 `value`, and by its place among the rows as written where it has none. */
   selectable?: (HelixHeadlessTable["selectable"]) | undefined;
@@ -12718,10 +13493,14 @@ selection as it was. `default-selected` seeds a selection this element
 then owns. */
   selected?: (HelixHeadlessTable["selected"]) | undefined;
   /** What screen readers hear when the chosen rows change. `{count}` is how many
-rows are chosen. */
+rows are chosen, written in the locale, and a language that needs plural
+forms writes them: `{count, plural, one {# wybrany} few {# wybrane} many
+{# wybranych} other {# wybranego}}`. */
   "selected-label"?: (HelixHeadlessTable["selectedLabel"]) | undefined;
   /** What screen readers hear when the chosen rows change. `{count}` is how many
-rows are chosen. */
+rows are chosen, written in the locale, and a language that needs plural
+forms writes them: `{count, plural, one {# wybrany} few {# wybrane} many
+{# wybranych} other {# wybranego}}`. */
   selectedLabel?: (HelixHeadlessTable["selectedLabel"]) | undefined;
   /** The name of a row's checkbox. `{row}` is replaced with the words of the
 row's first cell. */
@@ -12738,10 +13517,14 @@ first, and refusing it leaves the order as it was. `default-sort` seeds an
 order this element then owns. */
   sort?: (HelixHeadlessTable["sort"]) | undefined;
   /** What screen readers hear when the table is sorted. `{column}` is the
-column's heading and `{order}` is `ascending-label` or `descending-label`. */
+column's heading and `{direction}` is `ascending` or `descending`, so each
+order has its whole sentence. `{order}` is the deprecated
+`ascending-label` or `descending-label`. */
   "sorted-label"?: (HelixHeadlessTable["sortedLabel"]) | undefined;
   /** What screen readers hear when the table is sorted. `{column}` is the
-column's heading and `{order}` is `ascending-label` or `descending-label`. */
+column's heading and `{direction}` is `ascending` or `descending`, so each
+order has its whole sentence. `{order}` is the deprecated
+`ascending-label` or `descending-label`. */
   sortedLabel?: (HelixHeadlessTable["sortedLabel"]) | undefined;
   /** What screen readers hear when the table stops being sorted. */
   "unsorted-label"?: (HelixHeadlessTable["unsortedLabel"]) | undefined;
@@ -12764,6 +13547,10 @@ say that without the component knowing what a row looks like. */
 };
 
 export type HelixHeadlessTableVueEvents = {
+  /** Fired when a row is dropped at a new place, in a `reorderable` table, with every row's key in the new order. Cancelable: cancel it to keep the row where it is. */
+  "helix-before-reorder": HelixHeadlessTableHelixBeforeReorderElementEvent;
+  /** Fired after `helix-before-reorder` when nobody canceled it. Move your rows to the order in `keys`. Cancelable: cancel it to say the move did not happen. */
+  "helix-reorder": HelixHeadlessTableHelixReorderElementEvent;
   /** The selection is about to change. The event carries every selected key, separated by commas. Cancelable: cancel it to keep the current selection. */
   "helix-select": HelixHeadlessTableHelixSelectElementEvent;
   /** Fired after the selection changes, with every selected key, separated by commas. */
@@ -12989,6 +13776,20 @@ export type HelixHeadlessTagVueProps = {
 answering, and in a `Tag.Group` the arrow keys pass over it and it cannot
 be selected or removed. */
   disabled?: (HelixHeadlessTag["disabled"]) | undefined;
+  /** The remove button's name, read by screen readers, with `{label}` for the
+tag's own words.
+
+"Remove" rather than the mixin's "Dismiss": a tag is taken out of a set,
+which is a different act from closing a message. One sentence with the
+tag's words in it, so a translation puts them where its language does. */
+  "dismiss-label"?: (HelixHeadlessTag["dismissLabel"]) | undefined;
+  /** The remove button's name, read by screen readers, with `{label}` for the
+tag's own words.
+
+"Remove" rather than the mixin's "Dismiss": a tag is taken out of a set,
+which is a different act from closing a message. One sentence with the
+tag's words in it, so a translation puts them where its language does. */
+  dismissLabel?: (HelixHeadlessTag["dismissLabel"]) | undefined;
   /** Makes the label a link to this address. */
   href?: (HelixHeadlessTag["href"]) | undefined;
   /** What the tag stands for in its group's `value`.
@@ -12997,20 +13798,6 @@ Absent is the tag's own words, its category first. */
   value?: (HelixHeadlessTag["value"]) | undefined;
   /** Whether the element shows a control that dismisses it. */
   dismissible?: (HelixHeadlessTag["dismissible"]) | undefined;
-  /** The dismiss control's label, read by screen readers.
-
-`attribute` is spelled out because Lit lowercases a property name to
-derive one rather than dash-casing it, so this would otherwise be
-reachable only as `dismisslabel`, which nobody would guess and no linter
-would catch. */
-  "dismiss-label"?: (HelixHeadlessTag["dismissLabel"]) | undefined;
-  /** The dismiss control's label, read by screen readers.
-
-`attribute` is spelled out because Lit lowercases a property name to
-derive one rather than dash-casing it, so this would otherwise be
-reachable only as `dismisslabel`, which nobody would guess and no linter
-would catch. */
-  dismissLabel?: (HelixHeadlessTag["dismissLabel"]) | undefined;
   /** Whether the tag holds its group's tab stop.
 
 Written by `Tag.Group` on every tag it holds, and unset outside one, which
@@ -13152,18 +13939,22 @@ browser's message. */
   required?: (HelixHeadlessTextarea["required"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   "value-missing-message"?: (HelixHeadlessTextarea["valueMissingMessage"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
@@ -13292,14 +14083,14 @@ on why a wheel cannot do either. */
   /** The message shown when a range holds more than two times.
 
 **Every sentence a control raises in the browser's bubble is a property**,
-so a form in another language speaks it. Absent is the control's own
-sentence, in English. */
+so a form in another language speaks it. Unset is the sentence registered
+for the page's language, then the English. */
   "range-length-message"?: (HelixHeadlessTimeInput["rangeLengthMessage"]) | undefined;
   /** The message shown when a range holds more than two times.
 
 **Every sentence a control raises in the browser's bubble is a property**,
-so a form in another language speaks it. Absent is the control's own
-sentence, in English. */
+so a form in another language speaks it. Unset is the sentence registered
+for the page's language, then the English. */
   rangeLengthMessage?: (HelixHeadlessTimeInput["rangeLengthMessage"]) | undefined;
   /** The message shown when a time is after `max`, with `{max}` filled in as
 the field displays it. */
@@ -13369,12 +14160,28 @@ not touch, and React reads that as a hydration mismatch. The absent
 attribute *is* the list, which the stylesheet reads as the base rule, so
 only the departure has to be named. */
   variant?: (HelixHeadlessTimeInput["variant"]) | undefined;
+  /** What a row of segments reports when the field is required and every
+segment is empty, where `value-missing-message` is not set. `{kind}` is
+`date` or `time`. */
+  "empty-message"?: (HelixHeadlessTimeInput["emptyMessage"]) | undefined;
+  /** What a row of segments reports when the field is required and every
+segment is empty, where `value-missing-message` is not set. `{kind}` is
+`date` or `time`. */
+  emptyMessage?: (HelixHeadlessTimeInput["emptyMessage"]) | undefined;
   /** What a screen reader hears for a segment with nothing in it, which a
 sighted reader sees as dashes. */
   "empty-segment-label"?: (HelixHeadlessTimeInput["emptySegmentLabel"]) | undefined;
   /** What a screen reader hears for a segment with nothing in it, which a
 sighted reader sees as dashes. */
   emptySegmentLabel?: (HelixHeadlessTimeInput["emptySegmentLabel"]) | undefined;
+  /** What a row of segments reports while some segments are set and others
+are not, where `bad-input-message` is not set. `{kind}` is `date` or
+`time`. */
+  "incomplete-message"?: (HelixHeadlessTimeInput["incompleteMessage"]) | undefined;
+  /** What a row of segments reports while some segments are set and others
+are not, where `bad-input-message` is not set. `{kind}` is `date` or
+`time`. */
+  incompleteMessage?: (HelixHeadlessTimeInput["incompleteMessage"]) | undefined;
   /** Whether the field is a row of segments, one for each part of the date or
 time, in place of a line of text.
 
@@ -13456,6 +14263,12 @@ as `+3`, does not say what it does. */
   "max-tags"?: (HelixHeadlessTimeInput["maxTags"] | `${number}`) | undefined;
   /** How many tokens to show before the rest become a count. */
   maxTags?: (HelixHeadlessTimeInput["maxTags"]) | undefined;
+  /** The count of the tokens past `max-tags`, as it is shown, with `{count}`
+for the number, written in the element's locale. */
+  "rest-text"?: (HelixHeadlessTimeInput["restText"]) | undefined;
+  /** The count of the tokens past `max-tags`, as it is shown, with `{count}`
+for the number, written in the element's locale. */
+  restText?: (HelixHeadlessTimeInput["restText"]) | undefined;
   /** The value the control starts with. A form reset returns it to this value,
 and to the `value` attribute where this one is not written, as a native
 control resets to the `value` it declares. */
@@ -13485,18 +14298,22 @@ browser's message. */
   required?: (HelixHeadlessTimeInput["required"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   "value-missing-message"?: (HelixHeadlessTimeInput["valueMissingMessage"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
@@ -13569,13 +14386,19 @@ export type HelixHeadlessTimePickerVueProps = {
 
 **Every sentence a control raises in the browser's bubble is a property**,
 named for the validity flag it reports, so a form in another language
-speaks it. Absent is the control's own sentence, in English. */
+speaks it. Unset is the sentence registered for the page's language, then
+the English. `{shape}` is how a time is written, `HH:mm` or `HH:mm:ss`, and
+`{mode}` is `single`, `range` or `multiple`, so each can have its own
+sentence. */
   "bad-input-message"?: (HelixHeadlessTimePicker["badInputMessage"]) | undefined;
   /** The validation message for a value that is not a time.
 
 **Every sentence a control raises in the browser's bubble is a property**,
 named for the validity flag it reports, so a form in another language
-speaks it. Absent is the control's own sentence, in English. */
+speaks it. Unset is the sentence registered for the page's language, then
+the English. `{shape}` is how a time is written, `HH:mm` or `HH:mm:ss`, and
+`{mode}` is `single`, `range` or `multiple`, so each can have its own
+sentence. */
   badInputMessage?: (HelixHeadlessTimePicker["badInputMessage"]) | undefined;
   /** Times that cannot be chosen, as `HH:mm`, separated by commas or spaces.
 
@@ -13931,14 +14754,22 @@ A subset of the tone axis: a toast reports a status and never a brand role. */
 `attribute` is spelled out because Lit lowercases a property name to
 derive one rather than dash-casing it, so this would otherwise be
 reachable only as `dismisslabel`, which nobody would guess and no linter
-would catch. */
+would catch.
+
+A word property: register it for a locale under the host's key. A family
+that names the control otherwise, such as Tag's `Remove {label}`,
+declares its own English with `@words` above the override. */
   "dismiss-label"?: (HelixHeadlessToastItem["dismissLabel"]) | undefined;
   /** The dismiss control's label, read by screen readers.
 
 `attribute` is spelled out because Lit lowercases a property name to
 derive one rather than dash-casing it, so this would otherwise be
 reachable only as `dismisslabel`, which nobody would guess and no linter
-would catch. */
+would catch.
+
+A word property: register it for a locale under the host's key. A family
+that names the control otherwise, such as Tag's `Remove {label}`,
+declares its own English with `@words` above the override. */
   dismissLabel?: (HelixHeadlessToastItem["dismissLabel"]) | undefined;
 };
 
@@ -13958,7 +14789,9 @@ export type HelixHeadlessToastHelixDismissElementEvent =
 
 export type HelixHeadlessToastVueProps = {
   /** The key that takes focus to the stack and back, such as `F8` or `Alt+T`:
-keys joined by `+`, the last one the key. Empty turns it off. */
+keys joined by `+`, the last one the key, as `Announcement`'s `hotkey`
+reads them: `mod` is Command on Apple devices and Control elsewhere.
+Empty turns it off. */
   hotkey?: (HelixHeadlessToast["hotkey"]) | undefined;
   /** Accessible name for the region, with `{hotkey}` filled in. Translate it with
 the rest of your interface. */
@@ -14082,18 +14915,22 @@ browser's message. */
   required?: (HelixHeadlessToggleGroup["required"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   "value-missing-message"?: (HelixHeadlessToggleGroup["valueMissingMessage"]) | undefined;
   /** The message shown when the field is required and empty.
 
-**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
-set and the browser's own on a text field, which the browser writes in
-the reader's language. Every other word a control speaks is a property,
+**Absent, or empty, is the control's own sentence**, "Choose one to
+continue." on a set and the browser's own on a text field, which the
+browser writes in the reader's language. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. Every other word a control speaks is a property,
 and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
@@ -14286,6 +15123,14 @@ default slot is the trigger, which is the older form.
 Names an element in the same tree, so a tooltip inside another component's
 shadow root points at one in that root rather than one in the document.
 
+Give the tooltip an `id` and name it in the trigger's `aria-describedby`,
+so the trigger is described in the server's markup and at rest:
+
+```html
+<button aria-describedby="save-tip" id="save">Save</button>
+<helix-headless-tooltip content="Save your work" for="save" id="save-tip"></helix-headless-tooltip>
+```
+
 **In React this arrives as a property and not as an attribute**, which is
 worth knowing before someone reads the DOM and thinks it did not take.
 Measured against React 19.2.8: `for` exists on the prototype, so React sets
@@ -14448,11 +15293,11 @@ The shape is `Carousel`'s, which is the nearest thing in the library: a
   nextLabel?: (HelixHeadlessTour["nextLabel"]) | undefined;
   /** Draws each stop's place in the run in its panel, as well as saying it. */
   progress?: (HelixHeadlessTour["progress"]) | undefined;
-  /** Each stop's place in the run, with `{index}` and `{count}` filled in.
-Translate it with the rest of your text. */
+  /** Each stop's place in the run, with `{index}` and `{count}` filled in and
+written in the locale. Translate it with the rest of your text. */
   "progress-label"?: (HelixHeadlessTour["progressLabel"]) | undefined;
-  /** Each stop's place in the run, with `{index}` and `{count}` filled in.
-Translate it with the rest of your text. */
+  /** Each stop's place in the run, with `{index}` and `{count}` filled in and
+written in the locale. Translate it with the rest of your text. */
   progressLabel?: (HelixHeadlessTour["progressLabel"]) | undefined;
   /** Label for the control that leaves the tour. */
   "skip-label"?: (HelixHeadlessTour["skipLabel"]) | undefined;
@@ -14683,16 +15528,40 @@ export type HelixHeadlessTreeHelixActivateElementEvent =
 /** `helix-before-activate` event type */
 export type HelixHeadlessTreeHelixBeforeActivateElementEvent =
   HelixHeadlessTreeElementEvent<HelixBeforeActivateEvent>;
+/** `helix-before-reorder` event type */
+export type HelixHeadlessTreeHelixBeforeReorderElementEvent =
+  HelixHeadlessTreeElementEvent<HelixBeforeReorderEvent>;
+/** `helix-reorder` event type */
+export type HelixHeadlessTreeHelixReorderElementEvent =
+  HelixHeadlessTreeElementEvent<HelixReorderEvent>;
 /** `helix-select` event type */
 export type HelixHeadlessTreeHelixSelectElementEvent =
   HelixHeadlessTreeElementEvent<HelixSelectEvent>;
 
 export type HelixHeadlessTreeVueProps = {
+  /** What screen readers hear when a held item is put back, or a move is
+refused, in a `reorderable` tree. */
+  "canceled-label"?: (HelixHeadlessTree["canceledLabel"]) | undefined;
+  /** What screen readers hear when a held item is put back, or a move is
+refused, in a `reorderable` tree. */
+  canceledLabel?: (HelixHeadlessTree["canceledLabel"]) | undefined;
+  /** What screen readers hear when a held item is dropped, in a `reorderable` tree. */
+  "dropped-label"?: (HelixHeadlessTree["droppedLabel"]) | undefined;
+  /** What screen readers hear when a held item is dropped, in a `reorderable` tree. */
+  droppedLabel?: (HelixHeadlessTree["droppedLabel"]) | undefined;
   /** Accessible name for the tree.
 
 An `aria-label` or `aria-labelledby` on the host names the tree too, and
 wins over this. */
   label?: (HelixHeadlessTree["label"]) | undefined;
+  /** What screen readers hear each time an item moves, in a `reorderable`
+tree. `{name}` is the item's words, `{position}` its place among its
+siblings, counting from 1, and `{count}` the number of siblings. */
+  "moved-label"?: (HelixHeadlessTree["movedLabel"]) | undefined;
+  /** What screen readers hear each time an item moves, in a `reorderable`
+tree. `{name}` is the item's words, `{position}` its place among its
+siblings, counting from 1, and `{count}` the number of siblings. */
+  movedLabel?: (HelixHeadlessTree["movedLabel"]) | undefined;
   /** What a deeper level means: `peer` for no change, `subordinate` for a lower
 rank, or `heading` for a parent that heads the items under it.
 
@@ -14728,6 +15597,16 @@ branch as a label; a headless consumer reads the attribute and the
 written here appears in the served markup of every tree anybody renders.
 The resting state is the absence of the attribute, which is `peer`. */
   nesting?: (HelixHeadlessTree["nesting"]) | undefined;
+  /** What screen readers hear when a click on a grip picks up an item, in a
+`reorderable` tree. `{name}` is the item's words. */
+  "picked-up-label"?: (HelixHeadlessTree["pickedUpLabel"]) | undefined;
+  /** What screen readers hear when a click on a grip picks up an item, in a
+`reorderable` tree. `{name}` is the item's words. */
+  pickedUpLabel?: (HelixHeadlessTree["pickedUpLabel"]) | undefined;
+  /** Lets you move items among their siblings, by dragging a grip or with Alt
+and an arrow. The tree moves no item itself: you move your data on
+`helix-reorder`. */
+  reorderable?: (HelixHeadlessTree["reorderable"]) | undefined;
   /** Whether a reader can check many items, or choose only the items at the
 ends. Unset, one item is chosen at a time, branches included.
 
@@ -14779,14 +15658,20 @@ export type HelixHeadlessTreeVueEvents = {
   "helix-activate": HelixHeadlessTreeHelixActivateElementEvent;
   /** Fired before the current node changes, and cancelable. Canceling it is the only way to stop the change. */
   "helix-before-activate": HelixHeadlessTreeHelixBeforeActivateElementEvent;
+  /** Fired when an item is dropped at a new place among its siblings, in a `reorderable` tree, with the siblings' keys in the new order. Cancelable: cancel it to keep the item where it is. */
+  "helix-before-reorder": HelixHeadlessTreeHelixBeforeReorderElementEvent;
+  /** Fired after `helix-before-reorder` when nobody canceled it. Move your items to the order in `keys`, each an item's `value`, or its words where it has none. Cancelable: cancel it to say the move did not happen. */
+  "helix-reorder": HelixHeadlessTreeHelixReorderElementEvent;
   /** Fired when an item is chosen. The item sends it, and you can listen for it on the tree. Cancelable: canceling it changes nothing. */
   "helix-select": HelixHeadlessTreeHelixSelectElementEvent;
 };
 
 export type HelixHeadlessTrendVueProps = {
-  /** The word read out after the direction when the move is an improvement. */
+  /** The word read out after the direction when the move is an improvement,
+`{betterLabel}` in `judgment-label`. */
   "better-label"?: (HelixHeadlessTrend["betterLabel"]) | undefined;
-  /** The word read out after the direction when the move is an improvement. */
+  /** The word read out after the direction when the move is an improvement,
+`{betterLabel}` in `judgment-label`. */
   betterLabel?: (HelixHeadlessTrend["betterLabel"]) | undefined;
   /** Which way the measurement moved, as `movement` says it. */
   direction?: (HelixHeadlessTrend["direction"]) | undefined;
@@ -14825,9 +15710,23 @@ revenue up is good news and latency up is bad news, and only the consumer
 knows which one this is. Set it once per metric and it holds while the
 movement changes underneath. */
   good?: (HelixHeadlessTrend["good"]) | undefined;
-  /** The locale `value` is written in, such as `de` for `1.234,5`.
-
-Absent uses the runtime's own. Set it on a page rendered on a server, so
+  /** What the `direction` part says. `{direction}` is the word for the
+movement, `up-label`, `down-label` or `unchanged-label`, and
+`{judgment}` is `better` or `worse` where `good` judges the move, so a
+language whose words agree with the movement writes each phrase whole:
+`{judgment, select, better {...} worse {...} other {...}}`.
+`{betterLabel}` and `{worseLabel}` are `better-label` and `worse-label`. */
+  "judgment-label"?: (HelixHeadlessTrend["judgmentLabel"]) | undefined;
+  /** What the `direction` part says. `{direction}` is the word for the
+movement, `up-label`, `down-label` or `unchanged-label`, and
+`{judgment}` is `better` or `worse` where `good` judges the move, so a
+language whose words agree with the movement writes each phrase whole:
+`{judgment, select, better {...} worse {...} other {...}}`.
+`{betterLabel}` and `{worseLabel}` are `better-label` and `worse-label`. */
+  judgmentLabel?: (HelixHeadlessTrend["judgmentLabel"]) | undefined;
+  /** The locale the words and `value` are in, such as `de` for `1.234,5`.
+
+Absent reads the nearest `lang`, then the runtime's own. Set it on a page rendered on a server, so
 the server and the browser write the figure alike. */
   locale?: (HelixHeadlessTrend["locale"]) | undefined;
   /** Which way the measurement moved.
@@ -14856,9 +15755,11 @@ both are written. The size is written in the `value` part with
 `format-options` and `locale`, in place of a slotted metric. Absent leaves
 the movement to `movement` and the metric to the slot. */
   value?: (HelixHeadlessTrend["value"]) | undefined;
-  /** The word read out after the direction when the move is a setback. */
+  /** The word read out after the direction when the move is a setback,
+`{worseLabel}` in `judgment-label`. */
   "worse-label"?: (HelixHeadlessTrend["worseLabel"]) | undefined;
-  /** The word read out after the direction when the move is a setback. */
+  /** The word read out after the direction when the move is a setback,
+`{worseLabel}` in `judgment-label`. */
   worseLabel?: (HelixHeadlessTrend["worseLabel"]) | undefined;
 };
 
@@ -15143,9 +16044,11 @@ ours to promise: the attribute is ignored cross-origin, so a file served
 from somewhere else opens rather than saves, which is the browser's rule
 and not something a player can work around. */
   extraControls?: (HelixHeadlessVideo["extraControls"]) | undefined;
-  /** What the control that skips ahead is called, with `{seconds}` filled in. */
+  /** What the control that skips ahead is called. `{seconds}` is how far, written
+in the locale, and each language writes the forms it has. */
   "forward-label"?: (HelixHeadlessVideo["forwardLabel"]) | undefined;
-  /** What the control that skips ahead is called, with `{seconds}` filled in. */
+  /** What the control that skips ahead is called. `{seconds}` is how far, written
+in the locale, and each language writes the forms it has. */
   forwardLabel?: (HelixHeadlessVideo["forwardLabel"]) | undefined;
   /** What the control that fills the screen is called.
 
@@ -15239,9 +16142,13 @@ bar: two of the same control is worse than either placement. */
   "pause-label"?: (HelixHeadlessVideo["pauseLabel"]) | undefined;
   /** The name of the play control while pressing it would pause the video. */
   pauseLabel?: (HelixHeadlessVideo["pauseLabel"]) | undefined;
-  /** How the volume is read out, with `{percent}` filled in. */
+  /** How the volume is read out. `{percent}` is the volume from 0 to 100,
+written in the locale, and a language that needs plural forms writes them
+with `{percent, plural, ...}`. */
   "percent-label"?: (HelixHeadlessVideo["percentLabel"]) | undefined;
-  /** How the volume is read out, with `{percent}` filled in. */
+  /** How the volume is read out. `{percent}` is the volume from 0 to 100,
+written in the locale, and a language that needs plural forms writes them
+with `{percent, plural, ...}`. */
   percentLabel?: (HelixHeadlessVideo["percentLabel"]) | undefined;
   /** What the control that floats the video over other windows is called. */
   "pip-label"?: (HelixHeadlessVideo["pipLabel"]) | undefined;
@@ -15273,9 +16180,11 @@ this is what a screen reader calls it on arriving. */
   "remote-label"?: (HelixHeadlessVideo["remoteLabel"]) | undefined;
   /** What the control that casts the video to another device is called. */
   remoteLabel?: (HelixHeadlessVideo["remoteLabel"]) | undefined;
-  /** What the control that skips back is called, with `{seconds}` filled in. */
+  /** What the control that skips back is called. `{seconds}` is how far, written
+in the locale, and each language writes the forms it has. */
   "rewind-label"?: (HelixHeadlessVideo["rewindLabel"]) | undefined;
-  /** What the control that skips back is called, with `{seconds}` filled in. */
+  /** What the control that skips back is called. `{seconds}` is how far, written
+in the locale, and each language writes the forms it has. */
   rewindLabel?: (HelixHeadlessVideo["rewindLabel"]) | undefined;
   /** What the scrubber is called. */
   "seek-label"?: (HelixHeadlessVideo["seekLabel"]) | undefined;
@@ -15475,7 +16384,8 @@ arrive. The list does not ask for more while it is set. */
   loadingLabel?: (HelixHeadlessVirtualList["loadingLabel"]) | undefined;
   /** Places each row by its own measured height. Without it, rows are placed
 by one height: `estimate` until rows are drawn, then the drawn rows' height,
-read once.
+read once. Rows that come out different heights are placed by their own
+heights either way.
 
 **Off by default, because the straight line is better when it holds.** One
 height makes offset and index convert by division, which can never
@@ -15539,6 +16449,8 @@ export type CustomCssProperties = {
   "--bar-chart-secondary"?: (string) | undefined;
   /** The gradient for a bar, named per bar so the styled tier can use it as the `fill`. It is always drawn, and used only when `wash="gradient"` is set. */
   "--chart-bar-wash"?: (string) | undefined;
+  /** Written on the control inside each toggle button of a group with `selection-mode`: `1` while it is pressed and `0` while it is not. Read it in a `::part(button)` rule to draw the pressed look. */
+  "--button-group-pressed"?: (string) | undefined;
   /** Space between slides. Your stylesheet sets it, and the component uses it to measure the run. */
   "--carousel-gap"?: (string) | undefined;
   /** The size of one pane. Your stylesheet sets it, and the component uses it to measure the run. */
@@ -15721,7 +16633,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessAccordionVueProps,
     HelixHeadlessAccordionVueEvents
   >;
-  /** An announcement is a banner above the page header with news about the whole site or session, such as a trial ending, a degraded service, or a change of terms. For a passage inside a document, use 'Callout', which stays where it is placed and cannot be dismissed.  The announcement is always a polite live region, whatever its 'tone'. 'role="alert"' is assertive and interrupts a screen reader, so an announcement served with the page would interrupt on every page load.  The live region is its own part. When the announcement appears after the page has loaded, the message is written into the region one frame later, so screen readers read it reliably, and the region is emptied seven seconds later. While the region holds the copy, the message itself is hidden from screen readers, so it is in the page once. When the announcement is in the served HTML, the region stays empty and nothing is read out.  The dismiss button fires 'helix-dismiss', and the announcement stays in the document, so remove it in your listener. The event is cancelable, and 'dismiss()' returns 'false' when a listener calls 'preventDefault()'. When your listener removes an announcement whose dismiss button has focus, focus moves to the dismiss button of the announcement beside it. With no other announcement beside it, move focus yourself, for example to the page's main heading.  Set 'duration' to dismiss it after a time. The clock stops while the pointer or focus is on the announcement, and continues from what was left, so a reader partway through is not cut off. It stops while the page is hidden too, in another tab or a minimized window, so the message is not spent where nobody can see it. While the clock is stopped the announcement carries ':state(paused)'. When the time runs out it sends 'helix-dismiss', as the button does. */
+  /** An announcement is a banner above the page header with news about the whole site or session, such as a trial ending, a degraded service, or a change of terms. For a passage inside a document, use 'Callout', which stays where it is placed and cannot be dismissed.  The announcement is always a polite live region, whatever its 'tone'. 'role="alert"' is assertive and interrupts a screen reader, so an announcement served with the page would interrupt on every page load.  The live region is its own part. When the announcement appears after the page has loaded, the message is written into the region one frame later, so screen readers read it reliably, and the region is emptied seven seconds later. While the region holds the copy, the message itself is hidden from screen readers, so it is in the page once. When the announcement is in the served HTML, the region stays empty and nothing is read out.  The dismiss button fires 'helix-dismiss', and the announcement stays in the document, so remove it in your listener. The event is cancelable, and 'dismiss()' returns 'false' when a listener calls 'preventDefault()'. When your listener removes an announcement whose dismiss button has focus, focus moves to the dismiss button of the announcement beside it. With no other announcement beside it, move focus yourself, for example to the page's main heading.  **The announcement is a landmark region**, named by 'label', "Announcement" unless you set it, so a screen reader lists it among the page's regions. 'hotkey', F6 unless you set it, moves focus to the announcement's first control, an action or the dismiss button, and pressed there moves focus back to where it was, as React Aria's toast region does. An announcement with no control leaves the key to the browser. When an announcement that the key moved focus into is removed with focus still inside, focus goes back to where it was before the key.  **Set 'queued' to show several announcements one at a time.** A queued announcement waits while a queued announcement before it in the same parent is still there, and shows when that one is removed: its message is then read out, and its 'duration' starts. While it waits it renders nothing, is no region, and carries ':state(waiting)'. A server cannot see the announcements beside it, so a served page shows every one until the script runs.  Set 'duration' to dismiss it after a time. The clock stops while the pointer or focus is on the announcement, and continues from what was left, so a reader partway through is not cut off. It stops while the page is hidden too, in another tab or a minimized window, so the message is not spent where nobody can see it. While the clock is stopped the announcement carries ':state(paused)'. When the time runs out it sends 'helix-dismiss', as the button does. */
   "helix-headless-announcement": DefineCustomElement<
     HelixHeadlessAnnouncement,
     HelixHeadlessAnnouncementVueProps,
@@ -15763,7 +16675,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessBarChartVueProps,
     HelixHeadlessBarChartVueEvents
   >;
-  /** Renders a '<figure>' holding the '<blockquote>' and a '<figcaption>' for the attribution, the structure the HTML spec describes. The attribution sits outside the quotation because it is about the quotation, and it names the figure, so a screen reader reads the source as the figure's caption.  The figure keeps the browser's default margins on this tier. Set '::part(figure) { margin: 0 }' where they are unwanted.  For a quotation inside a sentence, use 'Quote'. */
+  /** Renders a figure holding the '<blockquote>' and a caption for the attribution, the structure the HTML spec describes. The attribution sits outside the quotation because it is about the quotation, and it names the figure, so a screen reader reads the source as the figure's caption.  **The figure is a '<div role="figure">'**, so the headless tier draws no space around the quotation. A '<figure>' takes a 40px indent and a line of space above and below from the browser's own sheet, which every page had to reset. The '<blockquote>' keeps its own margins, as a bare one does. A screen reader meets the same figure, named by its caption.  **A figure only while there is an attribution.** With nothing in the caption the figure has no name and nothing to say, so the role and its name are dropped and a reader meets the quotation alone. A server cannot see what is slotted, so it serves the figure, and the client drops it after hydration; an 'attribution' written as words is served exactly.  **Quotation marks follow the language**, under 'marks'. The opening mark is the one the browser sets for a '<q>' in the element's language, „ under 'lang="de"' and « under 'lang="fr"', and a 'Quote' inside the passage takes the inner marks. The mark is drawn, not read: a screen reader hears the passage. A passage under 'marks' that starts with a mark typed into the text would show two, and warns once, with the runtime kind 'typed-marks'.  **'cite' is the source's URL**, which the browser keeps and does not show. Words in it, such as the author's name, warn once, with the runtime kind 'cite-not-url'.  For a quotation inside a sentence, use 'Quote'. */
   "helix-headless-blockquote": DefineCustomElement<
     HelixHeadlessBlockquote,
     HelixHeadlessBlockquoteVueProps,
@@ -15781,7 +16693,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessBreadcrumbsVueProps,
     HelixHeadlessBreadcrumbsVueEvents
   >;
-  /** Sets 'role="group"' on the host through internals, and 'label' names the group. Without a name, a screen reader announces the buttons as separate controls, and a development build warns once with the kind 'missing-name'.  The group does not manage focus, so each button keeps its own tab stop. For one tab stop with arrow keys between the buttons, the APG toolbar pattern, use Toolbar.  Buttons are slotted, so they stay your own elements and keep their own appearance and size. */
+  /** Sets 'role="group"' on the host through internals, and 'label' names the group. Without a name, a screen reader announces the buttons as separate controls, and a development build warns once with the kind 'missing-name'.  The group does not manage focus, so each button keeps its own tab stop. For one tab stop with arrow keys between a mix of controls, the APG toolbar pattern, use Toolbar.  Buttons are slotted, so they stay your own elements and keep their own appearance and size.  **Buttons that stay pressed.** With 'selection-mode', each button with a 'value' is a toggle button: a press presses or releases it, and it says so with 'aria-pressed'. 'single' keeps one pressed at a time, and a press on the pressed one releases it. 'multiple' lets any number be pressed. 'value' is the pressed values, comma separated. A press sends a cancelable 'helix-before-change' with the value it would leave, then 'change'.  The pressed state is written on the control inside each button's shadow root, so the markup you rendered is never changed and a framework hydrating it sees what its server sent. That is also why only Helix buttons are toggles: a native '<button>' or a button without a 'value' stays a plain action button in the group, and a native one without its own 'aria-pressed' warns once, with the runtime kind 'untold-toggle'. The inner control also carries '--button-group-pressed', '1' or '0', for a '::part(button)' rule of yours.  Use Toggle Group instead for a choice that belongs in a form, or one where the arrow keys choose as they move: it is a 'radiogroup' of options with a form value, 'required' and validation. A Button Group in a selection mode is a set of actions that stay on, such as bold and italic, or a view that a press switches, and it submits nothing.  **Keyboard.** In a selection mode the group is one tab stop: the button focus was last on, then the first pressed one, then the first one.  | Key | What it does | |---|---| | Right, Down | Moves to the next button, from the last back to the first. | | Left, Up | Moves to the button before, from the first round to the last. | | Home, End | Moves to the first or the last button. | | Space, Enter | Presses or releases the focused button. |  Left and Right swap on a right-to-left page, and a disabled button is passed over. In a selection mode the group is a 'toolbar', with 'aria-orientation' under 'orientation="vertical"'. Inside a toolbar it stays a named 'group', and the toolbar's own arrow keys walk its buttons, so a reader meets one toolbar. */
   "helix-headless-button-group": DefineCustomElement<
     HelixHeadlessButtonGroup,
     HelixHeadlessButtonGroupVueProps,
@@ -15811,7 +16723,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessCanvasNodeVueProps,
     HelixHeadlessCanvasNodeVueEvents
   >;
-  /** A board of cards and connectors, drawn by Helix. On a canvas every position is data that someone placed, so drawing is arithmetic over rectangles with no layout to compute. 'Map' takes a slotted map, because another renderer draws its tiles.  The format is [JSON Canvas](https://jsoncanvas.org), an open format. Each node has an 'x', 'y', 'width', 'height', and a type. Each edge names the two nodes it joins and the sides it leaves and arrives on. A card belongs to a group when it sits inside the group's bounds.  The cards are text in the DOM, so a screen reader can read them. The family adds a reading order and states each card's connections as text. 'order' sets the reading order: - 'spatial' bands the cards into rows. - 'edges' follows the arrows, starting from the cards that nothing points to.  **Cards move by default.** The board writes the new 'x' and 'y' onto the card, the way an input writes its own value, and dispatches two events: - 'helix-before-move' for every step. Cancel it to hold the positions in your   own state and apply them yourself. - 'helix-move' once the move is finished.  A resize dispatches the same pair with a size. Set 'readonly' on the board to keep every card in place, such as on a published board. Set 'readonly' on one card or connection to keep only that one in place.  Keyboard behavior: - One card holds the board's tab stop. - The arrow keys move through the cards in reading order. The card you land   on scrolls into view, and its connections are announced with it. - Shift with an arrow key moves the card. - The connections leaving a card are stops of their own, straight after it.   Enter on one moves to the card it arrives at.  Every drag also works with clicks, as WCAG 2.5.7 requires for a pointer that cannot hold a button down. Click a selected card's move handle, a corner, a card's connection point, or the end of a selected connection to pick it up. It follows the pointer with no button held, and the next click puts it down where a drag would have. On touch, the next tap sets where it lands. Escape, or a press outside the board, puts it back.  Connecting and removing dispatch requests, and your code applies them: - Drawing from a card's handle to another card, or pressing C on one card and   Enter on another, dispatches 'helix-connect'. - Delete on a card or a connection dispatches 'helix-remove'. The event names   every connection that removing the card would leave without an end.  The board applies a move itself, because the card already exists. A connection is a new element, and React discards an element the board adds to its markup on the next render, so you write the connection.  Cards and connections are 'helix-canvas-node' and 'helix-canvas-edge' elements, so they are in the served markup whichever renderer wrote them. The library fetches nothing, and an array passed to an element is missing from the first paint of a server-rendered React page. 'fromJsonCanvas' turns a JSON Canvas document into their props, and 'toJsonCanvas()' writes a board back out. */
+  /** A board of cards and connectors, drawn by Helix. On a canvas every position is data that someone placed, so drawing is arithmetic over rectangles with no layout to compute. 'Map' takes a slotted map, because another renderer draws its tiles.  The format is [JSON Canvas](https://jsoncanvas.org), an open format. Each node has an 'x', 'y', 'width', 'height', and a type. Each edge names the two nodes it joins and the sides it leaves and arrives on. A card belongs to a group when it sits inside the group's bounds.  The cards are text in the DOM, so a screen reader can read them. The family adds a reading order and states each card's connections as text. 'order' sets the reading order: - 'spatial' bands the cards into rows. - 'edges' follows the arrows, starting from the cards that nothing points to.  **Cards move by default.** The board writes the new 'x' and 'y' onto the card, the way an input writes its own value, and dispatches two events: - 'helix-before-move' for every step. Cancel it to hold the positions in your   own state and apply them yourself. - 'helix-move' once the move is finished.  A resize dispatches the same pair with a size. Set 'readonly' on the board to keep every card in place, such as on a published board. Set 'readonly' on one card or connection to keep only that one in place.  Set 'snap' to a length in the document's units, such as '32', and a card that is moved or resized lands on a multiple of it. Carrying a card, a corner, a connection, or the selection box near the edge of the board moves the board under it, so a card can be taken to a place off screen in one drag. A connection let go within 20 pixels of a card arrives at it. A double click on the empty board zooms in about that point, and Shift with a double click zooms out.  Keyboard behavior: - One card holds the board's tab stop. - The arrow keys move through the cards in reading order. The card you land   on scrolls into view, and its connections are announced with it. - Shift with an arrow key moves the card: by 16 units, or to the next   multiple of 'snap' where it is set. Alt with an arrow key resizes it from   its bottom right corner the same way. - The connections leaving a card are stops of their own, straight after it.   Enter on one moves to the card it arrives at. - What a key changes that a reader cannot see is said: where a card moved   to, its new size, how many cards are selected, and the zoom. A selected   card or connection says so when a reader arrives on it.  Every drag also works with clicks, as WCAG 2.5.7 requires for a pointer that cannot hold a button down. Click a selected card's move handle, a corner, a card's connection point, or the end of a selected connection to pick it up. It follows the pointer with no button held, and the next click puts it down where a drag would have. On touch, the next tap sets where it lands. Escape, or a press outside the board, puts it back. So a finger connects two cards with three taps: the card, one of its points, and the card to connect to.  Connecting and removing dispatch requests, and your code applies them: - Drawing from a card's handle to another card, or pressing C on one card and   Enter on another, dispatches 'helix-connect'. - Delete on a card or a connection dispatches 'helix-remove'. The event names   every connection that removing the card would leave without an end.  Once your page removes what Delete asked for, focus moves to the next stop, to the one before where it was the last, and to the board where none is left. A focused card your page removes for its own reasons hands focus on the same way, unless the reader has already moved focus somewhere else.  The board applies a move itself, because the card already exists. A connection is a new element, and React discards an element the board adds to its markup on the next render, so you write the connection.  Cards and connections are 'helix-canvas-node' and 'helix-canvas-edge' elements, so they are in the served markup whichever renderer wrote them. The library fetches nothing, and an array passed to an element is missing from the first paint of a server-rendered React page. 'fromJsonCanvas' turns a JSON Canvas document into their props, and 'toJsonCanvas()' writes a board back out. */
   "helix-headless-canvas": DefineCustomElement<
     HelixHeadlessCanvas,
     HelixHeadlessCanvasVueProps,
@@ -15883,7 +16795,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessColorPickerVueProps,
     HelixHeadlessColorPickerVueEvents
   >;
-  /** The list is a 'Listbox', which handles filtering, the empty state, the highlight, 'aria-activedescendant', and scrolling an option into view. This element handles the field, the panel, and the communication between them.  The typed text and the value are separate. The text is a filter: it narrows the list and is then discarded. The value is the option you choose, and the field then shows that option's text. The filter clears on close, so a reopened combobox starts from the whole list.  Focus stays in the text field. The arrow keys move through the list with the listbox's public 'navigate' method. 'role="combobox"' is on the input itself. ArrowDown and ArrowUp open the list on the chosen option, and Enter chooses the highlighted one. As typing narrows the list, a screen reader hears how many options are left, such as "3 results". Space, Home, End and letters edit the text, and Enter in a closed field is left to the form. Emptying the field and leaving it clears a single choice; Escape puts the chosen words back, and a second Escape on the closed field clears the choice.  With 'multiple', each chosen option is a tag in the field with its own remove control. The panel stays open and the filter clears after each choice, so the next choice starts from the whole list.  With 'creatable', the combobox offers a create row and fires 'helix-create'. It does not add the option. The options are your light DOM, and your framework would re-render over an element the combobox inserted, so add the option in your event handler. */
+  /** The list is a 'Listbox', which handles filtering, the empty state, the highlight, 'aria-activedescendant', and scrolling an option into view. This element handles the field, the panel, and the communication between them.  The typed text and the value are separate. The text is a filter: it narrows the list and is then discarded. The value is the option you choose, and the field then shows that option's text. The filter clears on close, so a reopened combobox starts from the whole list.  Focus stays in the text field. The arrow keys move through the list with the listbox's public 'navigate' method. As typing narrows the list, a screen reader hears how many options are left, such as "3 results". Emptying the field and leaving it clears a single choice.  **Keyboard.**  | Key | What it does | |---|---| | Down, Up | On a closed field, opens the list on the chosen option, or the first or the last. In the open list, moves the highlight, round from the last option to the first. | | Page Down, Page Up | In the open list, moves the highlight by as many options as the list shows at once. | | Enter | Chooses the highlighted option. With nothing left in the list, creates what was typed with 'creatable', or takes it with 'allows-custom-value'. On a closed field, submits the form. | | Escape | Closes the list and puts the chosen words back. On a closed field, a second Escape clears a single choice. | | Tab | Closes the list and moves on. | | Backspace | With 'multiple', on an empty field, removes the last tag. | | Space, Home, End, letters | Edit the text. |  **ARIA.** The input is the 'combobox', named by the label, with 'aria-expanded', 'aria-controls' naming the list, 'aria-autocomplete' ('both' with 'suggest', 'list' otherwise) and 'aria-activedescendant' on the highlighted option. The list is the listbox 'Listbox' describes.  On Apple devices, where VoiceOver does not read the option the field points to, the field says it in a live region as the highlight moves, says how many options there are as the list opens, and says a choice once it is made, as React Aria's combobox does there.  Set 'autocomplete' to let a browser's autofill choose an option.  With 'multiple', each chosen option is a tag in the field with its own remove control. The panel stays open and the filter clears after each choice, so the next choice starts from the whole list.  With 'creatable', the combobox offers a create row and fires 'helix-create'. It does not add the option. The options are your light DOM, and your framework would re-render over an element the combobox inserted, so add the option in your event handler. */
   "helix-headless-combobox": DefineCustomElement<
     HelixHeadlessCombobox,
     HelixHeadlessComboboxVueProps,
@@ -15901,7 +16813,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessCopyButtonVueProps,
     HelixHeadlessCopyButtonVueEvents
   >;
-  /** Declare the columns as 'TableColumn' children and pass the rows as an array. The schema stays readable in the HTML, and the rows can be windowed, which ten thousand row elements cannot be.  '''html <helix-headless-data-table .rows=${rows} sort="name:asc" page-size="20">   <helix-headless-table-column field="name" sortable>Name</helix-headless-table-column>   <helix-headless-table-column field="size" text-align="end" sortable .cell=${bytes}>Size</helix-headless-table-column> </helix-headless-data-table> '''  For a short table written out by hand, use 'Table', which takes rows as markup.  Sort and filter apply to the whole set, including the rows on other pages.  **The cell values do not server-render.** The headings and the row elements do. Reading a cell needs the columns, and Lit SSR does not pass the column children to this element, so a crawler sees an empty table of the right shape. Use 'Table' when the served HTML has to carry the values.  'selectable' adds a column of checkboxes, keyed on 'row-key':  - A row is selected by its key, so the selection survives a sort, a filter,   and a page change. - 'selected' holds the chosen keys, comma separated, the same shape 'Listbox'   uses for a multiple choice. As with 'sort', writing it applies the   selection, and 'default-selected' holds what the markup declared. - The checkbox in the heading selects every row in the result, across pages,   and shows a dash while only some are chosen. - Shift with a press on a checkbox selects every row between it and the row   last chosen.  To act on a single row, such as opening it, put a link or a button in a cell.  **Keyboard.** The grid is one tab stop, and the arrow keys move between its cells, the headings included.  | Key | What it does | |---|---| | Right, Left | Moves one cell along the row. Left moves on, on a right-to-left page. | | Down, Up | Moves one row, the heading row and the 'load-more' row included. | | Home, End | Moves to the first or the last cell of the row. | | Control with Home or End | Moves to the first or the last cell of the grid. | | Page Down, Page Up | Moves by the rows that fit in view. | | Enter, F2 | Moves into the cell's controls. Escape moves back to the cell, and Tab moves between the controls of one cell. | | Enter, Space on a sortable heading | Sorts by the column. | | Enter, Space on the 'load-more' row | Sends 'helix-load-more'. | | Space on a row | Selects the row, in a 'selectable' table. | | Shift with Down or Up | Selects the rows it moves across, in a 'selectable' table. | | Shift with Space | Selects every row from the one last chosen, in a 'selectable' table. | | Control or Command with A | Selects every row, in a 'selectable' table. | | Right on a row header in a tree grid | Opens a closed row, and moves one cell along an open one. | | Left on a row header in a tree grid | Closes an open row, and moves to the parent of a closed one. | | A letter or a word | Moves to the next row whose row header starts with what you typed. |  'selected' and 'expanded' hold their keys in the order of the rows, as do 'helix-select', 'helix-selected' and 'helix-expand'.  Each row is named by its row header, the column marked 'row-header', or the first column with a 'field' where none is. A screen reader says it as a reader moves between rows.  **Rows that hold rows.** 'child-field' names the field that holds a row's child rows, and the grid becomes a tree grid. The row header column draws a mark that a press opens and closes a row by, and 'expanded' holds the keys of the open rows, which 'row-key' names. Right on a closed row's header opens it, Left on an open one closes it, and Left on a child moves to its parent. A sort orders the rows under each parent, and a search shows the rows that lead to each match, open.  'load-more' adds a row after the last one with a button that sends 'helix-load-more'. A 'windowed' table also sends it by itself once a reader scrolls within one screen of the end, once for each number of rows. Add the next rows to 'rows', and set 'loading' while they are on their way.  The controls inside the cells leave the tab order, so Tab moves past the whole grid. A windowed table keeps the row holding focus drawn while the rest scroll away.  People can resize and reorder the columns. 'resizable' on a column puts a separator on its edge. 'reorderable' on the table puts a grip on each heading that has a 'field', moved by dragging or with the arrow keys. The new order is written to 'order' as a list of fields. Your markup is not rewritten: the table assigns the headings to its header in that order.  'csv()' returns the result as text: every row that passes the filter, in the order and the columns on screen. Saving the file is up to you.  'DataTable' has no 'columns' attribute. Each 'TableColumn' is part of the schema, so you size a column with its own 'width'. 'Table' has 'columns' because its cells are markup you write and it can have no columns at all. Written on 'DataTable', 'columns' has no effect, so watch for it when you move a table from 'Table' to 'DataTable'. */
+  /** Declare the columns as 'TableColumn' children and pass the rows as an array. The schema stays readable in the HTML, and the rows can be windowed, which ten thousand row elements cannot be.  '''html <helix-headless-data-table .rows=${rows} sort="name:asc" page-size="20">   <helix-headless-table-column field="name" sortable>Name</helix-headless-table-column>   <helix-headless-table-column field="size" text-align="end" sortable .cell=${bytes}>Size</helix-headless-table-column> </helix-headless-data-table> '''  For a short table written out by hand, use 'Table', which takes rows as markup.  Sort and filter apply to the whole set, including the rows on other pages.  **The cell values do not server-render.** The headings and the row elements do. Reading a cell needs the columns, and Lit SSR does not pass the column children to this element, so a crawler sees an empty table of the right shape. Use 'Table' when the served HTML has to carry the values.  'selectable' adds a column of checkboxes, keyed on 'row-key':  - A row is selected by its key, so the selection survives a sort, a filter,   and a page change. - 'selected' holds the chosen keys, comma separated, the same shape 'Listbox'   uses for a multiple choice. As with 'sort', writing it applies the   selection, and 'default-selected' holds what the markup declared. - The checkbox in the heading selects every row in the result, across pages,   and shows a dash while only some are chosen. - Shift with a press on a checkbox selects every row between it and the row   last chosen.  To act on a single row, such as opening it, put a link or a button in a cell.  **Keyboard.** The grid is one tab stop, and the arrow keys move between its cells, the headings included.  | Key | What it does | |---|---| | Right, Left | Moves one cell along the row. Left moves on, on a right-to-left page. | | Down, Up | Moves one row, the heading row and the 'load-more' row included. | | Home, End | Moves to the first or the last cell of the row. | | Control with Home or End | Moves to the first or the last cell of the grid. | | Page Down, Page Up | Moves by the rows that fit in view. | | Enter, F2 | Moves into the cell's controls. Escape moves back to the cell, and Tab moves between the controls of one cell. | | Enter, Space on a sortable heading | Sorts by the column. | | Enter, Space on the 'load-more' row | Sends 'helix-load-more'. | | Space on a row | Selects the row, in a 'selectable' table. | | Shift with Down or Up | Selects the rows it moves across, in a 'selectable' table. | | Shift with Space | Selects every row from the one last chosen, in a 'selectable' table. | | Control or Command with A | Selects every row, in a 'selectable' table. | | Right on a row header in a tree grid | Opens a closed row, and moves one cell along an open one. | | Left on a row header in a tree grid | Closes an open row, and moves to the parent of a closed one. | | A letter or a word | Moves to the next row whose row header starts with what you typed. |  'selected' and 'expanded' hold their keys in the order of the rows, as do 'helix-select', 'helix-selected' and 'helix-expand'.  Each row is named by its row header, the column marked 'row-header', or the first column with a 'field' where none is. A screen reader says it as a reader moves between rows.  **Rows that hold rows.** 'child-field' names the field that holds a row's child rows, and the grid becomes a tree grid. The row header column draws a mark that a press opens and closes a row by, and 'expanded' holds the keys of the open rows, which 'row-key' names. Right on a closed row's header opens it, Left on an open one closes it, and Left on a child moves to its parent. A sort orders the rows under each parent, and a search shows the rows that lead to each match, open.  'load-more' adds a row after the last one with a button that sends 'helix-load-more'. A 'windowed' table also sends it by itself once a reader scrolls within one screen of the end, once for each number of rows. Add the next rows to 'rows', and set 'loading' while they are on their way.  The controls inside the cells leave the tab order, so Tab moves past the whole grid. A windowed table keeps the row holding focus drawn while the rest scroll away.  People can resize and reorder the columns. 'resizable' on a column puts a separator on its edge. 'reorderable' on the table puts a grip on each heading that has a 'field', moved by dragging or with the arrow keys. The new order is written to 'order' as a list of fields. Your markup is not rewritten: the table assigns the headings to its header in that order.  **'reorderable-rows' lets people move rows.** A column of grips leads each row, named by 'move-row-label'. Drag a grip to move its row, and the table scrolls near an edge. Or press Space or Enter on a grip, or click it, to pick up its row, move it with Down and Up, Home and End, and press Space or Enter again to drop it. A click on another row drops it there, and Escape puts it back. The table says each step in its 'live' region. A drop sends 'helix-before-reorder', which you can refuse, and then 'helix-reorder' with 'kind' set to 'row', whose 'keys' hold every key of 'rows' in the new order. **You move the rows**: set 'rows' to the new order, and the table draws it. Set 'row-key', so a row is known by its key once it has moved. The grips do nothing while a 'sort' is set, since the sort decides the order, and a tree grid draws none.  'csv()' returns the result as text: every row that passes the filter, in the order and the columns on screen. Saving the file is up to you.  'DataTable' has no 'columns' attribute. Each 'TableColumn' is part of the schema, so you size a column with its own 'width'. 'Table' has 'columns' because its cells are markup you write and it can have no columns at all. Written on 'DataTable', 'columns' has no effect, so watch for it when you move a table from 'Table' to 'DataTable'. */
   "helix-headless-data-table": DefineCustomElement<
     HelixHeadlessDataTable,
     HelixHeadlessDataTableVueProps,
@@ -15913,7 +16825,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessDateInputVueProps,
     HelixHeadlessDateInputVueEvents
   >;
-  /** A grid of days that follows the APG date grid pattern:  - The grid is one tab stop. Only the focused cell is in the tab sequence. - Arrow keys move by day and by week. - 'PageUp' and 'PageDown' move by month. - 'Home' and 'End' move to the start and end of the week.  **Dates are 'YYYY-MM-DD' strings, and every calculation is in UTC**, because a local-time 'Date' shifts across a time zone or daylight-saving boundary.  'month' sets which month the grid shows, separately from 'value', so paging selects nothing and you can control the view. When unset, it follows the first selected date, then the current month.  'mode' sets how many dates are held. Unset holds one, 'range' holds two and marks the dates between them, and 'multiple' toggles each date. All three read and write the same comma-separated 'value'.  'max-view' makes the heading a button that steps back to the months of the year, and with 'year' to a page of years, as Zag's date picker does. The arrows, Home, End and the page keys move there, Enter or a press chooses, and Escape goes back to the days.  'isDateUnavailable' and 'dayContent' are properties for a script: a rule that bars dates, and what each day shows in place of its number.  The month heading is a live region, so a screen reader hears the new month when Previous or Next is pressed. Neither moves past 'min' or 'max', and the keys stop at them too. A value outside the bounds, on a barred day, or off 'step' reports 'rangeUnderflow', 'rangeOverflow', 'badInput' or 'stepMismatch', so a form does not submit it. */
+  /** A grid of days that follows the APG date grid pattern:  - The grid is one tab stop. Only the focused cell is in the tab sequence. - Arrow keys move by day and by week. - 'PageUp' and 'PageDown' move by month. - 'Home' and 'End' move to the start and end of the week.  **Dates are 'YYYY-MM-DD' strings, and every calculation is in UTC**, because a local-time 'Date' shifts across a time zone or daylight-saving boundary.  **The days are the Gregorian calendar's**, written in 'calendar': the locale's own where its months are the Gregorian months, as 'th-TH' writes 2569 for 2026, and 'gregory' where they are not, as for 'fa-IR'.  'month' sets which month the grid shows, separately from 'value', so paging selects nothing and you can control the view. When unset, it follows the first selected date, then the current month.  'mode' sets how many dates are held. Unset holds one, 'range' holds two and marks the dates between them, and 'multiple' toggles each date. All three read and write the same comma-separated 'value'.  'max-view' makes the heading a button that steps back to the months of the year, and with 'year' to a page of years, as Zag's date picker does. The arrows, Home, End and the page keys move there, Enter or a press chooses, and Escape goes back to the days.  'isDateUnavailable' and 'dayContent' are properties for a script: a rule that bars dates, and what each day shows in place of its number.  The month heading is a live region, so a screen reader hears the new month when Previous or Next is pressed. Neither moves past 'min' or 'max', and the keys stop at them too. A value outside the bounds, on a barred day, or off 'step' reports 'rangeUnderflow', 'rangeOverflow', 'badInput' or 'stepMismatch', so a form does not submit it. */
   "helix-headless-date-picker": DefineCustomElement<
     HelixHeadlessDatePicker,
     HelixHeadlessDatePickerVueProps,
@@ -15931,13 +16843,13 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessDescriptionListVueProps,
     HelixHeadlessDescriptionListVueEvents
   >;
-  /** Renders a native '<dialog>' opened with 'showModal()'. The platform provides:  - the top layer, so the dialog is above everything whatever the 'z-index' - a backdrop - closing with Escape - an inert page behind the dialog, unreachable by pointer, keyboard, or   virtual cursor  The dialog adds one thing to those: 'Tab' from its last control goes to its first, and 'Shift+Tab' from its first to its last. A native modal lets 'Tab' past its last control out to the browser's own controls.  'open' calls 'showModal()', and every way the dialog closes goes through 'requestOpen'. A native dialog closes three ways: the property, Escape, and a '<form method="dialog">' submit. Routing all three through 'requestOpen' keeps your state in step, so the dialog never closes while your state still says it is open, which would leave it impossible to reopen.  The dialog's name is 'label' when you set it. Otherwise it is the heading in the 'header' slot, or the elements an 'aria-labelledby' on the host names. While it is open, the page behind it does not scroll.  The dialog is described by the words at the start of its body: the elements in the default slot before the first one that is or holds a control. A question above a form describes the dialog, and the form does not. A Helix component that draws words and no control, such as 'Text', counts as words. An 'aria-describedby' on the host replaces it.  Set 'alert' for a dialog that interrupts to ask for an answer, such as a confirmation before a deletion. It is an 'alertdialog', which a screen reader announces with its description as it opens. Set 'dismissible' to draw a close control, labeled by 'dismiss-label'. */
+  /** Renders a native '<dialog>' opened with 'showModal()'. The platform provides:  - the top layer, so the dialog is above everything whatever the 'z-index' - a backdrop - closing with Escape - an inert page behind the dialog, unreachable by pointer, keyboard, or   virtual cursor  The dialog adds one thing to those: 'Tab' from its last control goes to its first, and 'Shift+Tab' from its first to its last. A native modal lets 'Tab' past its last control out to the browser's own controls.  'open' calls 'showModal()', and every way the dialog closes goes through 'requestOpen'. A native dialog closes three ways: the property, Escape, and a '<form method="dialog">' submit. Routing all three through 'requestOpen' keeps your state in step, so the dialog never closes while your state still says it is open, which would leave it impossible to reopen.  The dialog's name is 'label' when you set it. Otherwise it is the heading in the 'header' slot, or the elements an 'aria-labelledby' on the host names, and 'fallback-label' where nothing names it. While it is open, the page behind it does not scroll.  The dialog is described by the words at the start of its body: the elements in the default slot before the first one that is or holds a control. A question above a form describes the dialog, and the form does not. A Helix component that draws words and no control, such as 'Text', counts as words. An 'aria-describedby' on the host replaces it.  Set 'alert' for a dialog that interrupts to ask for an answer, such as a confirmation before a deletion. It is an 'alertdialog', which a screen reader announces with its description as it opens. Set 'dismissible' to draw a close control, labeled by 'dismiss-label'. */
   "helix-headless-dialog": DefineCustomElement<
     HelixHeadlessDialog,
     HelixHeadlessDialogVueProps,
     HelixHeadlessDialogVueEvents
   >;
-  /** The separator role is on the rule inside the shadow root. A role does not need to cross the shadow boundary the way an IDREF does, so it can sit on the rendered element. The semantics are then in the server-rendered markup, with no attribute written by script after the element connects.  Set 'announced' for a line that divides one thing from another, and it is read as a separator, named by any content set into it.  Use 'orientation="vertical"' between items on one line, such as inside a toolbar. A vertical divider stretches to fit its flex parent and sets no height of its own. */
+  /** The separator role is on the rule inside the shadow root. A role does not need to cross the shadow boundary the way an IDREF does, so it can sit on the rendered element. The semantics are then in the server-rendered markup, with no attribute written by script after the element connects.  **The line is a separator**, as '<hr>' is, and as Radix Separator, React Aria Separator, and Web Awesome's divider are. It is named by any content set into it, so a screen reader says "Or, separator" where you wrote "Or" on the line. Set 'decorative' on a rule that separates nothing, such as one under a heading or between the facts of a byline, and it leaves the accessibility tree.  Use 'orientation="vertical"' between items on one line. A vertical divider stretches to fit its flex parent and sets no height of its own.  **Inside a toolbar it runs across the toolbar** without being told: vertical in a horizontal toolbar and horizontal in a vertical one, with 'aria-orientation' to match, as React Aria's separator does inside a toolbar. Inside means a child of Toolbar or of the page's own 'role="toolbar"'. An 'orientation' you write still wins. A server cannot see the toolbar, so the turn arrives with hydration, inside the shadow root. */
   "helix-headless-divider": DefineCustomElement<
     HelixHeadlessDivider,
     HelixHeadlessDividerVueProps,
@@ -15949,7 +16861,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessDonutChartVueProps,
     HelixHeadlessDonutChartVueEvents
   >;
-  /** Uses 'MixinControllerOpen', so 'open', 'defaultOpen', and the 'helix-before-open' and 'helix-before-close' events work the same way as on an accordion item.  The drawer is modal by default, which means four things:  - focus is trapped inside: 'Tab' from the last control goes to the first,   and 'Shift+Tab' from the first to the last, as in 'Dialog' - Escape and a press outside close it - the page behind is covered - the page behind does not scroll  A drawer with 'modal="false"' leaves the page usable and still closes on Escape, in a browser without 'closedby' as well.  **A touch or a pen swipes it away**, toward the edge it came from, resolved against the writing direction. A swipe past halfway, or a quick one, closes it through the same request as every other way out. 'snap-points' lists the fractions of the panel a reader can leave on screen, such as '0.5 1' for a sheet that rests half open: it opens at the smallest, and a swipe settles at the nearest. While a swipe moves the panel, the distance is written on it as '--drawer-swipe-x' and '--drawer-swipe-y'. 'swipe="false"' turns swiping off.  'snap' is the snap point the panel rests at, and ':state(snapped)' is on the host while that is less than the whole panel. 'snapTo()' moves it to another. **Focus moving to a control past the window's edge opens the panel to its largest snap point**, so a reader moving through a half open sheet with 'Tab' never lands on a control they cannot see.  Set 'dismissible' to draw a close control in the corner, labeled by 'dismiss-label', as 'Dialog' draws one.  The panel's name is 'label' when you set it. Otherwise it is the heading in the 'header' slot, or the elements an 'aria-labelledby' on the host names.  Content stays mounted when the drawer is closed, so it is in the server markup and can animate. A closed '<dialog>' is already out of the tab order and the accessibility tree, so the drawer does not write 'inert'. The 'role', 'aria-modal', and the scrim also come from the '<dialog>' element. 'drawer-root.ssr.spec.ts' checks that the panel has no hand-written 'inert' or 'role'.  Open the drawer declaratively with the platform's invoker attributes:  '''html <helix-headless-button commandfor="nav" command="--toggle">Menu</helix-headless-button> <helix-headless-drawer id="nav">…</helix-headless-drawer> ''' */
+  /** Uses 'MixinControllerOpen', so 'open', 'defaultOpen', and the 'helix-before-open' and 'helix-before-close' events work the same way as on an accordion item.  The drawer is modal by default, which means four things:  - focus is trapped inside: 'Tab' from the last control goes to the first,   and 'Shift+Tab' from the first to the last, as in 'Dialog' - Escape and a press outside close it - the page behind is covered - the page behind does not scroll  A drawer with 'modal="false"' leaves the page usable and still closes on Escape, in a browser without 'closedby' as well.  **A touch or a pen swipes it away**, toward the edge it came from, resolved against the writing direction. A swipe past halfway, or a quick one, closes it through the same request as every other way out. 'snap-points' lists the fractions of the panel a reader can leave on screen, such as '0.5 1' for a sheet that rests half open: it opens at the smallest, and a swipe settles at the nearest. While a swipe moves the panel, the distance is written on it as '--drawer-swipe-x' and '--drawer-swipe-y'. 'swipe="false"' turns swiping off.  'snap' is the snap point the panel rests at, and ':state(snapped)' is on the host while that is less than the whole panel. 'snapTo()' moves it to another. **Focus moving to a control past the window's edge opens the panel to its largest snap point**, so a reader moving through a half open sheet with 'Tab' never lands on a control they cannot see.  Set 'dismissible' to draw a close control in the corner, labeled by 'dismiss-label', as 'Dialog' draws one.  The panel's name is 'label' when you set it. Otherwise it is the heading in the 'header' slot, or the elements an 'aria-labelledby' on the host names, and 'fallback-label' where nothing names it.  Content stays mounted when the drawer is closed, so it is in the server markup and can animate. A closed '<dialog>' is already out of the tab order and the accessibility tree, so the drawer does not write 'inert'. The 'role', 'aria-modal', and the scrim also come from the '<dialog>' element. 'drawer-root.ssr.spec.ts' checks that the panel has no hand-written 'inert' or 'role'.  Open the drawer declaratively with the platform's invoker attributes:  '''html <helix-headless-button commandfor="nav" command="--toggle">Menu</helix-headless-button> <helix-headless-drawer id="nav">…</helix-headless-drawer> ''' */
   "helix-headless-drawer": DefineCustomElement<
     HelixHeadlessDrawer,
     HelixHeadlessDrawerVueProps,
@@ -15967,7 +16879,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessDrilldownVueProps,
     HelixHeadlessDrilldownVueEvents
   >;
-  /** Shows what would be in a region and the one action that would fill it, so an empty region does not look like one that failed to load.  The message is announced, because an empty view often replaces content that was loading, and the announcement tells a screen reader user that the search returned nothing. It is announced from a status region of its own, which is rendered empty and filled a frame after the view appears. Screen readers read a region that arrives with its text already in it inconsistently. For the seven seconds the region holds its copy, the heading and the message are hidden from screen readers, so the words are in the page once.  Every region is a bare slot. There is no 'empty-state-heading' or 'empty-state-actions' element: assign your own heading and actions to the slots.  **Or give the heading as words.** 'heading' draws them in a 'heading' part that is a heading at 'heading-level', 3 where it is not set, so a page rendering from data or on a server gets a heading a reader finds in the outline without writing the element. A heading slotted in replaces it. */
+  /** Shows what would be in a region and the one action that would fill it, so an empty region does not look like one that failed to load.  The message is announced, because an empty view often replaces content that was loading, and the announcement tells a screen reader user that the search returned nothing. It is announced from a status region of its own, which is rendered empty and filled a frame after the view appears. Screen readers read a region that arrives with its text already in it inconsistently. For the seven seconds the region holds its copy, the heading and the message are hidden from screen readers, so the words are in the page once.  Every region is a bare slot. There is no 'empty-state-heading' or 'empty-state-actions' element: assign your own heading and actions to the slots.  **Or give the heading as words.** 'heading' draws them in a 'heading' part that is a heading at 'heading-level', 3 where it is not set, so a page rendering from data or on a server gets a heading a reader finds in the outline without writing the element. A heading slotted in replaces it.  **Whatever is slotted into 'heading' is read as a heading.** An element that is no heading, such as a '<span>' or a '<p>', is set inside the 'heading' part at 'heading-level', so a screen reader still finds it in the outline. A heading element, or an element holding one, keeps its own level. A server cannot see the slotted element, so a served '<span>' becomes a heading once the script runs. */
   "helix-headless-empty": DefineCustomElement<
     HelixHeadlessEmpty,
     HelixHeadlessEmptyVueProps,
@@ -16009,7 +16921,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessFilterInputVueProps,
     HelixHeadlessFilterInputVueEvents
   >;
-  /** Formats a date with 'Intl' where it is shown, so you do not write the same 'Intl' call and options in your own code.  **'elapsed' shows compact relative time for a feed**, such as "42m", "3h", or "1d". After six days it shows a date. In en-US, 'Intl.NumberFormat' narrow renders both 'minute' and 'month' as 'm', so a compact "3m" could mean three minutes or three months. 'elapsedTime' in 'helix/core' does the measurement.  **'relative' shows the same reading in words**, such as "3 hours ago" at 'long', "3 hr. ago" at 'short' and "3h ago" at 'narrow', the styles 'sl-relative-time' offers. 'numeric="always"' says "1 day ago" where the default says "yesterday".  **'date-style' and 'time-style' take each locale's own pattern**, such as "Tuesday, August 4, 2026" at 'full', and stand in for the separate fields, which 'Intl' refuses beside them. 'hour-cycle' sets a twelve or twenty-four hour clock either way.  **The text refreshes on one timer shared by the page.** Each element schedules an update for when its current reading expires, and an element showing a date schedules none, so a long feed left open costs almost nothing. 'frozen' draws the reading once and leaves it.  **The output is always '<time datetime>'**, so copy and paste and scripts parsing the page get the exact instant, whatever the visible text says. A screen reader reads the text, so an 'elapsed' reading is named in full, such as "3 hours ago", and carries the whole date as its title.  **A date with no time, such as '2026-08-04', is that day everywhere.** It is formatted in UTC unless 'time-zone' says otherwise, as Date Input and Date Picker format their dates, so a reader west of UTC sees August 4 and not August 3. */
+  /** Formats a date with 'Intl' where it is shown, so you do not write the same 'Intl' call and options in your own code.  **'elapsed' shows compact relative time for a feed**, such as "42m", "3h", or "1d". After six days it shows a date. In en-US, 'Intl.NumberFormat' narrow renders both 'minute' and 'month' as 'm', so a compact "3m" could mean three minutes or three months. 'elapsedTime' in 'helix/core' does the measurement.  **'relative' shows the same reading in words**, such as "3 hours ago" at 'long', "3 hr. ago" at 'short' and "3h ago" at 'narrow', the styles 'sl-relative-time' offers. 'numeric="always"' says "1 day ago" where the default says "yesterday".  **'date-style' and 'time-style' take each locale's own pattern**, such as "Tuesday, August 4, 2026" at 'full', and stand in for the separate fields, which 'Intl' refuses beside them. 'hour-cycle' sets a twelve or twenty-four hour clock either way.  **The text refreshes on one timer shared by the page.** Each element schedules an update for when its current reading expires, and an element showing a date schedules none, so a long feed left open costs almost nothing. 'frozen' draws the reading once and leaves it.  **'fields' draws each field of a date as a part of its own**, such as 'day', 'month' and 'year', so a stylesheet can set the year in a lighter ink or the weekday in capitals with '::part()'. The text between the fields is the locale's own and has no part. An 'elapsed' or 'relative' reading is one phrase, with no parts inside it.  **The output is always '<time datetime>'**, so copy and paste and scripts parsing the page get the exact instant, whatever the visible text says. A screen reader reads the text, so an 'elapsed' reading is named in full, such as "3 hours ago", and carries the whole date as its title.  **A date with no time, such as '2026-08-04', is that day everywhere.** It is formatted in UTC unless 'time-zone' says otherwise, as Date Input and Date Picker format their dates, so a reader west of UTC sees August 4 and not August 3.  **A date is written in a calendar Date Picker draws**: the locale's own where its months are the Gregorian months, as 'th-TH' writes 2569 for 2026, and 'gregory' where they are not, as for 'fa-IR'. 'calendar' picks one of the five. */
   "helix-headless-format-date": DefineCustomElement<
     HelixHeadlessFormatDate,
     HelixHeadlessFormatDateVueProps,
@@ -16039,7 +16951,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessIconVueProps,
     HelixHeadlessIconVueEvents
   >;
-  /** Image handles the part CSS cannot: when the picture has loaded, or that it failed. 'aspect-ratio' in your stylesheet reserves the box. The element tracks three states and relays the two events that move between them, and leaves the box to the stylesheet.  The 'placeholder' slot is empty by default, so the headless tier does not depend on 'Skeleton', which it does not ship.  The placeholder is hidden from screen readers, the picture having a name of its own. The fallback is read once the picture fails, after the picture's 'alt', so a reader hears that it did not load, as a sighted reader sees. */
+  /** Image handles the part CSS cannot: when the picture has loaded, or that it failed. 'aspect-ratio' in your stylesheet reserves the box. The element tracks three states and relays the two events that move between them, and leaves the box to the stylesheet.  The 'placeholder' slot is empty by default, so the headless tier does not depend on 'Skeleton', which it does not ship.  The placeholder is hidden from screen readers, the picture having a name of its own. The fallback is read once the picture fails, after the picture's 'alt', so a reader hears that it did not load, as a sighted reader sees.  **An image with no 'alt' says so.** At its first render it reports a 'missing-alt' warning, printed in the console and counted by '@fusion.dev/helix-diagnostics', which names the fix: describe the picture in 'alt', or write 'alt=""' for one that is decoration. An image hidden with 'aria-hidden="true"' needs neither and is not reported.  A sheet of yours reads the state as ':state(loading)', ':state(loaded)', ':state(error)', and ':state(waiting)', the last while 'placeholder-delay' holds the placeholder back. It can also read 'data-status' on the host once the picture has loaded or failed. */
   "helix-headless-image": DefineCustomElement<
     HelixHeadlessImage,
     HelixHeadlessImageVueProps,
@@ -16081,19 +16993,19 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessLineChartVueProps,
     HelixHeadlessLineChartVueEvents
   >;
-  /** Provides layout and semantics. The row is a target only when you set 'href'.  **'href' makes the row a link.** The component wraps the leading content, the label, and the description in an '<a part="link">' inside the row, as 'Tree.Item' does. An anchor of your own cannot wrap slots it does not own. With the anchor, the row is a target, Enter follows it, middle click opens a new tab, the status bar shows the destination, and all of it works before JavaScript runs.  **The 'end' slot sits beside the link, outside it**, so a button or a menu there is a control of its own: a click on it does not follow the link, and its name is not part of the link's.  Client-side routing needs your own handling. A router cannot render its anchor inside the shadow root, so to navigate without a page load, intercept the click: the anchor is in 'composedPath()'. Handle only a plain primary click, so native gestures keep working.  **For a row that holds controls and is not a destination, use 'data-list-item'.** With 'href' unset, the row is not a link.  'current' marks the row a reader is on, such as the page in a list of pages, with 'aria-current' on its link, or on the row where it has none.  **In a list with 'selection-mode', the row is a row of a grid.** The list gives it its role, its place in the one tab stop and, where the list selects, whether it is selected. Its link leaves the tab order there, and Enter follows it from the row. */
+  /** Provides layout and semantics. The row is a target only when you set 'href'.  **'href' makes the row a link.** The component wraps the leading content, the label, and the description in an '<a part="link">' inside the row, as 'Tree.Item' does. An anchor of your own cannot wrap slots it does not own. With the anchor, the row is a target, Enter follows it, middle click opens a new tab, the status bar shows the destination, and all of it works before JavaScript runs.  **The 'end' slot sits beside the link, outside it**, so a button or a menu there is a control of its own: a click on it does not follow the link, and its name is not part of the link's.  Client-side routing needs your own handling. A router cannot render its anchor inside the shadow root, so to navigate without a page load, intercept the click: the anchor is in 'composedPath()'. Handle only a plain primary click, so native gestures keep working.  **For a row that holds controls and is not a destination, use 'data-list-item'.** With 'href' unset, the row is not a link.  'current' marks the row a reader is on, such as the page in a list of pages, with 'aria-current' on its link, or on the row where it has none.  **In a list with 'selection-mode', the row is a row of a grid.** The list gives it its role, its place in the one tab stop and, where the list selects, whether it is selected. Its link leaves the tab order there, and Enter follows it from the row.  **In a 'reorderable' list, the row has a grip** after its 'end' slot, named by the list's 'move-label'. The list says which row is moving and where the drop indicator is, with the 'dragging', 'drop-before', and 'drop-after' states. */
   "helix-headless-list-item": DefineCustomElement<
     HelixHeadlessListItem,
     HelixHeadlessListItemVueProps,
     HelixHeadlessListItemVueEvents
   >;
-  /** Sets 'role="list"' on the host, so a screen reader counts the rows and announces each one's position, such as "1 of 7".  **'selection-mode' makes the list interactive**, in the way of a grid list: a grid of rows that is one tab stop. 'single' selects one row at a time and 'multiple' any number, and 'value' holds the selected rows' values, separated by commas. A change asks with 'helix-before-change' and tells with 'change'. 'none' selects nothing, so a press acts on the row. A 'disabled' row is passed over. Each row is named by its label and described by its description, so the words of the controls in 'end' are not read as part of its name.  'selection-behavior' says what a press does to the rows already selected. 'toggle', the default, adds or takes out the row. 'replace' selects the row alone, as a file list does, and the arrow keys carry the selection with them. Control or Command with a press then adds or takes out one row.  | Key | What it does | |---|---| | Down, Up | Moves to the next or the previous row. Under 'replace', selects it. | | Home, End | Moves to the first or the last row. Under 'replace', selects it. | | Page Down, Page Up | Moves a box's height of rows, so the row at one edge lands at the other. Under 'replace', selects the row it lands on. | | A letter or a word | Moves to the next row whose words start with what you typed. | | Left, Right | Moves between the row and the controls in its 'end' slot. | | Space | Selects the row, or lets it go. | | Shift with Down, Up, Home, End, Page Down, Page Up or Space | Selects every row from the last one pressed, in 'multiple'. | | Control or Command with Down, Up, Home, End, Page Down or Page Up | Moves without selecting, under 'replace'. | | Control or Command with A | Selects every row, in 'multiple'. | | Escape | Lets go of every selected row, asking first, and keeps the key from the dialog or menu around the list. With nothing selected, the key goes on to them. | | Enter | Acts on the row: follows its link, or sends 'helix-action' from it. |  A press with Shift selects every row from the last one pressed, and a press with Control or Command adds or takes out one row under 'replace'.  **Leave 'selection-mode' unset for a list a reader reads**, and set it for one a reader chooses from or acts on. The rows of an interactive list are grid rows, which hold controls as a list box option cannot. Give a control in 'end' 'tabindex="-1"' to leave it to the arrow keys and out of the tab order.  'start' and 'reversed' number an ordered list as '<ol>' does. The list writes where the numbers start and which way they run as '--list-first' and '--list-step' on its slot, which the styled tier counts from. Reversed with no 'start' counts down from the number of rows, which a server cannot know, so served markup counts from one until the list runs. */
+  /** Sets 'role="list"' on the host, so a screen reader counts the rows and announces each one's position, such as "1 of 7".  **'selection-mode' makes the list interactive**, in the way of a grid list: a grid of rows that is one tab stop. 'single' selects one row at a time and 'multiple' any number, and 'value' holds the selected rows' values, separated by commas. A change asks with 'helix-before-change' and tells with 'change'. 'none' selects nothing, so a press acts on the row. A 'disabled' row is passed over. Each row is named by its label and described by its description, so the words of the controls in 'end' are not read as part of its name.  'selection-behavior' says what a press does to the rows already selected. 'toggle', the default, adds or takes out the row. 'replace' selects the row alone, as a file list does, and the arrow keys carry the selection with them. Control or Command with a press then adds or takes out one row.  | Key | What it does | |---|---| | Down, Up | Moves to the next or the previous row. Under 'replace', selects it. | | Home, End | Moves to the first or the last row. Under 'replace', selects it. | | Page Down, Page Up | Moves a box's height of rows, so the row at one edge lands at the other. Under 'replace', selects the row it lands on. | | A letter or a word | Moves to the next row whose words start with what you typed. | | Left, Right | Moves between the row and the controls in its 'end' slot. | | Space | Selects the row, or lets it go. | | Shift with Down, Up, Home, End, Page Down, Page Up or Space | Selects every row from the last one pressed, in 'multiple'. | | Control or Command with Down, Up, Home, End, Page Down or Page Up | Moves without selecting, under 'replace'. | | Control or Command with A | Selects every row, in 'multiple'. | | Escape | Lets go of every selected row, asking first, and keeps the key from the dialog or menu around the list. With nothing selected, the key goes on to them. | | Enter | Acts on the row: follows its link, or sends 'helix-action' from it. |  A press with Shift selects every row from the last one pressed, and a press with Control or Command adds or takes out one row under 'replace'.  **Leave 'selection-mode' unset for a list a reader reads**, and set it for one a reader chooses from or acts on. The rows of an interactive list are grid rows, which hold controls as a list box option cannot. Give a control in 'end' 'tabindex="-1"' to leave it to the arrow keys and out of the tab order.  **'reorderable' lets you move rows.** Each row gets a grip after its 'end' slot, named by 'move-label'. Drag a grip to move its row, and the list scrolls near an edge. Or press a grip with Space, Enter, or a click to pick up its row, move it with the arrow keys, and press the grip again to drop it. A click on another row drops it there, and Escape puts it back. The list says each step in its 'live' region. A drop sends 'helix-before-reorder', which you can refuse, and then 'helix-reorder', whose 'keys' hold every row's value in the new order. **You move the rows**: the list moves no element of yours, so your framework keeps the order it rendered.  | Key, on a held row's grip | What it does | |---|---| | Down, Up | Moves the row one place. | | Home, End | Moves the row to the top or the bottom. | | Space, Enter | Drops the row. | | Escape | Puts the row back where it was. |  'start' and 'reversed' number an ordered list as '<ol>' does. The list writes where the numbers start and which way they run as '--list-first' and '--list-step' on its slot, which the styled tier counts from. Reversed with no 'start' counts down from the number of rows, which a server cannot know, so served markup counts from one until the list runs. */
   "helix-headless-list": DefineCustomElement<
     HelixHeadlessList,
     HelixHeadlessListVueProps,
     HelixHeadlessListVueEvents
   >;
-  /** The listbox is the control, and options are its items. A Select is a listbox with a trigger in front of it, a Combobox is a listbox with a text input, and a command palette is a listbox in a dialog. They differ only in what opens the list and what filters it.  With 'multiple' set, 'value' is a comma-separated string, like 'Checkbox.Group''s, because 'MixinControllerValue' holds a string. The form receives one entry per selected option, as a native '<select multiple>' sends it, so your server does not split on commas.  Selected and active are separate. The selected option is the value. The active option is where the keyboard is: the arrow keys move it, and 'aria-activedescendant' points to it while focus stays on the list.  The arrow keys, Home, End, PageUp and PageDown move the highlight, and typed letters move it to the next option whose words start with them. In a single-choice list the highlight is the choice unless 'manual' is set; then Enter, Space or a click chooses. With 'multiple', Space toggles the highlighted option, Shift with an arrow adds the option it moves to, Shift with Home or End adds every option from the highlight to that end, and Control+A or Command+A chooses every option, or none where all are chosen. In a filter field, Space, Home, End and letters edit the text, and with 'multiple', Control with Shift and Home or End adds every option from the highlight to that end.  An option with 'href' is a link: Enter or a press follows it and selects nothing, and moving onto it with the arrows does not follow it.  As a filter narrows the list, a screen reader hears how many options are left, such as "3 results", from 'result-label' and 'results-label'. A filter that leaves none says 'empty-text'. */
+  /** The listbox is the control, and options are its items. A Select is a listbox with a trigger in front of it, a Combobox is a listbox with a text input, and a command palette is a listbox in a dialog. They differ only in what opens the list and what filters it.  With 'multiple' set, 'value' is a comma-separated string, like 'Checkbox.Group''s, because 'MixinControllerValue' holds a string. The form receives one entry per selected option, as a native '<select multiple>' sends it, so your server does not split on commas.  Selected and active are separate. The selected option is the value. The active option is where the keyboard is: the arrow keys move it, and 'aria-activedescendant' points to it while focus stays on the list.  **Keyboard.** The list is one tab stop, or its filter field is where there is one. In a single-choice list the highlight is the choice unless 'manual' is set; then Enter, Space or a click chooses.  | Key | What it does | |---|---| | Down, Up | Moves the highlight to the next or the previous option, round from the last to the first. With 'layout="grid"', to the option below or above, stopping at the edge. | | Right, Left | With 'layout="grid"', moves to the next or the previous option, mirrored right to left. In a filter field, moves the caret. | | Home, End | Moves to the first or the last option. In a filter field, moves the caret. | | Page Down, Page Up | Moves by as many options as the list shows at once. | | A letter or a word | Moves to the next option whose words start with what you typed. In a filter field, types it. | | Enter | Chooses the highlighted option, or follows it where it is a link. | | Space | Chooses the highlighted option, or with 'multiple' toggles it. In a filter field, types a space. | | Shift with Down or Up | With 'multiple', adds the option the highlight moves to. In a filter field, moves the highlight and leaves the value. | | Shift with Space | With 'multiple', adds every option from the one last chosen to the highlighted one. In a filter field, types a space. | | Shift with Home or End | With 'multiple', adds every option from the highlight to that end. In a filter field, hold Control as well. | | Control or Command with A | With 'multiple', chooses every option, or none where all are chosen. In a filter field, selects the text. | | Escape | In a filter field, clears the filter. | | Alt with Up or Down | In a 'reorderable' list, moves the highlighted option a place. Alt with Home or End moves it to either end. |  **ARIA.** The 'items' part is the 'listbox', named by the label and described by the hint and the message, with 'aria-multiselectable' under 'multiple', 'aria-required', 'aria-invalid', and 'aria-busy' while loading. Each option is an 'option' with 'aria-selected'. The list, or its filter field, points 'aria-activedescendant' at the highlighted option; the field is 'aria-autocomplete="list"' and controls the list.  An option with 'href' is a link: Enter or a press follows it and selects nothing, and moving onto it with the arrows does not follow it.  As a filter narrows the list, a screen reader hears how many options are left, such as "3 results", from 'result-label' and 'results-label'. A filter that leaves none says 'empty-text'.  **Moving options** is a separate import, '@fusion.dev/helix/listbox/reorder', so a list that never moves options carries none of its code. With it imported, 'reorderable' lets a reader move options:  - Alt with Up or Down moves the highlighted option a place, and Alt with   Home or End moves it to either end, as the APG's rearrangeable listbox   does. The highlight stays on it. - A pointer drags an option, with a drop indicator, and the list scrolls near   an edge. A press that does not travel still chooses the option. - A drop sends 'helix-before-reorder', which you can refuse, and then   'helix-reorder', whose 'keys' hold every value in the new order. **You   move the options**, or set 'items' in the new order: the list moves no   element of yours. - The list says each move in its 'live' region. The words are the   'moved-label', 'canceled-label', 'dropped-label', and 'picked-up-label'   attributes, which the import reads. - An option in a group moves within its group. Options do not move while a   filter narrows the list, under 'layout="grid"', or while the list is   disabled. */
   "helix-headless-listbox": DefineCustomElement<
     HelixHeadlessListbox,
     HelixHeadlessListboxVueProps,
@@ -16129,7 +17041,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessMapLandcoverVueProps,
     HelixHeadlessMapLandcoverVueEvents
   >;
-  /** A button placed at a latitude and longitude. 'connectMap' positions it on the map and moves it as the map moves. Its name shows beside it on hover and focus.  Pressing a marker sends 'helix-activate' from the frame with the marker's 'name', or its 'label' if it has no name.  All the markers in a map share one tab stop. The arrow keys move between them in the order they are written. */
+  /** A button placed at a latitude and longitude. 'connectMap' positions it on the map and moves it as the map moves. Its name shows beside it on hover and focus.  Pressing a marker sends 'helix-activate' from the frame with the marker's 'name', or its 'label' if it has no name.  All the markers in a map share one tab stop. The arrow keys move between them in the order they are written. Taking away the marker that has focus moves focus to the next one, or to the one before where it was the last. */
   "helix-headless-map-marker": DefineCustomElement<
     HelixHeadlessMapMarker,
     HelixHeadlessMapMarkerVueProps,
@@ -16183,7 +17095,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessMenuItemVueProps,
     HelixHeadlessMenuItemVueEvents
   >;
-  /** The trigger is slotted and stays your own element, as with the tooltip. The menu renders its surface in the top layer with the popover API, so an ancestor with 'overflow: hidden' does not clip it and it needs no 'z-index'.  Slot a 'helix-button' or 'helix-icon-button' as the trigger, and the menu tells it that it opens a menu and whether the menu is open. A plain '<button>' can only be told by writing attributes onto your markup, which the menu does not do, so give it 'aria-haspopup="menu"' and set its 'aria-expanded' from the 'toggle' event.  Submenus drill down. A submenu replaces the panel's content, and a back row returns to the previous page. One panel avoids the diagonal pointer path that side-by-side panels need, stays inside a narrow window, and works on touch screens, which have no hover.  The root holds which page is open, because only one page shows at a time. It sets this on items as a property, never as an attribute. An attribute written onto your element after it upgrades causes a hydration mismatch.  Group rows under a heading with 'Menu.Section', which is a 'group' named by its heading. Between runs of rows, a '<helix-divider announced>' is a separator a screen reader announces.  Keys: Enter, Space or Down Arrow on the trigger opens the menu on its first row, and Up Arrow on its last. In the menu, Up and Down Arrow move between rows, Home and End go to the first and the last, a typed letter moves to the next row whose name starts with it, Enter and Space choose, Right Arrow opens a row's submenu and Left Arrow goes back, the two swapping on a right-to-left page, and Escape closes the menu and returns focus to the trigger. Tab closes it and moves on.  While it is open, the surface carries the trigger's width as '--floating-anchor-inline-size' and the room left below it as '--floating-available-block-size', as Radix's dropdown menu publishes its trigger's width, for a menu as wide as its trigger: 'helix-menu::part(surface) { min-inline-size: var(--floating-anchor-inline-size) }'.  With 'context', the trigger is an area and the menu is its context menu: a right-click, a long press, Shift+F10 or the menu key over the area opens it at the pointer, or at the area's corner from the keyboard, as Radix's context menu does. A press on the area does not open it, and closing it returns focus to where it was. */
+  /** The trigger is slotted and stays your own element, as with the tooltip. The menu renders its surface in the top layer with the popover API, so an ancestor with 'overflow: hidden' does not clip it and it needs no 'z-index'.  Slot a 'helix-button' or 'helix-icon-button' as the trigger, and the menu tells it that it opens a menu and whether the menu is open. A plain '<button>' can only be told by writing attributes onto your markup, which the menu does not do, so give it 'aria-haspopup="menu"' and set its 'aria-expanded' from the 'toggle' event.  Submenus drill down. A submenu replaces the panel's content, and a back row returns to the previous page. One panel avoids the diagonal pointer path that side-by-side panels need, stays inside a narrow window, and works on touch screens, which have no hover.  The root holds which page is open, because only one page shows at a time. It sets this on items as a property, never as an attribute. An attribute written onto your element after it upgrades causes a hydration mismatch.  Group rows under a heading with 'Menu.Section', which is a 'group' named by its heading. Between runs of rows, a '<helix-divider>' is a separator a screen reader announces.  Keys: Enter, Space or Down Arrow on the trigger opens the menu on its first row, and Up Arrow on its last. In the menu, Up and Down Arrow move between rows, Home and End go to the first and the last, a typed letter moves to the next row whose name starts with it, Enter and Space choose, Right Arrow opens a row's submenu and Left Arrow goes back, the two swapping on a right-to-left page, and Escape closes the menu and returns focus to the trigger. Tab closes it and moves on.  While it is open, the surface carries the trigger's width as '--floating-anchor-inline-size' and the room left below it as '--floating-available-block-size', as Radix's dropdown menu publishes its trigger's width, for a menu as wide as its trigger: 'helix-menu::part(surface) { min-inline-size: var(--floating-anchor-inline-size) }'.  With 'context', the trigger is an area and the menu is its context menu: a right-click, a long press, Shift+F10 or the menu key over the area opens it at the pointer, or at the area's corner from the keyboard, as Radix's context menu does. A press on the area does not open it, and closing it returns focus to where it was. */
   "helix-headless-menu": DefineCustomElement<
     HelixHeadlessMenu,
     HelixHeadlessMenuVueProps,
@@ -16219,7 +17131,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessNotificationVueProps,
     HelixHeadlessNotificationVueEvents
   >;
-  /** Notifications are slotted children. Each one is your own markup, with an avatar, a link, or a button in it. Feeds usually hold tens of items, so writing them out lets an item hold anything.  The list does not virtualize. Windowing needs the list to own the data, and here you own it, so N notifications are N elements. For a feed of thousands, use a data table with a custom cell.  Read state is reported to you. Marking read goes from the root to the item and from the item to you, so a canceled 'helix-read' changes nothing, and if you own 'read', nothing changes until you set it. 'unread' is derived from the items and written to an attribute, so a stylesheet and a badge can both use it without counting.  **The feed is one 'Tab' stop for its rows.** Each row takes focus itself and is read by its label. 'ArrowDown' and 'ArrowUp' move to the next and the previous row, 'Home' and 'End' to the first and the last, and 'PageDown' and 'PageUp' move a row on or back from anywhere inside one, as in the APG feed pattern. The controls inside a row stay in the 'Tab' order. Set 'total' when the feed holds one page of a longer list, and each row says its place in the whole of it.  **'load-more' adds a button after the list** that sends 'helix-load-more', for a feed that holds one page of a longer list. Append the next page, set 'loading' while it is on its way, and take 'load-more' off once there is nothing more. While the feed is loading the button stays, so focus stays on it, and it is 'aria-disabled' and sends nothing. */
+  /** Notifications are slotted children. Each one is your own markup, with an avatar, a link, or a button in it. Feeds usually hold tens of items, so writing them out lets an item hold anything.  The list does not virtualize. Windowing needs the list to own the data, and here you own it, so N notifications are N elements. For a feed of thousands, use a data table with a custom cell.  Read state is reported to you. Marking read goes from the root to the item and from the item to you, so a canceled 'helix-read' changes nothing, and if you own 'read', nothing changes until you set it. 'unread' is derived from the items and written to an attribute, so a stylesheet and a badge can both use it without counting.  **The feed is one 'Tab' stop for its rows.** Each row takes focus itself and is read by its label. 'ArrowDown' and 'ArrowUp' move to the next and the previous row, 'Home' and 'End' to the first and the last, and 'PageDown' and 'PageUp' move a row on or back from anywhere inside one, as in the APG feed pattern. The controls inside a row stay in the 'Tab' order. Set 'total' when the feed holds one page of a longer list, and each row says its place in the whole of it.  **'load-more' adds a button after the list** that sends 'helix-load-more', for a feed that holds one page of a longer list. Append the next page, set 'loading' while it is on its way, and take 'load-more' off once there is nothing more. While the feed is loading the button stays, so focus stays on it, and it is 'aria-disabled' and sends nothing.  **'load-error' says a page could not be fetched**, such as "Could not load notifications": it shows under the rows there are, in the 'error' part, in place of the empty and loading lines, and a screen reader hears it. Clear it when you ask again. */
   "helix-headless-notifications": DefineCustomElement<
     HelixHeadlessNotifications,
     HelixHeadlessNotificationsVueProps,
@@ -16231,7 +17143,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessNumberInputVueProps,
     HelixHeadlessNumberInputVueEvents
   >;
-  /** Object Inspector shows a structured value, such as an API response, a config, or a raw record, as a read-only tree with each entry's type visible.  Pass the object to 'value', or name a '<script type="application/json">' by id with 'for', the same source 'VirtualList' and the charts read. JSON text works with server rendering and with React hydration, which skips object properties. 'value' wins when both are set.  **Keyboard.** The tree is one tab stop, and focus moves from row to row.  | Key | What it does | |---|---| | Down, Up | Moves to the next or the previous row. | | Right | Opens a closed branch, or moves into an open one. Left on a right-to-left page. | | Left | Closes an open branch, or moves to the parent. Right on a right-to-left page. | | Home, End | Moves to the first or the last row. | | Page Down, Page Up | Moves a box's height of rows, so the row at one edge lands at the other. | | Enter, Space | Opens or closes a branch. | | '*' | Opens every branch beside the active row. | | A letter or a word | Moves to the next row whose key starts with what you typed. | | Command+C, Control+C | Copies the active row, where no text is selected. |  The tree is a 'treegrid', as React Aria's Tree is: each entry is a 'row' with one cell, and carries its real level, position, and set size, including in a windowed tree. Nothing in it is chosen, so no row carries 'aria-selected', and a focused row is not announced as selected.  A reader opening or closing a branch sends 'helix-before-open' or 'helix-before-close', which you can cancel, and then 'toggle' with 'newState' and 'oldState', as '<details>' does. The branch is the active row, and 'expanded' holds every open branch. '*' asks once for all the branches it opens. A script writing 'expanded' or 'active' sends nothing.  'active' is the active row's path, written the way a JSON Pointer writes it: the empty string for the root and '/meta/tags/0' for an entry under it. Moving to another row sends 'helix-before-activate', which you can cancel, and then 'helix-activate', both with the path. Writing 'active' moves there and opens the branches around it, and sends nothing. 'expanded' holds the open branches by path, and writing it opens those and closes the rest. A row that closes around the active one hands it to the nearest open branch.  'filter' narrows the tree to the entries whose key or value holds the text, ignoring case, and the branches that lead to them, which it opens. A matched branch keeps everything under it. Each matched row carries 'row-match', and a screen reader hears how many entries matched from 'result-label' and 'results-label'. 'filterable' adds a field that sets it: typing sends 'helix-filter', which you can cancel, and then 'helix-filtered', and Down moves from the field to the tree.  A new 'value' keeps the branches a reader opened or closed, and the active row, where the new value still has them. A branch the old value did not have opens to 'default-depth'.  The copy button copies the active row, a branch as JSON and a string as its text. So do Command+C and Control+C while the tree has focus and no text is selected. The button sits beside the tree, because assistive technology cannot reliably reach a button inside a tree item.  'windowed' draws only the rows in view, for values with thousands of entries. The box needs a height for windowing to work. The styled tier sets one, and in the headless tier you set it yourself. */
+  /** Object Inspector shows a structured value, such as an API response, a config, or a raw record, as a read-only tree with each entry's type visible.  Pass the object to 'value', or name a '<script type="application/json">' by id with 'for', the same source 'VirtualList' and the charts read. JSON text works with server rendering and with React hydration, which skips object properties. 'value' wins when both are set.  **Keyboard.** The tree is one tab stop, and focus moves from row to row.  | Key | What it does | |---|---| | Down, Up | Moves to the next or the previous row. | | Right | Opens a closed branch, or moves into an open one. Left on a right-to-left page. | | Left | Closes an open branch, or moves to the parent. Right on a right-to-left page. | | Home, End | Moves to the first or the last row. | | Page Down, Page Up | Moves a box's height of rows, so the row at one edge lands at the other. | | Enter, Space | Opens or closes a branch. | | '*' | Opens every branch beside the active row. | | A letter or a word | Moves to the next row whose key starts with what you typed. | | Command+C, Control+C | Copies the active row, where no text is selected. |  The tree is a 'treegrid', as React Aria's Tree is: each entry is a 'row' with one cell, and carries its real level, position, and set size, including in a windowed tree. Nothing in it is chosen, so no row carries 'aria-selected', and a focused row is not announced as selected.  A reader opening or closing a branch sends 'helix-before-open' or 'helix-before-close', which you can cancel, and then 'toggle' with 'newState' and 'oldState', as '<details>' does. The branch is the active row, and 'expanded' holds every open branch. '*' asks once for all the branches it opens. A script writing 'expanded' or 'active' sends nothing.  'active' is the active row's path, written the way a JSON Pointer writes it: the empty string for the root and '/meta/tags/0' for an entry under it. Moving to another row sends 'helix-before-activate', which you can cancel, and then 'helix-activate', both with the path. Writing 'active' moves there and opens the branches around it, and sends nothing. 'expanded' holds the open branches by path, and writing it opens those and closes the rest. A row that closes around the active one hands it to the nearest open branch.  'filter' narrows the tree to the entries whose key or value holds the text, ignoring case, and the branches that lead to them, which it opens. A matched branch keeps everything under it. Each matched row carries 'row-match', and a screen reader hears how many entries matched from 'results-label'. 'filterable' adds a field that sets it: typing sends 'helix-filter', which you can cancel, and then 'helix-filtered', and Down moves from the field to the tree.  A new 'value' keeps the branches a reader opened or closed, and the active row, where the new value still has them. A branch the old value did not have opens to 'default-depth'.  The copy button copies the active row, a branch as JSON and a string as its text. So do Command+C and Control+C while the tree has focus and no text is selected. The button sits beside the tree, because assistive technology cannot reliably reach a button inside a tree item.  'windowed' draws only the rows in view, for values with thousands of entries. The box needs a height for windowing to work. The styled tier sets one, and in the headless tier you set it yourself. */
   "helix-headless-object-inspector": DefineCustomElement<
     HelixHeadlessObjectInspector,
     HelixHeadlessObjectInspectorVueProps,
@@ -16297,7 +17209,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessProgressVueProps,
     HelixHeadlessProgressVueEvents
   >;
-  /** The code is drawn as one '<path>'. Runs of adjacent dark modules are joined, so a row of eight is one horizontal move. A code of useful length has about a thousand modules, and an element for each would be a thousand nodes for one image.  The element has 'role="img"' and an accessible name. Set 'label' to what the code is for, such as "Open the menu". With no 'label', a code is named by 'code-label', "QR code", followed by its value where the value is a web address, which a URL read aloud makes a destination. Any other value is never read out: a code that sets up an authenticator or joins a network carries a secret in it.  The quiet zone of four modules is required by the specification, and a scanner rejects a code cropped to its edge. It is drawn inside the 'viewBox', so it stays at any size, including a size set in CSS.  'correction' sets how much of the code can be lost. At 'H' a code can lose thirty percent and still scan, so a mark in the center slot is safe. At 'L' the same mark makes the code unscannable. The default is 'M', and 'H' when the 'logo' slot is filled.  A higher level holds fewer characters, so a value that fits at 'M' can be too long once a logo raises the level to 'H'. A value too long for the level draws no code: the element fires 'error', carries ':state(overflow)', and shows what is in the 'fallback' slot, such as the link written out.  'toSvg()', 'toPng()' and 'download()' give the drawn code as a file of its own, in the colors it is drawn in, with a slotted image or SVG logo where it sits, for a page that offers it to save or print, as Zag's download trigger does. */
+  /** The code is drawn as one '<path>'. Runs of adjacent dark modules are joined, so a row of eight is one horizontal move. A code of useful length has about a thousand modules, and an element for each would be a thousand nodes for one image.  The element has 'role="img"' and an accessible name. Set 'label' to what the code is for, such as "Open the menu". With no 'label', a code is named by 'code-label', "QR code", followed by its value where the value is a web address, which a URL read aloud makes a destination. Any other value is never read out: a code that sets up an authenticator or joins a network carries a secret in it.  The quiet zone of four modules is required by the specification, and a scanner rejects a code cropped to its edge. It is drawn inside the 'viewBox', so it stays at any size, including a size set in CSS.  'correction' sets how much of the code can be lost. At 'H' a code can lose thirty percent and still scan, so a mark in the center slot is safe. At 'L' the same mark makes the code unscannable. The default is 'M', and 'H' when the 'logo' slot is filled. A code that holds a logo at a 'correction' below 'H' warns once with the kind 'unscannable-logo'.  A higher level holds fewer characters, so a value that fits at 'M' can be too long once a logo raises the level to 'H'. A value too long for the level draws no code: the element fires 'error', carries ':state(overflow)', and shows what is in the 'fallback' slot, such as the link written out.  'toSvg()', 'toPng()' and 'download()' give the drawn code as a file of its own, in the colors it is drawn in, with a slotted image or SVG logo where it sits, for a page that offers it to save or print, as Zag's download trigger does. 'download()' saves an SVG for a name ending in '.svg', and a PNG for any other. */
   "helix-headless-qr-code": DefineCustomElement<
     HelixHeadlessQrCode,
     HelixHeadlessQrCodeVueProps,
@@ -16339,7 +17251,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessScrollAreaVueProps,
     HelixHeadlessScrollAreaVueEvents
   >;
-  /** A trigger that opens a 'Listbox'. The list is the same element you can use on its own, with the same keyboard behavior, filtering, and multi-select rules. Select adds a trigger that shows what is chosen, a floating surface, and a place for focus to return to when the list closes.  Your options stay in your light DOM and are slotted through into the listbox, so the listbox looks through slots to find them.  'Select' owns the value, passes it down to the listbox, and takes changes back, so the value lives in one place.  Set 'valueContent' to draw the trigger's content from the chosen options, and several chosen options are written as a list in the reader's language.  In the open list the arrow keys, Home, End, PageUp, PageDown and typed letters move the highlight, and Enter, Space or a click chooses it and closes the list. Tab closes the list and moves on. On the closed trigger, ArrowDown, Enter and Space open the list on the chosen option, ArrowUp opens it on the chosen or last option, Home and End open it on the first or last, and typed letters choose the option whose words start with them, as a native '<select>' does. */
+  /** A trigger that opens a 'Listbox'. The list is the same element you can use on its own, with the same keyboard behavior, filtering, and multi-select rules. Select adds a trigger that shows what is chosen, a floating surface, and a place for focus to return to when the list closes.  Your options stay in your light DOM and are slotted through into the listbox, so the listbox looks through slots to find them.  'Select' owns the value, passes it down to the listbox, and takes changes back, so the value lives in one place.  Set 'valueContent' to draw the trigger's content from the chosen options, and several chosen options are written as a list in the reader's language.  **Keyboard.** On the closed trigger:  | Key | What it does | |---|---| | Down, Enter, Space | Opens the list on the chosen option, or the first. | | Up | Opens the list on the chosen option, or the last. | | Home, End | Opens the list on the first or the last option. | | Left, Right | Chooses the option before or after the chosen one without opening, as React Aria's Select does, in either direction of text. | | A letter or a word | Chooses the option whose words start with what you typed, as a native '<select>' does. With 'multiple', opens the list on it. |  In the open list, which is a 'Listbox':  | Key | What it does | |---|---| | Down, Up, Home, End, Page Down, Page Up | Moves the highlight. | | A letter or a word | Moves the highlight to the next option whose words start with what you typed. | | Enter, Space | Chooses the highlighted option and closes the list. With 'multiple', toggles it and leaves the list open. | | Escape | Closes the list and puts focus back on the trigger. | | Tab | Closes the list and moves on. |  A choice made on the closed trigger is said aloud on Apple devices, where VoiceOver does not read the trigger's new name.  **ARIA.** The trigger is a 'button' with 'aria-haspopup="listbox"' and 'aria-expanded', named by the label and then the chosen words, as a native '<select>' is. The list is the listbox 'Listbox' describes, named by the label, or by 'list-label' where there is none.  Set 'autocomplete' to let a browser's autofill choose, as a native '<select>' with the same attribute would. */
   "helix-headless-select": DefineCustomElement<
     HelixHeadlessSelect,
     HelixHeadlessSelectVueProps,
@@ -16369,19 +17281,25 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessSparklineVueProps,
     HelixHeadlessSparklineVueEvents
   >;
-  /** Each item is a command, so it has the 'menuitem' role. A megamenu holds destinations, so it is a disclosure of links. A speed dial holds actions, which is what 'role="menu"' is for.  The name is text rendered beside the icon, and it is the accessible name. A 'title' on an icon shows only on hover. Visible text is read, searched, and translated like other text. */
+  /** A 'group' of the dial's menu, named by its label, as React Aria's menu sections and Menu's groups are: a reader hears the name on entering the set, and the arrow keys walk through every group's actions in order, from the last action of one group to the first of the next.  Put actions straight into the group, and the group straight into the dial. Anything else slotted here is drawn and is not an action. */
+  "helix-headless-speed-dial-group": DefineCustomElement<
+    HelixHeadlessSpeedDialGroup,
+    HelixHeadlessSpeedDialGroupVueProps,
+    HelixHeadlessSpeedDialGroupVueEvents
+  >;
+  /** Each item is a command, so it has the 'menuitem' role. A megamenu holds destinations, so it is a disclosure of links. A speed dial holds actions, which is what 'role="menu"' is for.  The name is text rendered beside the icon, and it is the accessible name. A 'title' on an icon shows only on hover. Visible text is read, searched, and translated like other text.  'shortcut' gives the action's keyboard shortcut as a chord, such as 'mod+s', the grammar Menu's rows use. The action carries it as 'aria-keyshortcuts' and draws it after the name in the platform's glyphs or words, '⌘S' on an Apple keyboard and 'Ctrl+S' elsewhere, as Menu draws its rows' shortcuts. Put a 'Kbd' in the 'shortcut' slot to draw it as keys instead; the dial imports no 'Kbd' of its own. Showing a shortcut does not bind it. */
   "helix-headless-speed-dial-item": DefineCustomElement<
     HelixHeadlessSpeedDialItem,
     HelixHeadlessSpeedDialItemVueProps,
     HelixHeadlessSpeedDialItemVueEvents
   >;
-  /** A speed dial is a menu. Its items are commands, so it uses 'role="menu"' and 'menuitem', and it is built from the same pieces as 'Menu': - 'KeyboardNavigationController' for the arrow keys - 'PopoverController' for the panel - 'MixinControllerOpen' for open and closed  It is a separate component because a speed dial has no submenus, headers, or checkable items.  You slot the trigger. The usual floating action button is 'IconButton' with 'shape="circle"' and 'raised'. There is no 'helix-fab', because 'IconButton' already has 'emphasis', 'tone', 'label', and a size. Position the button with 'data-dock' in the base layer.  All four arrow keys move through the actions, because a speed dial has no nested levels to reserve the horizontal pair for. This is the default behavior of the keyboard controller. Typing a letter moves to the next action whose name starts with it. The actions are one tab stop, and Tab closes the dial and moves on. */
+  /** A speed dial is a menu. Its items are commands, so it uses 'role="menu"' and 'menuitem', and it is built from the same pieces as 'Menu': - 'KeyboardNavigationController' for the arrow keys - 'PopoverController' for the panel - 'MixinControllerOpen' for open and closed  It is a separate component because a speed dial has no submenus, headers, or checkable items.  You slot the trigger. The usual floating action button is 'IconButton' with 'shape="circle"' and 'raised'. There is no 'helix-fab', because 'IconButton' already has 'emphasis', 'tone', 'label', and a size. Position the button with 'data-dock' in the base layer.  All four arrow keys move through the actions, because a speed dial has no nested levels to reserve the horizontal pair for. This is the default behavior of the keyboard controller. Typing a letter moves to the next action whose name starts with it. The actions are one tab stop, and Tab closes the dial and moves on.  **Keyboard.** On the trigger, Enter, Space or a press opens the dial on its first action. With the dial open:  | Key | What it does | |---|---| | Down, Right | Moves to the next action, from the last back to the first. | | Up, Left | Moves to the action before, from the first round to the last. | | Home, End | Moves to the first or the last action. | | A letter | Moves to the next action whose name starts with it. | | Enter, Space | Chooses the action, and the dial closes. | | Escape | Closes the dial and puts focus back on the trigger. | | Tab | Closes the dial and moves on. |  **Groups.** Put actions in 'Speed Dial.Group', named by its 'label', to set them apart as Menu's sections do: each is a 'group' of the menu, and the arrow keys walk through every group's actions in order.  **A trigger with its own action.** With 'open-on="long-press"', a press on the trigger is the trigger's own, such as composing a message, and holding it for half a second opens the dial, as React Aria's menu trigger does with 'trigger="longPress"'. Alt+Down or Alt+Up opens it from the keyboard, and the trigger says so in its description, 'long-press-label', the drawn one and a slotted one alike. A press that has opened the dial does not also do the trigger's action. */
   "helix-headless-speed-dial": DefineCustomElement<
     HelixHeadlessSpeedDial,
     HelixHeadlessSpeedDialVueProps,
     HelixHeadlessSpeedDialVueEvents
   >;
-  /** A splitter has one axis. Nest splitters to get two axes and three-pane or four-pane layouts.  When a splitter is slotted into a pane of another at a right angle, a corner handle appears where the dividers cross. It shows the 'move' cursor, responds to both arrow axes, and a drag moves both dividers at once. The corner is added at 'firstUpdated' and is not in the server markup. Before it appears, both dividers work on their own.  The divider has 'role="separator"' and 'aria-valuenow', and 'aria-controls' names the start pane. Drag it with a pointer or move it with the arrow keys, press 'Home' or 'End' to move it to its bounds, and press 'Enter' to collapse the start pane and open it again. A drag in progress is tracked as a state, so both dividers a corner moves stay lit for as long as they move.  By default, 'min' and 'max' let the divider reach either edge, so you can drag a pane fully closed. Set them to limit the range.  A pane can be collapsed, which is a separate state from a divider at the edge. 'collapsed' names the shut pane, 'start' or 'end', and the pane opens back to the position where the collapsing gesture began. A drag records that position on press, and every other way of collapsing records it in 'settle'. 'collapsed-size' keeps a sliver of the pane visible, such as a tab strip. Collapsing overrides 'min' and 'max'. */
+  /** A splitter has one axis. Nest splitters to get two axes and three-pane or four-pane layouts.  When a splitter is slotted into a pane of another at a right angle, a corner handle appears where the dividers cross. It shows the 'move' cursor, responds to both arrow axes, and a drag moves both dividers at once. The corner is added at 'firstUpdated' and is not in the server markup. Before it appears, both dividers work on their own.  The divider has 'role="separator"' and 'aria-valuenow', with 'aria-valuetext' saying the start pane's share as a percentage in the nearest 'lang', or in the reader's locale where no 'lang' is set, and 'aria-controls' names the start pane. Drag it with a pointer or move it with the arrow keys, press 'Home' or 'End' to move it to its bounds, and press 'Enter' to collapse the start pane and open it again. A drag in progress is tracked as a state, so both dividers a corner moves stay lit for as long as they move.  By default, 'min' and 'max' let the divider reach either edge, so you can drag a pane fully closed. Set them to limit the range.  A pane can be collapsed, which is a separate state from a divider at the edge. 'collapsed' names the shut pane, 'start' or 'end', and the pane opens back to the position where the collapsing gesture began. A drag records that position on press, and every other way of collapsing records it in 'settle'. 'collapsed-size' keeps a sliver of the pane visible, such as a tab strip. Collapsing overrides 'min' and 'max'. */
   "helix-headless-splitter": DefineCustomElement<
     HelixHeadlessSplitter,
     HelixHeadlessSplitterVueProps,
@@ -16417,7 +17335,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessSwitchVueProps,
     HelixHeadlessSwitchVueEvents
   >;
-  /** Sets its own role, because a grid of elements has no table structure for assistive technology otherwise. 'header' makes the cell a header, so a screen reader announces it with the values it heads:  - In a row that holds a cell without 'header', it is a 'rowheader' and names   its row, for example "web-app" in a row of a service's values. - In a row of 'header' cells alone, it is a 'columnheader', which is what a   table with no 'TableColumn' heads its columns with.  The role is on the host so the cell stays a child of its row in the flat tree, which keeps the table structure intact. */
+  /** Sets its own role, because a grid of elements has no table structure for assistive technology otherwise. 'header' makes the cell a header, so a screen reader announces it with the values it heads:  - In a row that holds a cell without 'header', it is a 'rowheader' and names   its row, for example "web-app" in a row of a service's values. - In a row of 'header' cells alone, it is a 'columnheader', which is what a   table with no 'TableColumn' heads its columns with.  The role is on the host so the cell stays a child of its row in the flat tree, which keeps the table structure intact. In a 'grid' table a value is a 'gridcell', and the table gives the cell a 'tabindex' so focus can rest on it. */
   "helix-headless-table-cell": DefineCustomElement<
     HelixHeadlessTableCell,
     HelixHeadlessTableCellVueProps,
@@ -16429,13 +17347,13 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessTableColumnVueProps,
     HelixHeadlessTableColumnVueEvents
   >;
-  /** Lays out the rows on a CSS grid, so every column lines up across rows and each row stays a real element that can be styled, hidden, or made interactive. A '<table>' layout aligns columns but limits almost everything else.  A grid of elements has no table structure for assistive technology, so the roles are set explicitly: 'table', 'row', 'cell', 'columnheader', and 'rowheader' for a 'header' cell in a row of values. Rows are 'display: contents', so their cells become items of the one grid.  **Sorting.** A column with 'sortable' and a 'field' draws its heading as a button that sorts the rows by the text of its cells, numbers by their value. Your markup is not reordered: the table draws the rows in the sorted order.  1. Each press cycles the column through ascending, descending, and the    order the rows were written in, which keeps a server's own ranking    reachable. 2. 'helix-sort' asks first, with 'field:direction', or empty for the written    order. Refuse it to keep the order, or to sort the rows yourself and set    'sort'. 3. 'helix-sorted' follows once the order stands, and 'sort' holds it. 4. The heading carries 'aria-sort', and a screen reader hears 'sorted-label'    ("Sorted by Name, ascending") or 'unsorted-label' from a polite region.  Tab reaches each sort button, and Enter or Space presses it.  The 'heading' slot names the table: slot a heading or a line of text into it, and the table is named by its words. An 'aria-label' or 'aria-labelledby' on the host wins over it.  **Selecting.** 'selectable' adds a column of checkboxes.  1. Each row is known by its 'value', or by its place among the rows where it    has none, and 'selected' holds the chosen keys, comma separated, the same    shape 'DataTable' uses. 'default-selected' is where it starts. 2. A row's checkbox is named by 'select-row-label' ("Select {row}") with the    words of the row's first cell. The checkbox in the heading selects every    row, and shows a dash while only some are chosen. 3. 'helix-select' asks first, with every key the change would leave.    Refuse it to keep the selection. 'helix-selected' follows once it stands. 4. A chosen row takes ':state(selected)', and a screen reader hears    'selected-label' ("2 selected") from a polite region.  Tab reaches each checkbox, and Space ticks it. For a grid a reader moves through with the arrow keys, with typeahead and range selection, use 'DataTable'. To act on one row, put a link or a button in a cell.  The CSS custom properties listed for this component are written by it and read by the stylesheet that draws it. Do not set them. Each holds a number the component computes and CSS cannot, so the stylesheet can draw the table without measuring anything. */
+  /** Lays out the rows on a CSS grid, so every column lines up across rows and each row stays a real element that can be styled, hidden, or made interactive. A '<table>' layout aligns columns but limits almost everything else.  A grid of elements has no table structure for assistive technology, so the roles are set explicitly: 'table', 'row', 'cell', 'columnheader', and 'rowheader' for a 'header' cell in a row of values. Rows are 'display: contents', so their cells become items of the one grid.  **Sorting.** A column with 'sortable' and a 'field' draws its heading as a button that sorts the rows by the text of its cells, numbers by their value. Your markup is not reordered: the table draws the rows in the sorted order.  1. Each press cycles the column through ascending, descending, and the    order the rows were written in, which keeps a server's own ranking    reachable. 2. 'helix-sort' asks first, with 'field:direction', or empty for the written    order. Refuse it to keep the order, or to sort the rows yourself and set    'sort'. 3. 'helix-sorted' follows once the order stands, and 'sort' holds it. 4. The heading carries 'aria-sort', and a screen reader hears 'sorted-label'    ("Sorted by Name, ascending") or 'unsorted-label' from a polite region.  Tab reaches each sort button, and Enter or Space presses it.  The 'heading' slot names the table: slot a heading or a line of text into it, and the table is named by its words. An 'aria-label' or 'aria-labelledby' on the host wins over it.  **Selecting.** 'selectable' adds a column of checkboxes.  1. Each row is known by its 'value', or by its place among the rows where it    has none, and 'selected' holds the chosen keys, comma separated, the same    shape 'DataTable' uses. 'default-selected' is where it starts. 2. A row's checkbox is named by 'select-row-label' ("Select {row}") with the    words of the row's first cell. The checkbox in the heading selects every    row, and shows a dash while only some are chosen. 3. 'helix-select' asks first, with every key the change would leave.    Refuse it to keep the selection. 'helix-selected' follows once it stands. 4. A chosen row takes ':state(selected)', and a screen reader hears    'selected-label' ("2 selected") from a polite region.  Tab reaches each checkbox, and Space ticks it. To act on one row, put a link or a button in a cell, or give the row an 'href'.  **Moving rows.** 'reorderable' adds a column of grips before the checkboxes, under a heading named by 'row-grips-label'.  1. Each row is known by its 'value', or by its place among the rows where it    has none, as for selecting. Give rows a 'value' when they move, so a key    stays with its row. 2. A grip is a button named by 'move-row-label' ("Move {row}") with the    words of the row's first cell. Drag it to move its row, and the page    scrolls near an edge. Or press it with Space, Enter, or a click to pick    the row up, move it with Up, Down, Home, and End, and press it again to    drop it. A click on another row drops it there, and Escape puts it back. 3. 'helix-before-reorder' asks first, and 'helix-reorder' follows with    'keys', every row's key in the new order. **You move the rows**: the    table moves no element of yours, and focus goes back to the moved row's    grip once you have. 4. Each step is said in the table's live region, in words you can change:    'picked-up-label', 'moved-label', 'dropped-label', and 'canceled-label'.    The grips do nothing while a sort is set.  **A grid.** 'grid' makes the table one tab stop that the arrow keys move through cell by cell, the headings included, as React Aria's table is. The table is then a 'grid' and each value a 'gridcell', and the table gives every cell a 'tabindex' so focus can rest on it: set 'grid' only where the cells may carry one. For typeahead and range selection, use 'DataTable'.  | Key | What it does | |---|---| | Right, Left | Moves one cell along the row. Left moves on, on a right-to-left page. | | Down, Up | Moves one row, the headings included. | | Home, End | Moves to the first or the last cell of the row. | | Control with Home or End | Moves to the first or the last cell of the table. | | Page Down, Page Up | Moves by the rows that fit in view. | | 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. | | Enter on a cell of a row with 'href' | Follows the row's link. | | Enter, Space on a sortable heading | Sorts by the column. | | Space on a row, Enter or Space on its checkbox cell | Selects the row, in a 'selectable' table. | | 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. | | Control or Command with A | Selects every row, in a 'selectable' table. | | Tab | Leaves the table. |  The CSS custom properties listed for this component are written by it and read by the stylesheet that draws it. Do not set them. Each holds a number the component computes and CSS cannot, so the stylesheet can draw the table without measuring anything. */
   "helix-headless-table": DefineCustomElement<
     HelixHeadlessTable,
     HelixHeadlessTableVueProps,
     HelixHeadlessTableVueEvents
   >;
-  /** The row renders its cells straight through and lays out none of them, so a stylesheet can place them in the table's grid and every column lines up across rows. The row still exists as an element, so you can style it, hide it, or make it interactive.  In a 'selectable' table the row draws a checkbox cell before its own cells, and 'value' is the key the table's 'selected' lists it by.  **'href' makes the whole row a link**, as a row action does in React Aria's table: a press anywhere on the row follows it, except on a link or a control of the row's own, and Control, Command or Shift open it the way they open a link. A drag that selects text follows nothing. A row in a table is not a stop of its own, so put the same link in a cell, usually the row header, which is what the keyboard and a screen reader reach. */
+  /** The row renders its cells straight through and lays out none of them, so a stylesheet can place them in the table's grid and every column lines up across rows. The row still exists as an element, so you can style it, hide it, or make it interactive.  In a 'selectable' table the row draws a checkbox cell before its own cells, and 'value' is the key the table's 'selected' lists it by.  In a 'reorderable' table the row draws a grip cell before those, holding a button named by the table's 'move-row-label', and 'value' is the key 'helix-reorder' lists it by. The table says which row is moving and where the drop indicator is, with the 'dragging', 'drop-before', and 'drop-after' states.  **'href' makes the whole row a link**, as a row action does in React Aria's table: a press anywhere on the row follows it, except on a link or a control of the row's own, and Control, Command or Shift open it the way they open a link. A drag that selects text follows nothing. A row in a table is not a stop of its own, so put the same link in a cell, usually the row header, which is what the keyboard and a screen reader reach. In a 'grid' table, Enter on any cell of the row follows it as well. */
   "helix-headless-table-row": DefineCustomElement<
     HelixHeadlessTableRow,
     HelixHeadlessTableRowVueProps,
@@ -16507,7 +17425,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessTimelineVueProps,
     HelixHeadlessTimelineVueEvents
   >;
-  /** Each message is an element because it has a timeout, a tone, a dismiss control, and a lifetime that pauses.  **Each item runs its own timer.** A timer held by the region would restart with each new message, and the last of three messages would stay for nine seconds.  **Each message is an 'alertdialog' named by its words**, which is how a reader who moves into the stack hears which message they are on. Give it a 'heading' and a 'description', and the heading names it and the description describes it, for a message with a title and a line of detail. The region says each message once as it arrives, a 'danger' one assertively, so a message is never a live region of its own.  A touch or a pen swipes a message toward the end of the line, and past halfway, or quickly, dismisses it through the same 'helix-dismiss' as its control. While it moves, the distance is on the 'item' part as '--toast-swipe-x'.  **Messages are inverted by default.** The item flips 'color-scheme', so a new message stands out from the page without using a color that carries meaning. */
+  /** Each message is an element because it has a timeout, a tone, a dismiss control, and a lifetime that pauses.  **Each item runs its own timer.** A timer held by the region would restart with each new message, and the last of three messages would stay for nine seconds. It pauses while the pointer or focus is on the message, and while the page is hidden, so a message is not spent in a background tab.  **Each message is an 'alertdialog' named by its words**, which is how a reader who moves into the stack hears which message they are on. Give it a 'heading' and a 'description', and the heading names it and the description describes it, for a message with a title and a line of detail. The region says each message once as it arrives, a 'danger' one assertively, so a message is never a live region of its own.  A touch or a pen swipes a message toward the end of the line, and past halfway, or quickly, dismisses it through the same 'helix-dismiss' as its control. While it moves, the distance is on the 'item' part as '--toast-swipe-x'.  **Messages are inverted by default.** The item flips 'color-scheme', so a new message stands out from the page without using a color that carries meaning. */
   "helix-headless-toast-item": DefineCustomElement<
     HelixHeadlessToastItem,
     HelixHeadlessToastItemVueProps,
@@ -16531,13 +17449,13 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessToggleVueProps,
     HelixHeadlessToggleVueEvents
   >;
-  /** A toolbar holds a mix of controls, such as buttons, toggles, and menus. A button group holds one kind, so the two are separate components.  The toolbar is one tab stop, and the arrow keys move between its controls, so three toolbars take three presses of Tab to pass. Any element the browser can focus counts as a control, including your own elements. A child that takes no focus, such as a divider, is skipped. A menu is reached at its trigger.  Controls inside a plain wrapper, such as a 'Button Group', are each a stop of the toolbar's own, as React Aria's toolbar flattens a group: the arrows walk through the group's buttons and on past it, and the group takes no tab stop of its own.  The arrows wrap from the last control to the first. Set 'stop-at-ends' to keep them at the ends, as Radix's 'loop' set to false does.  A toggle group of pressed buttons, 'selection-mode="multiple"', is walked through the same way, each toggle a stop on the toolbar's axis, as React Aria's toolbar walks its toggle buttons. Another nested composite, such as a radio-style toggle group, is one stop on the toolbar's axis: the toolbar's arrows move past it, and the arrows across the toolbar move inside it. A composite with a 'focusable' property, as Toggle Group has, gives up its own tab stop while the toolbar's is elsewhere, so Tab stops once in the toolbar. A composite without one keeps its own tab stop.  A toolbar inside another toolbar, a Helix one or the page's own 'role="toolbar"', is a 'group' of the outer one, as React Aria's is: the outer toolbar's arrows walk through its controls and on past them, and it takes no keys and no tab stop of its own. A server renders it as a toolbar, having no parent to read, until it upgrades. */
+  /** A toolbar holds a mix of controls, such as buttons, toggles, and menus. A button group holds one kind, so the two are separate components.  The toolbar is one tab stop, and the arrow keys move between its controls, so three toolbars take three presses of Tab to pass. Any element the browser can focus counts as a control, including your own elements. A child that takes no focus, such as a divider, is skipped. A menu is reached at its trigger.  A Divider in the toolbar is a separator across the toolbar's axis, as React Aria's is: vertical in a horizontal toolbar and horizontal in a vertical one, without an 'orientation' of its own.  Controls inside a plain wrapper, such as a 'Button Group', are each a stop of the toolbar's own, as React Aria's toolbar flattens a group: the arrows walk through the group's buttons and on past it, and the group takes no tab stop of its own.  The arrows wrap from the last control to the first. Set 'stop-at-ends' to keep them at the ends, as Radix's 'loop' set to false does.  **Keyboard.** Tab enters the toolbar on the control that last had focus, the first control at the start, and the next Tab leaves it.  | Key | What it does | |---|---| | Right | Moves to the next control in a horizontal toolbar, from the last back to the first. | | Left | Moves to the control before in a horizontal toolbar, from the first round to the last. | | Down, Up | The same in a vertical toolbar. | | Home, End | Moves to the first or the last control. |  Left and Right swap on a right-to-left page, where the first control is on the right. The arrows across the toolbar's axis are left to the control that has focus, so a radio-style toggle group or a select answers them itself. The toolbar is 'role="toolbar"' with 'aria-orientation', named by 'label'.  The stop moves through a control's own 'focusable' property where it has one, as Button, Select and Toggle Group do. A control without one has 'tabindex' written on the element that takes focus: a native element itself, or the control inside a custom element's open shadow root, so the host keeps the markup you rendered. Only a custom element whose shadow root is closed takes it on the host.  A toggle group of pressed buttons, 'selection-mode="multiple"', is walked through the same way, each toggle a stop on the toolbar's axis, as React Aria's toolbar walks its toggle buttons. Another nested composite, such as a radio-style toggle group, is one stop on the toolbar's axis: the toolbar's arrows move past it, and the arrows across the toolbar move inside it. A composite with a 'focusable' property, as Toggle Group has, gives up its own tab stop while the toolbar's is elsewhere, so Tab stops once in the toolbar. A composite without one keeps its own tab stop.  A toolbar inside another toolbar, a Helix one or the page's own 'role="toolbar"', is a 'group' of the outer one, as React Aria's is: the outer toolbar's arrows walk through its controls and on past them, and it takes no keys and no tab stop of its own. A server renders it as a toolbar, having no parent to read, until it upgrades. */
   "helix-headless-toolbar": DefineCustomElement<
     HelixHeadlessToolbar,
     HelixHeadlessToolbarVueProps,
     HelixHeadlessToolbarVueEvents
   >;
-  /** The trigger is slotted and stays your own element. The bubble renders in the top layer through the popover API, so an ancestor with 'overflow: hidden' does not clip it and no 'z-index' is needed. 'FloatingController' positions it and flips it to another side when the preferred side does not fit.  **The tooltip describes its trigger itself, in both forms.** Wrap the trigger, or place the tooltip beside it and name the trigger with 'for':  '''html <helix-headless-button id="save">Save</helix-headless-button> <helix-headless-tooltip for="save" content="Save your work"></helix-headless-tooltip> '''  The link is an element reference on the control that takes focus, and it is never written into your markup before a reader has acted. A trigger that is a Helix component is described at once, inside its own shadow root. A plain element in your markup is described when a reader first points at it or focuses it, which is after any hydration, and only where you have written no 'aria-describedby' or 'aria-labelledby' of your own. Write 'aria-describedby' pointing at the tooltip yourself to have the link in the server's markup. Where the browser has no element references, write it yourself; the tooltip warns once on first open if nothing links the two. In the 'for' form the tooltip itself is out of the accessibility tree while its bubble is down, so a reader walking the page meets its words once, as the trigger's description.  The tooltip shows on hover and on focus. It hides on pointer leave, on blur, on Escape, and when the trigger is activated. The pointer can move from the trigger onto the bubble and the bubble stays, unless you set 'hoverable="false"'. 'delay' is how long the pointer rests before it shows, and 'delay-out' how long it stays once the pointer leaves.  Once one tooltip is showing, moving to another trigger shows its tooltip with no 'delay', and the first one hides. The same holds for 'skip-delay' milliseconds after a tooltip hides, 300 unless you set it. 'show-on="focus"' shows the tooltip on keyboard focus only, for a hint a pointer does not need. */
+  /** The trigger stays your own element. The bubble renders in the top layer through the popover API, so an ancestor with 'overflow: hidden' does not clip it and no 'z-index' is needed. 'FloatingController' positions it and flips it to another side when the preferred side does not fit.  **Place the tooltip beside its trigger, name the trigger with 'for', and name the tooltip in the trigger's 'aria-describedby'.** The description is then in your own markup, so it is in the server's HTML and in the accessibility tree at rest, in every browser, before anyone points at the trigger or focuses it:  '''html <helix-headless-button aria-describedby="save-tip" id="save">Save</helix-headless-button> <helix-headless-tooltip content="Save your work" for="save" id="save-tip"></helix-headless-tooltip> '''  Without the attribute, the tooltip links itself through an element reference on the control that takes focus, and it never writes into your markup before you act, so hydration stays intact. A trigger that is a Helix component is described at once, inside its own shadow root. A plain element in your markup is described when you first point at it or focus it, so a screen reader in reading mode meets it with no description until then. Where the browser has no element references, nothing links the two, and the tooltip warns once on first open. The tooltip can also wrap its trigger, which describes a Helix component and leaves a plain element undescribed. In the 'for' form the tooltip itself is out of the accessibility tree while its bubble is down, so you meet its words once, as the trigger's description.  The tooltip shows on hover and on focus. It hides on pointer leave, on blur, on Escape, and when the trigger is activated. The pointer can move from the trigger onto the bubble and the bubble stays, unless you set 'hoverable="false"'. 'delay' is how long the pointer rests before it shows, and 'delay-out' how long it stays once the pointer leaves.  Once one tooltip is showing, moving to another trigger shows its tooltip with no 'delay', and the first one hides. The same holds for 'skip-delay' milliseconds after a tooltip hides, 300 unless you set it. 'show-on="focus"' shows the tooltip on keyboard focus only, for a hint a pointer does not need. */
   "helix-headless-tooltip": DefineCustomElement<
     HelixHeadlessTooltip,
     HelixHeadlessTooltipVueProps,
@@ -16555,13 +17473,13 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessTourStopVueProps,
     HelixHeadlessTourStopVueEvents
   >;
-  /** 'open' comes from 'MixinControllerOpen', the same state a disclosure holds, so you can respond to a branch opening and control the state yourself. The row renders 'aria-expanded'.  Each item is an element because it holds state: whether it is open, selected, and focused.  An item is a branch when something is slotted into 'children'. This is detected on the client, so server-rendered markup shows a leaf and the twisty appears on hydration.  **'href' makes the whole row a link**, rendered as an '<a>'. Enter, middle click, and the status bar then work anywhere on the row.  Pressing a branch, or Enter or Space on it, opens or closes it. A branch with a 'value' is chosen as well and sends 'helix-select', unless the tree has 'nesting="heading"', where a branch names the list under it, or 'selection-mode="leaf"', where only the items at the ends are chosen.  A 'disabled' item is reached by the arrow keys and announced as unavailable, and a press, Enter or Space on it does nothing.  A 'lazy' item is a branch whose children you load when it opens: opening it sends 'helix-load', the row says it is busy, and the children you add appear in it. Remove 'lazy' once they are in. */
+  /** 'open' comes from 'MixinControllerOpen', the same state a disclosure holds, so you can respond to a branch opening and control the state yourself. The row renders 'aria-expanded'.  Each item is an element because it holds state: whether it is open, selected, and focused.  An item is a branch when something is slotted into 'children'. This is detected on the client, so server-rendered markup shows a leaf and the twisty appears on hydration.  **'href' makes the whole row a link**, rendered as an '<a>'. Enter, middle click, and the status bar then work anywhere on the row.  Pressing a branch, or Enter or Space on it, opens or closes it. A branch with a 'value' is chosen as well and sends 'helix-select', unless the tree has 'nesting="heading"', where a branch names the list under it, or 'selection-mode="leaf"', where only the items at the ends are chosen.  A 'disabled' item is reached by the arrow keys and announced as unavailable, and a press, Enter or Space on it does nothing.  A 'lazy' item is a branch whose children you load when it opens: opening it sends 'helix-load', the row says it is busy, and the children you add appear in it. Remove 'lazy' once they are in.  **In a 'reorderable' tree, the row has a grip** at its far end, which a pointer drags to move the item among its siblings. The tree says which item is moving and where the drop indicator is, with the 'dragging', 'drop-before', and 'drop-after' states. */
   "helix-headless-tree-item": DefineCustomElement<
     HelixHeadlessTreeItem,
     HelixHeadlessTreeItemVueProps,
     HelixHeadlessTreeItemVueEvents
   >;
-  /** The tree is a single tab stop, and arrow keys move focus between items, as the tree pattern requires, so Tab moves past a long sidebar in one press. The tree moves the tab stop to the focused item, so the browser's focus order stays intact.  Items are found with 'instanceof', never by tag name, so the headless tier does not depend on the styled one.  Typing a letter moves to the next visible item whose name starts with it, and '*' opens every branch beside the focused item.  'selection-mode="multiple"' draws a check mark on every row and lets a reader check many, as Web Awesome's and Ark UI's checkbox trees do. Checking a branch checks every item under it, and a branch some of whose items are checked is partly checked. Space or a press on the mark checks the focused row, and Enter or a press on a branch's row opens it. 'active' then holds the checked values, comma separated, which 'values' also gives as a list, and the tree says 'aria-multiselectable'.  'selection-mode="leaf"' chooses one item at a time and only the items at the ends: a press, Enter or Space on a branch opens or closes it and chooses nothing, as Web Awesome's 'leaf' mode does.  Keys: Up and Down Arrow move between the items a reader can see; Right Arrow opens a shut branch and then moves into it, and Left Arrow shuts an open one and then moves to its parent, the two swapping on a right-to-left page. Home and End go to the first and the last item, Enter and Space choose or open, and the tree's one tab stop stays on the item last reached. In a tree of check marks, Control+A (Command+A on an Apple keyboard) checks every item or clears them all, and Shift with Up or Down Arrow moves and checks. */
+  /** The tree is a single tab stop, and arrow keys move focus between items, as the tree pattern requires, so Tab moves past a long sidebar in one press. The tree moves the tab stop to the focused item, so the browser's focus order stays intact.  Items are found with 'instanceof', never by tag name, so the headless tier does not depend on the styled one.  Typing a letter moves to the next visible item whose name starts with it, and '*' opens every branch beside the focused item.  'selection-mode="multiple"' draws a check mark on every row and lets a reader check many, as Web Awesome's and Ark UI's checkbox trees do. Checking a branch checks every item under it, and a branch some of whose items are checked is partly checked. Space or a press on the mark checks the focused row, and Enter or a press on a branch's row opens it. 'active' then holds the checked values, comma separated, which 'values' also gives as a list, and the tree says 'aria-multiselectable'.  'selection-mode="leaf"' chooses one item at a time and only the items at the ends: a press, Enter or Space on a branch opens or closes it and chooses nothing, as Web Awesome's 'leaf' mode does.  Keys: Up and Down Arrow move between the items a reader can see; Right Arrow opens a shut branch and then moves into it, and Left Arrow shuts an open one and then moves to its parent, the two swapping on a right-to-left page. Home and End go to the first and the last item, Enter and Space choose or open, and the tree's one tab stop stays on the item last reached. In a tree of check marks, Control+A (Command+A on an Apple keyboard) checks every item or clears them all, and Shift with Up or Down Arrow moves and checks.  **'reorderable' lets you move items among their siblings.** Alt with Up or Down moves the focused item a place, and Alt with Home or End to the first or the last place among its siblings, as the APG's rearrangeable listbox does. Each row gets a grip at its far end: drag it to move the item, and the tree scrolls near an edge. A click on a grip picks the item up and a click on one of its siblings drops it there, which needs no drag. The arrows move an item picked up that way, Enter or Space drops it, and Escape puts it back. The tree says each step in its 'live' region. A drop sends 'helix-before-reorder', which you can refuse, and then 'helix-reorder', whose 'keys' hold the siblings in the new order. **You move the items**: the tree moves no element of yours, and focus follows the moved item once you have. Moving an item into another branch is not part of this. */
   "helix-headless-tree": DefineCustomElement<
     HelixHeadlessTree,
     HelixHeadlessTreeVueProps,
@@ -16597,7 +17515,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessVideoVueProps,
     HelixHeadlessVideoVueEvents
   >;
-  /** The items arrive as data, in one of two ways:  - 'items' takes an array. A framework sets it as a property, and React   hydration keeps it. - 'for' names a '<script type="application/json">' that holds an array, which   a server sends as markup.  Each item is drawn into a row in one of two ways:  - 'renderItem' is a function from an item and its index to the row's   content: a Lit template, a string, or a DOM node. - A '<template>' child defines one row. 'data-field="name"' fills an element   with the item's 'name' as text, and 'data-field-href="url"' writes the   item's 'url' into 'href', the same for any attribute. A field may be a path   of keys, such as 'author.name'.  Rows are your markup in the light DOM, so your stylesheet styles them.  **A grid.** 'columns' lays the items out that many to a line, as a grid of equal columns, and windows the set a line at a time, as React Aria's grid layout does. Each item draws one element, a cell of the grid, and 'estimate' is the height of a line. Space the items with padding inside each one, which the list measures with the line.  **Keyboard.** The list is one tab stop.  | Key | What it does | |---|---| | 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. | | 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. | | Home, End | Moves to the first or the last item. | | Page Down, Page Up | Moves by the number of items, or of lines in a grid, on screen. | | A letter or a word | Moves to the next item whose text starts with what you typed. | | Tab | Moves into the focused row's own links and buttons, then out of the list. |  An item that is not drawn is scrolled into view and focused, so a keyboard reaches the whole set. When the row holding the tab stop scrolls away, the stop moves to the first row on screen. Typing matches each item's 'text-field', which is the first 'data-field' of the row template by default, or the item itself when it is a string or a number.  Each row says its place in the whole set with 'aria-posinset' and 'aria-setsize', so a screen reader says "4,000 of 10,000". The row holding focus stays drawn when it scrolls out.  **Selecting.** 'selection-mode' makes the list a list box a reader chooses from: 'single' selects one item and 'multiple' any number. Space or a press selects an item, Shift with Space, an arrow, Home, End or a press takes in the items from the last one chosen, and Control or Command with A selects them all, in 'multiple'. 'value' holds the chosen items' keys, separated by commas, in the order of the set: 'key-field' names each item's key, and a string or a number item is its own key. A change asks with 'helix-before-change' and tells with 'change'. Each row is an 'option' marked 'aria-selected', so a row's own links and buttons are not reached there: keep those to a list without 'selection-mode'.  **Loading more.** 'helix-range-change' fires as the items on screen change, and 'range' holds them. 'helix-load-more' fires once a reader is within one screen of the end, once for each length of the set: add to 'items' and it can fire again. While you fetch, set 'loading': the list is busy, and a row after the last item says "Loading more" ('loading-label', or your own content in the 'loading' slot). 'scrollToIndex' takes a reader to an item.  **Row height.** Rows are placed by 'estimate' until they are drawn. Then the list reads the drawn rows' height once and places every row by it, so a wrong estimate still reaches the last item. Set 'measured' for rows of different heights.  The list follows its source. A new 'items' array, an edit to the script's text, or a script replaced under the same id draws the new rows. A row that stays in view keeps its element as the list scrolls.  The viewport scrolls on this tier. It carries 'data-scroller', and 'core' ships '[data-scroller] { overflow: auto }' into every shadow root, so 'scrollTop' works with no stylesheet. You still need to set a block size. */
+  /** The items arrive as data, in one of two ways:  - 'items' takes an array. A framework sets it as a property, and React   hydration keeps it. - 'for' names a '<script type="application/json">' that holds an array, which   a server sends as markup.  Each item is drawn into a row in one of two ways:  - 'renderItem' is a function from an item and its index to the row's   content: a Lit template, a string, or a DOM node. - A '<template>' child defines one row. 'data-field="name"' fills an element   with the item's 'name' as text, and 'data-field-href="url"' writes the   item's 'url' into 'href', the same for any attribute. A field may be a path   of keys, such as 'author.name'.  Rows are your markup in the light DOM, so your stylesheet styles them.  **A grid.** 'columns' lays the items out that many to a line, as a grid of equal columns, and windows the set a line at a time, as React Aria's grid layout does. Each item draws one element, a cell of the grid, and 'estimate' is the height of a line. Space the items with padding inside each one, which the list measures with the line.  **Keyboard.** The list is one tab stop.  | Key | What it does | |---|---| | 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. | | 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. | | Home, End | Moves to the first or the last item. | | Page Down, Page Up | Moves by the number of items, or of lines in a grid, on screen. | | A letter or a word | Moves to the next item whose text starts with what you typed. | | Tab | Moves into the focused row's own links and buttons, then out of the list. |  An item that is not drawn is scrolled into view and focused, so a keyboard reaches the whole set. When the row holding the tab stop scrolls away, the stop moves to the first row on screen. Typing matches each item's 'text-field', which is the first 'data-field' of the row template by default, or the item itself when it is a string or a number.  Each row says its place in the whole set with 'aria-posinset' and 'aria-setsize', so a screen reader says "4,000 of 10,000". The row holding focus stays drawn when it scrolls out.  **Selecting.** 'selection-mode' makes the list a list box a reader chooses from: 'single' selects one item and 'multiple' any number. Space or a press selects an item, Shift with Space, an arrow, Home, End or a press takes in the items from the last one chosen, and Control or Command with A selects them all, in 'multiple'. 'value' holds the chosen items' keys, separated by commas, in the order of the set: 'key-field' names each item's key, and a string or a number item is its own key. A change asks with 'helix-before-change' and tells with 'change'. Each row is an 'option' marked 'aria-selected', so a row's own links and buttons are not reached there: keep those to a list without 'selection-mode'.  **Loading more.** 'helix-range-change' fires as the items on screen change, and 'range' holds them. 'helix-load-more' fires once a reader is within one screen of the end, once for each length of the set: add to 'items' and it can fire again. While you fetch, set 'loading': the list is busy, and a row after the last item says "Loading more" ('loading-label', or your own content in the 'loading' slot). 'scrollToIndex' takes a reader to an item.  **Row height.** Rows are placed by 'estimate' until they are drawn. Then the list reads the drawn rows' height once and places every row by it, so a wrong estimate still reaches the last item. Set 'measured' for rows of different heights. Once the list draws rows of different heights, such as rows that wrap on a narrow screen, it places each row by its own height whether 'measured' is set or not.  The list follows its source. A new 'items' array, an edit to the script's text, or a script replaced under the same id draws the new rows. A row that stays in view keeps its element as the list scrolls.  The viewport scrolls on this tier. It carries 'data-scroller', and 'core' ships '[data-scroller] { overflow: auto }' into every shadow root, so 'scrollTop' works with no stylesheet. You still need to set a block size. */
   "helix-headless-virtual-list": DefineCustomElement<
     HelixHeadlessVirtualList,
     HelixHeadlessVirtualListVueProps,