@fusion.dev/helix-headless 0.142.1 → 0.143.0

package/types/vue.d.ts

@@ -165,6 +165,7 @@ import type {
   HelixHeadlessVirtualList,
   HelixBeforeCloseEvent,
   HelixBeforeOpenEvent,
+  ToggleEvent,
   HelixDismissEvent,
   HelixScrolledEvent,
   HelixBeforeMoveEvent,
@@ -180,9 +181,11 @@ import type {
   HelixRelabelEvent,
   HelixRemoveEvent,
   HelixSelectEvent,
+  HelixActivateEvent,
   HelixSendEvent,
   HelixBeforePinEvent,
   HelixHistoryEvent,
+  HelixPinEvent,
   HelixBeforeChangeEvent,
   HelixBeforeToggleEvent,
   HelixCopyEvent,
@@ -190,11 +193,14 @@ import type {
   HelixSampleStartEvent,
   HelixCreateEvent,
   HelixFilterEvent,
+  HelixFilteredEvent,
   HelixNavigateEvent,
   HelixReorderEvent,
+  HelixReorderedEvent,
+  HelixSelectedEvent,
   HelixSortEvent,
+  HelixSortedEvent,
   HelixFacetEvent,
-  HelixActivateEvent,
   HelixBeforeActivateEvent,
   HelixGraphFilterEvent,
   HelixGraphLayoutEvent,
@@ -216,6 +222,8 @@ import type {
   HelixCompleteEvent,
   HelixBeforeCollapseEvent,
   HelixBeforeResizeEvent,
+  HelixCollapseEvent,
+  HelixResizedEvent,
   HelixTourAskEvent,
   HelixNextEvent,
   HelixPreviousEvent,
@@ -270,6 +278,9 @@ export type HelixHeadlessAccordionItemHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixHeadlessAccordionItemHelixBeforeOpenElementEvent =
   HelixHeadlessAccordionItemElementEvent<HelixBeforeOpenEvent>;
+/** `toggle` event type */
+export type HelixHeadlessAccordionItemToggleElementEvent =
+  HelixHeadlessAccordionItemElementEvent<ToggleEvent>;
 
 export type HelixHeadlessAccordionItemVueProps = {
   /** Where the chevron sits, or `none` for no chevron.
@@ -290,6 +301,19 @@ indicator is found once at the edge rather than shifting with the text.
 `none` is for a row that carries its own affordance and would otherwise
 have two. */
   chevronPlacement?: (HelixHeadlessAccordionItem["chevronPlacement"]) | undefined;
+  /** Whether the section is disabled, so its trigger cannot be pressed or
+reached with the arrow keys. A script can still open and close it. */
+  disabled?: (HelixHeadlessAccordionItem["disabled"]) | undefined;
+  /** The level of the heading around the trigger, from 1 to 6.
+
+Unset takes the accordion's `heading-level`, and 3 where that is unset
+too. */
+  "heading-level"?: (HelixHeadlessAccordionItem["headingLevel"] | `${number}`) | undefined;
+  /** The level of the heading around the trigger, from 1 to 6.
+
+Unset takes the accordion's `heading-level`, and 3 where that is unset
+too. */
+  headingLevel?: (HelixHeadlessAccordionItem["headingLevel"]) | undefined;
   /** A group name. Opening an item closes the other items with the same name,
 as `<details name>` does.
 
@@ -334,16 +358,29 @@ export type HelixHeadlessAccordionItemVueEvents = {
   /** The section is about to open. Cancelable: cancel it to keep it closed. */
   "helix-before-open": HelixHeadlessAccordionItemHelixBeforeOpenElementEvent;
   /** The section opened or closed. The event carries `newState` and `oldState`. */
-  toggle: HelixHeadlessAccordionItemElementEvent;
+  toggle: HelixHeadlessAccordionItemToggleElementEvent;
 };
 
 export type HelixHeadlessAccordionVueProps = {
+  /** The level of the heading around each trigger, from 1 to 6.
+
+Unset is 3. An item's own `heading-level` wins over this. */
+  "heading-level"?: (HelixHeadlessAccordion["headingLevel"] | `${number}`) | undefined;
+  /** The level of the heading around each trigger, from 1 to 6.
+
+Unset is 3. An item's own `heading-level` wins over this. */
+  headingLevel?: (HelixHeadlessAccordion["headingLevel"]) | undefined;
   /** How many sections may be open at once.
 
 Absent is `multiple`, so nothing closes unexpectedly and the default costs
 no attribute on the host. `single` keeps exactly one open and refuses to
 close the last; `single-collapsible` keeps at most one and lets it close.
 
+Held however a section opens: a press, `open` set from a script,
+`toggleOpen()`, or `default-open` in the markup. Opening one closes the
+others, and on first render only the first section written open stays
+open. Under `single` the first section opens when none is written open.
+
 A union rather than a mode plus a `collapsible` boolean, which would make
 `collapsible` alongside `multiple` expressible and meaningless. */
   mode?: (HelixHeadlessAccordion["mode"]) | undefined;
@@ -373,9 +410,8 @@ to match `Tag` while differing from it in both directions: it carried
 components saying what a thing means, in three vocabularies, one of which
 described itself as a fourth.
 
-`accent` is the second emphasis, a rotation off the brand seed rather than a
-color of its own, so it stays in relation when somebody rethemes. `primary`
-is the seed itself.
+`accent` is the second emphasis, the second color a theme names, and the
+brand itself until one is named. `primary` is the brand.
 
 **`surface` was never a color and has moved to `separation`**, which is the
 axis that owns where a box sits relative to the page. It said the band rode
@@ -444,6 +480,9 @@ the wordmark and the actions happen to measure.
 takes a search field or a breadcrumb trail as readily as a `Navigation`, so
 the property carries the part's name, `content`. */
   contentAlign?: (HelixHeadlessAppHeader["contentAlign"]) | undefined;
+  /** The id of the element whose scrolling lifts the bar, for an app shell that
+scrolls a container instead of the window. Unset is the window. */
+  scroller?: (HelixHeadlessAppHeader["scroller"]) | undefined;
 };
 
 export type HelixHeadlessAppHeaderVueEvents = {
@@ -500,6 +539,12 @@ shadow root reads a table in that root rather than one in the document. A
 Absent falls back to the table's own caption, which is usually the right
 words and is already written. */
   label?: (HelixHeadlessAreaChart["label"]) | undefined;
+  /** 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. */
+  locale?: (HelixHeadlessAreaChart["locale"]) | undefined;
 };
 
 export type HelixHeadlessAreaChartVueEvents = {};
@@ -524,6 +569,16 @@ 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.
+
+The count shows "+3", which reads as "plus three" and says nothing about
+what was counted. */
+  "overflow-label"?: (HelixHeadlessAvatarGroup["overflowLabel"]) | undefined;
+  /** What a screen reader is told the count is, with `{count}` for the number.
+
+The count shows "+3", which reads as "plus three" and says nothing about
+what was counted. */
+  overflowLabel?: (HelixHeadlessAvatarGroup["overflowLabel"]) | undefined;
 };
 
 export type HelixHeadlessAvatarGroupVueEvents = {};
@@ -544,7 +599,9 @@ Used for the label and the initials. */
 Falls back to the slot, or to initials, if it fails. */
   src?: (HelixHeadlessAvatar["src"]) | undefined;
   /** The image's state: `loading` while it is on its way, `loaded` once it
-arrives, or `error` when it fails and the initials replace it.
+arrives, or `error` when it fails and the initials replace it. An avatar
+with no `src` has no image to wait for, and reports `error` as well, since
+the initials are what it shows.
 
 Read-only to a consumer: it is a report rather than a setting, and the same
 report `Image` gives, for the same reason. `load` and `error` fire once, so
@@ -608,6 +665,10 @@ 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. */
+  "highest-label"?: (HelixHeadlessBarChart["highestLabel"]) | undefined;
+  /** The word the summary puts before each series' highest reading. */
+  highestLabel?: (HelixHeadlessBarChart["highestLabel"]) | undefined;
   /** The names of the series to draw as lines. The other series are drawn as
 columns.
 
@@ -639,8 +700,8 @@ names are words rather than dates: a row of long names either overlaps or
 turns on its side, and neither is as readable as putting them down the left
 where they read normally.
 
-`orientation` and not `orientation`, which `Trend` uses in the same group for
-which way a number moved. */
+Named `orientation` because `direction` is taken: `Trend` uses it in the
+same group for which way a number moved. */
   orientation?: (HelixHeadlessBarChart["orientation"]) | undefined;
   /** The names of the series measured against a second scale of their own.
 
@@ -689,6 +750,12 @@ shadow root reads a table in that root rather than one in the document. A
 Absent falls back to the table's own caption, which is usually the right
 words and is already written. */
   label?: (HelixHeadlessBarChart["label"]) | undefined;
+  /** 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. */
+  locale?: (HelixHeadlessBarChart["locale"]) | undefined;
 };
 
 export type HelixHeadlessBarChartVueEvents = {};
@@ -731,7 +798,11 @@ The consumer's decision. */
 
 export type HelixHeadlessBreadcrumbVueEvents = {};
 
-export type HelixHeadlessBreadcrumbsVueProps = {};
+export type HelixHeadlessBreadcrumbsVueProps = {
+  /** The landmark's name, read by screen readers. An `aria-label` on the host
+wins over it. */
+  label?: (HelixHeadlessBreadcrumbs["label"]) | undefined;
+};
 
 export type HelixHeadlessBreadcrumbsVueEvents = {};
 
@@ -944,6 +1015,16 @@ callout reports a status, or `neutral` for an aside that reports none, and
 never a brand role, so it takes five of the seven values. One word per axis
 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". */
+  "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". */
+  toneLabel?: (HelixHeadlessCallout["toneLabel"]) | undefined;
 };
 
 export type HelixHeadlessCalloutVueEvents = {};
@@ -1521,6 +1602,9 @@ export type HelixHeadlessCarouselElementEvent<E = Event> = TypedEvent<
   HelixHeadlessCarousel,
   E
 >;
+/** `helix-activate` event type */
+export type HelixHeadlessCarouselHelixActivateElementEvent =
+  HelixHeadlessCarouselElementEvent<HelixActivateEvent>;
 /** `helix-select` event type */
 export type HelixHeadlessCarouselHelixSelectElementEvent =
   HelixHeadlessCarouselElementEvent<HelixSelectEvent>;
@@ -1753,6 +1837,8 @@ case is the absent attribute, and the styles read it that way. */
 };
 
 export type HelixHeadlessCarouselVueEvents = {
+  /** Fired after the slide in view changes, with the new index as a string in `detail.value`. */
+  "helix-activate": HelixHeadlessCarouselHelixActivateElementEvent;
   /** Fired before the slide in view changes, with the requested index. Cancelable: cancel it to keep the current slide. Nothing moves, and a drag returns to the slide the index still holds. See `handleScroll`. */
   "helix-select": HelixHeadlessCarouselHelixSelectElementEvent;
 };
@@ -1797,13 +1883,16 @@ has to mean a new line and nothing else. */
   submitOn?: (HelixHeadlessChatComposer["submitOn"]) | undefined;
   /** The text the user has written.
 
-Read it, or set it to seed a draft. */
+It follows typing, so reading it gives the draft. Set it to seed a draft or
+to replace the one in the field, and set it to `''` to clear it. */
   value?: (HelixHeadlessChatComposer["value"]) | undefined;
 };
 
 export type HelixHeadlessChatComposerVueEvents = {
   /** Fired when the user sends their turn, and cancelable. */
   "helix-send": HelixHeadlessChatComposerHelixSendElementEvent;
+  /** The user changed the text. Read it from `value`, for a typing indicator or a saved draft. Sent on the composer and does not bubble. */
+  input: HelixHeadlessChatComposerElementEvent;
 };
 
 /** `HelixHeadlessChatMessage` component event */
@@ -1871,6 +1960,9 @@ export type HelixHeadlessChatHelixBeforePinElementEvent =
 /** `helix-history` event type */
 export type HelixHeadlessChatHelixHistoryElementEvent =
   HelixHeadlessChatElementEvent<HelixHistoryEvent>;
+/** `helix-pin` event type */
+export type HelixHeadlessChatHelixPinElementEvent =
+  HelixHeadlessChatElementEvent<HelixPinEvent>;
 /** `helix-send` event type */
 export type HelixHeadlessChatHelixSendElementEvent =
   HelixHeadlessChatElementEvent<HelixSendEvent>;
@@ -1958,6 +2050,8 @@ export type HelixHeadlessChatVueEvents = {
   "helix-before-pin": HelixHeadlessChatHelixBeforePinElementEvent;
   /** Fired when the user reaches the oldest turn while `history` is `more`. It reports the position and cannot be canceled. */
   "helix-history": HelixHeadlessChatHelixHistoryElementEvent;
+  /** Fired after the transcript is pinned or unpinned, with `true` or `false` in `detail.value`. */
+  "helix-pin": HelixHeadlessChatHelixPinElementEvent;
   /** Fired when the user sends a turn from the composer or retries a failed one. It is fired inside and handled here, so you can listen for it on the conversation. Cancelable: canceling it sends nothing and leaves the decision to you. */
   "helix-send": HelixHeadlessChatHelixSendElementEvent;
 };
@@ -1972,12 +2066,13 @@ export type HelixHeadlessCheckboxGroupHelixBeforeChangeElementEvent =
   HelixHeadlessCheckboxGroupElementEvent<HelixBeforeChangeEvent>;
 
 export type HelixHeadlessCheckboxGroupVueProps = {
-  /** The checked values, comma separated. */
+  /** The checked values, comma separated.
+
+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. */
   value?: (HelixHeadlessCheckboxGroup["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessCheckboxGroup["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessCheckboxGroup["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessCheckboxGroup["feedback"]) | undefined;
@@ -2055,7 +2150,11 @@ export type HelixHeadlessCheckboxHelixBeforeToggleElementEvent =
 export type HelixHeadlessCheckboxVueProps = {
   /** Shows the box as neither checked nor unchecked.
 
-Presentation only. It never submits, and the first change resolves it. */
+Presentation only. It never submits, and the first change resolves it.
+
+Not reflected, as no state is: the element resolves it itself, and a
+reflected one removed the attribute the consumer wrote. A stylesheet
+reads it as `:state(indeterminate)`. */
   indeterminate?: (HelixHeadlessCheckbox["indeterminate"]) | undefined;
   /** The value submitted when the box is checked. */
   value?: (HelixHeadlessCheckbox["value"]) | undefined;
@@ -2073,9 +2172,7 @@ stylesheets. */
   /** Whether the control starts checked. A form reset returns it to this state. */
   defaultChecked?: (HelixHeadlessCheckbox["defaultChecked"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessCheckbox["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessCheckbox["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessCheckbox["feedback"]) | undefined;
@@ -2142,6 +2239,14 @@ export type HelixHeadlessCheckboxVueEvents = {
 };
 
 export type HelixHeadlessCodeBlockVueProps = {
+  /** The copy button's name and tooltip text after a copy. */
+  "copied-label"?: (HelixHeadlessCodeBlock["copiedLabel"]) | undefined;
+  /** The copy button's name and tooltip text after a copy. */
+  copiedLabel?: (HelixHeadlessCodeBlock["copiedLabel"]) | undefined;
+  /** The copy button's name and tooltip text before a copy. */
+  "copy-label"?: (HelixHeadlessCodeBlock["copyLabel"]) | undefined;
+  /** The copy button's name and tooltip text before a copy. */
+  copyLabel?: (HelixHeadlessCodeBlock["copyLabel"]) | 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
@@ -2220,6 +2325,9 @@ export type HelixHeadlessColorInputHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixHeadlessColorInputHelixBeforeOpenElementEvent =
   HelixHeadlessColorInputElementEvent<HelixBeforeOpenEvent>;
+/** `toggle` event type */
+export type HelixHeadlessColorInputToggleElementEvent =
+  HelixHeadlessColorInputElementEvent<ToggleEvent>;
 
 export type HelixHeadlessColorInputVueProps = {
   /** Whether the color carries an alpha channel. */
@@ -2247,6 +2355,16 @@ value spelled out. */
   noFormat?: (HelixHeadlessColorInput["noFormat"]) | undefined;
   /** The text the field shows before a color is entered. */
   placeholder?: (HelixHeadlessColorInput["placeholder"]) | undefined;
+  /** Whether the color is locked. A read-only field still submits its value.
+
+The field can be read and copied from, and the panel does not open, as on
+Date Input and Time Input. */
+  readonly?: (HelixHeadlessColorInput["readOnly"]) | undefined;
+  /** Whether the color is locked. A read-only field still submits its value.
+
+The field can be read and copied from, and the panel does not open, as on
+Date Input and Time Input. */
+  readOnly?: (HelixHeadlessColorInput["readOnly"]) | undefined;
   /** Colors offered under the picker, as a comma-separated list. */
   swatches?: (HelixHeadlessColorInput["swatches"]) | undefined;
   /** Accessible name for the control that opens the panel. */
@@ -2314,9 +2432,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixHeadlessColorInput["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessColorInput["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessColorInput["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessColorInput["feedback"]) | undefined;
@@ -2385,7 +2501,7 @@ export type HelixHeadlessColorInputVueEvents = {
   /** Fired as the value changes. */
   input: HelixHeadlessColorInputElementEvent;
   /** The panel opened or closed. The event carries `newState` and `oldState`. */
-  toggle: HelixHeadlessColorInputElementEvent;
+  toggle: HelixHeadlessColorInputToggleElementEvent;
 };
 
 /** `HelixHeadlessColorPicker` component event */
@@ -2419,6 +2535,10 @@ point.** The field holds a color, so a browser offering to fill it with a
 saved address is competing for the same keystrokes as the square and the
 ramps. A consumer who wants autofill can still ask. */
   autocomplete?: (HelixHeadlessColorPicker["autocomplete"]) | undefined;
+  /** The message shown when the value is text that is not a color. */
+  "bad-input-message"?: (HelixHeadlessColorPicker["badInputMessage"]) | undefined;
+  /** The message shown when the value is text that is not a color. */
+  badInputMessage?: (HelixHeadlessColorPicker["badInputMessage"]) | undefined;
   /** What the square's vertical ramp is called.
 
 **Every word the picker speaks is a property**, so a page in another
@@ -2575,13 +2695,11 @@ a panel composed *into* a field that already has all three, so taking it
 would give one control two of each. What is left is the validity call and
 the anchor the browser points its bubble at.
 
-**Emptiness is the only fault reported, and bad input deliberately is
-not.** The value row is typed into a character at a time and every
-keystroke reaches `requestValue`, so `#0`, `#00` and `#00f` would each be a
-reported fault on the way to `#00ff00`. Date Picker and Time Picker can
-report bad input because their value moves only on a commit. Color Input
-reports it for this family instead, once, against the field the reader
-typed into. */
+**Text that is not a color is bad input**, so a form does not submit
+`#00` from a half-typed value. The picker draws no message of its own, so
+reporting it as each keystroke arrives shows nothing until the form asks;
+Color Input shows its own message against the field the reader typed
+into. */
   required?: (HelixHeadlessColorPicker["required"]) | undefined;
   /** What the square's horizontal ramp is called. */
   "saturation-label"?: (HelixHeadlessColorPicker["saturationLabel"]) | undefined;
@@ -2683,6 +2801,9 @@ export type HelixHeadlessComboboxHelixCreateElementEvent =
 /** `helix-filter` event type */
 export type HelixHeadlessComboboxHelixFilterElementEvent =
   HelixHeadlessComboboxElementEvent<HelixFilterEvent>;
+/** `toggle` event type */
+export type HelixHeadlessComboboxToggleElementEvent =
+  HelixHeadlessComboboxElementEvent<ToggleEvent>;
 
 export type HelixHeadlessComboboxVueProps = {
   /** What the browser may autofill in the text field, as a platform token.
@@ -2697,7 +2818,8 @@ keystrokes as the listbox. A consumer who wants autofill can still ask. */
 The row appears while what is typed matches no option's words exactly, so
 it is offered next to near misses too: a reader typing "Ruby on Rails" with
 "Ruby" in the list wants the one they are typing, not the one they are
-halfway through. */
+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. */
   "create-label"?: (HelixHeadlessCombobox["createLabel"]) | undefined;
@@ -2740,6 +2862,16 @@ element is responsible for. */
   multiple?: (HelixHeadlessCombobox["multiple"]) | undefined;
   /** Text shown while nothing has been chosen. */
   placeholder?: (HelixHeadlessCombobox["placeholder"]) | undefined;
+  /** Whether the choice is locked. A read-only combobox still submits its value.
+
+The field can be read and focused, the list does not open, and the tags of
+a `multiple` combobox cannot be dismissed. */
+  readonly?: (HelixHeadlessCombobox["readOnly"]) | undefined;
+  /** Whether the choice is locked. A read-only combobox still submits its value.
+
+The field can be read and focused, the list does not open, and the tags of
+a `multiple` combobox cannot be dismissed. */
+  readOnly?: (HelixHeadlessCombobox["readOnly"]) | undefined;
   /** The name of the control that removes one chosen option, with `{name}`
 filled in.
 
@@ -2804,9 +2936,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixHeadlessCombobox["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessCombobox["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessCombobox["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessCombobox["feedback"]) | undefined;
@@ -2886,7 +3016,7 @@ export type HelixHeadlessComboboxVueEvents = {
   /** Fired after the value changes. */
   input: HelixHeadlessComboboxElementEvent;
   /** Fired when the panel opens or closes, with `newState` and `oldState`. */
-  toggle: HelixHeadlessComboboxElementEvent;
+  toggle: HelixHeadlessComboboxToggleElementEvent;
 };
 
 /** `HelixHeadlessCommand` component event */
@@ -2900,9 +3030,15 @@ export type HelixHeadlessCommandHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixHeadlessCommandHelixBeforeOpenElementEvent =
   HelixHeadlessCommandElementEvent<HelixBeforeOpenEvent>;
+/** `helix-filter` event type */
+export type HelixHeadlessCommandHelixFilterElementEvent =
+  HelixHeadlessCommandElementEvent<HelixFilterEvent>;
 /** `helix-select` event type */
 export type HelixHeadlessCommandHelixSelectElementEvent =
   HelixHeadlessCommandElementEvent<HelixSelectEvent>;
+/** `toggle` event type */
+export type HelixHeadlessCommandToggleElementEvent =
+  HelixHeadlessCommandElementEvent<ToggleEvent>;
 
 export type HelixHeadlessCommandVueProps = {
   /** The text shown when the filter matches no commands. */
@@ -2917,6 +3053,15 @@ with: one key, said once. */
   hotkey?: (HelixHeadlessCommand["hotkey"]) | undefined;
   /** Accessible name for the overlay, which has no visible heading. */
   label?: (HelixHeadlessCommand["label"]) | undefined;
+  /** Whether the commands are still loading, for a palette that asks a server
+for them as the user types.
+
+Passed to the list, which shows `loading-text` and tells screen readers. */
+  loading?: (HelixHeadlessCommand["loading"]) | undefined;
+  /** The text shown while the commands load. */
+  "loading-text"?: (HelixHeadlessCommand["loadingText"]) | undefined;
+  /** The text shown while the commands load. */
+  loadingText?: (HelixHeadlessCommand["loadingText"]) | undefined;
   /** The text shown in the filter field before anything is typed. */
   placeholder?: (HelixHeadlessCommand["placeholder"]) | undefined;
   /** Whether the element starts open. Ignored once `open` is written. */
@@ -2943,10 +3088,12 @@ export type HelixHeadlessCommandVueEvents = {
   "helix-before-close": HelixHeadlessCommandHelixBeforeCloseElementEvent;
   /** The palette is about to open. Cancelable: cancel it to keep it closed. */
   "helix-before-open": HelixHeadlessCommandHelixBeforeOpenElementEvent;
+  /** Fired as the user types, with the text the list is filtered by. Cancelable: cancel it to leave the list unfiltered and filter the commands yourself, for example on a server while `loading` is set. */
+  "helix-filter": HelixHeadlessCommandHelixFilterElementEvent;
   /** A command was chosen. Cancelable: cancel it to keep the palette open. */
   "helix-select": HelixHeadlessCommandHelixSelectElementEvent;
   /** The palette opened or closed. The event carries `newState` and `oldState`. */
-  toggle: HelixHeadlessCommandElementEvent;
+  toggle: HelixHeadlessCommandToggleElementEvent;
 };
 
 /** `HelixHeadlessCopyButton` component event */
@@ -2977,13 +3124,11 @@ world is called Copy. A consumer with a better word still sets it. */
   label?: (HelixHeadlessCopyButton["label"]) | undefined;
   /** The text copied to the clipboard.
 
-**Narrows `Button.value`, which is the submit value, and the two agree.**
-A copy button is `type="button"` and never submits, so the inherited
-meaning has nothing to act on; where a consumer changes the type, what it
-submits is what it copies, which is the reading anybody would expect of one
-property called `value`. Declared here rather than inherited because the
-clipboard is what this component is about and its own page should say so. */
+It replaces `Button.value`, the submit value: a copy button never submits,
+whatever its `type`. Declared here so its own page says what it holds. */
   value?: (HelixHeadlessCopyButton["value"]) | undefined;
+  /**  */
+  "aria-label"?: unknown;
   /** What to send when the button is activated, and what to send it to.
 
 The platform's invoker attributes, forwarded onto the inner `<button>`
@@ -3142,21 +3287,36 @@ export type HelixHeadlessDataTableElementEvent<E = Event> = TypedEvent<
   HelixHeadlessDataTable,
   E
 >;
+/** `helix-activate` event type */
+export type HelixHeadlessDataTableHelixActivateElementEvent =
+  HelixHeadlessDataTableElementEvent<HelixActivateEvent>;
 /** `helix-filter` event type */
 export type HelixHeadlessDataTableHelixFilterElementEvent =
   HelixHeadlessDataTableElementEvent<HelixFilterEvent>;
+/** `helix-filtered` event type */
+export type HelixHeadlessDataTableHelixFilteredElementEvent =
+  HelixHeadlessDataTableElementEvent<HelixFilteredEvent>;
 /** `helix-navigate` event type */
 export type HelixHeadlessDataTableHelixNavigateElementEvent =
   HelixHeadlessDataTableElementEvent<HelixNavigateEvent>;
 /** `helix-reorder` event type */
 export type HelixHeadlessDataTableHelixReorderElementEvent =
   HelixHeadlessDataTableElementEvent<HelixReorderEvent>;
+/** `helix-reordered` event type */
+export type HelixHeadlessDataTableHelixReorderedElementEvent =
+  HelixHeadlessDataTableElementEvent<HelixReorderedEvent>;
 /** `helix-select` event type */
 export type HelixHeadlessDataTableHelixSelectElementEvent =
   HelixHeadlessDataTableElementEvent<HelixSelectEvent>;
+/** `helix-selected` event type */
+export type HelixHeadlessDataTableHelixSelectedElementEvent =
+  HelixHeadlessDataTableElementEvent<HelixSelectedEvent>;
 /** `helix-sort` event type */
 export type HelixHeadlessDataTableHelixSortElementEvent =
   HelixHeadlessDataTableElementEvent<HelixSortEvent>;
+/** `helix-sorted` event type */
+export type HelixHeadlessDataTableHelixSortedElementEvent =
+  HelixHeadlessDataTableElementEvent<HelixSortedEvent>;
 
 export type HelixHeadlessDataTableVueProps = {
   /** The word for an ascending sort, in `sorted-label`. */
@@ -3207,6 +3367,12 @@ One query rather than a predicate per column, which is what a reader means
 by a search box above a table. It matches on each column's ordering value,
 so search and sort cannot disagree about what a column holds. */
   filter?: (HelixHeadlessDataTable["filter"]) | undefined;
+  /** The built-in pagination's name for a gap in its run of pages. `{page}` is
+replaced with the page it jumps to. */
+  "gap-label"?: (HelixHeadlessDataTable["gapLabel"]) | undefined;
+  /** The built-in pagination's name for a gap in its run of pages. `{page}` is
+replaced with the page it jumps to. */
+  gapLabel?: (HelixHeadlessDataTable["gapLabel"]) | undefined;
   /** The grid's name, read by screen readers. */
   label?: (HelixHeadlessDataTable["label"]) | undefined;
   /** Where filtering, sorting, and paging happen. `client` does them in the
@@ -3219,6 +3385,10 @@ 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;
+  /** 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. */
+  nextLabel?: (HelixHeadlessDataTable["nextLabel"]) | undefined;
   /** The column order, as field names separated by spaces.
 
 A reader's move fires `helix-reorder` first, and refusing it leaves the
@@ -3233,6 +3403,12 @@ Clamped on the way out, so what this reports is the page it drew: a
 bookmarked link to page 99 of a result that has since shrunk reads back as
 the last page rather than as 99. */
   page?: (HelixHeadlessDataTable["page"]) | undefined;
+  /** The built-in pagination's name for one page. `{page}` and `{pages}` are
+replaced with the page number and the page count. */
+  "page-label"?: (HelixHeadlessDataTable["pageLabel"]) | undefined;
+  /** The built-in pagination's name for one page. `{page}` and `{pages}` are
+replaced with the page number and the page count. */
+  pageLabel?: (HelixHeadlessDataTable["pageLabel"]) | undefined;
   /** The number of rows on a page. `0` shows every row, with no paging.
 
 **It announces nothing, and that is not an omission.** Nothing in this
@@ -3256,11 +3432,29 @@ change pages shows a reader the first twenty rows and no way to know there
 are more. Off for a consumer supplying their own through the `footer` slot,
 which is why the slot replaces this rather than sitting beside it. */
   paginated?: (HelixHeadlessDataTable["paginated"]) | undefined;
+  /** The name of the built-in pagination's navigation landmark. */
+  "pagination-label"?: (HelixHeadlessDataTable["paginationLabel"]) | undefined;
+  /** The name of the built-in pagination's navigation landmark. */
+  paginationLabel?: (HelixHeadlessDataTable["paginationLabel"]) | 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. */
+  previousLabel?: (HelixHeadlessDataTable["previousLabel"]) | undefined;
   /** Lets users reorder the columns.
 
 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. */
+  "result-label"?: (HelixHeadlessDataTable["resultLabel"]) | undefined;
+  /** What screen readers hear when a search leaves one row. `{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. */
+  "results-label"?: (HelixHeadlessDataTable["resultsLabel"]) | undefined;
+  /** What screen readers hear when a search leaves any other number of rows.
+`{count}` is the count. */
+  resultsLabel?: (HelixHeadlessDataTable["resultsLabel"]) | undefined;
   /** The field that identifies each row.
 
 **Needed before selection exists, not after.** Lit keys the rendered rows by
@@ -3292,6 +3486,10 @@ the element, so a React page could not tell the table which field a row is. */
 Wants `row-key`: a selection is a set of identities, and without one the rows
 are known by their place in the result, which a sort changes. */
   selectable?: (HelixHeadlessDataTable["selectable"]) | undefined;
+  /** The name of the checkbox in the heading that selects every row. */
+  "select-all-label"?: (HelixHeadlessDataTable["selectAllLabel"]) | undefined;
+  /** The name of the checkbox in the heading that selects every row. */
+  selectAllLabel?: (HelixHeadlessDataTable["selectAllLabel"]) | undefined;
   /** The keys of the selected rows, separated by commas.
 
 A string rather than an array, so it is an attribute a server writes and a
@@ -3306,11 +3504,18 @@ rows are chosen. */
   /** What screen readers hear when the chosen rows change. `{count}` is how many
 rows are chosen. */
   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. */
+  "select-row-label"?: (HelixHeadlessDataTable["selectRowLabel"]) | 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. */
+  selectRowLabel?: (HelixHeadlessDataTable["selectRowLabel"]) | undefined;
   /** The sort order, as `field:direction`.
 
-Set it and this element defers: a reader's click fires `helix-sort` and
-changes nothing until a new value arrives. `default-sort` seeds an order this
-element then owns. */
+A reader's click on a sortable heading fires `helix-sort` first, and
+refusing it leaves the order as it was. To own the order yourself, refuse
+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`. */
@@ -3375,16 +3580,26 @@ 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;
   /** The search query is about to change. Cancelable: cancel it to keep the current query. */
   "helix-filter": HelixHeadlessDataTableHelixFilterElementEvent;
+  /** Fired after the search query changes, with the new query. */
+  "helix-filtered": HelixHeadlessDataTableHelixFilteredElementEvent;
   /** Another page was requested. Cancelable: cancel it to stay on the current page. */
   "helix-navigate": HelixHeadlessDataTableHelixNavigateElementEvent;
-  /** The columns were moved. The event carries every field in the new order. Cancelable: cancel it to keep the current order. */
+  /** The columns are about to move. The event carries every field in the new order. Cancelable: cancel it to keep the current order. */
   "helix-reorder": HelixHeadlessDataTableHelixReorderElementEvent;
-  /** The selection changed. The event carries every selected key, separated by commas. Cancelable: cancel it to keep the current selection. */
+  /** Fired after the columns move, with every field in the new order. */
+  "helix-reordered": HelixHeadlessDataTableHelixReorderedElementEvent;
+  /** 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": HelixHeadlessDataTableHelixSelectElementEvent;
+  /** Fired after the selection changes, with every selected key, separated by commas. */
+  "helix-selected": HelixHeadlessDataTableHelixSelectedElementEvent;
   /** A different sort order was requested. Cancelable: cancel it to keep the current order. */
   "helix-sort": HelixHeadlessDataTableHelixSortElementEvent;
+  /** Fired after the sort order changes, with the new order. */
+  "helix-sorted": HelixHeadlessDataTableHelixSortedElementEvent;
 };
 
 /** `HelixHeadlessDateInput` component event */
@@ -3401,6 +3616,9 @@ export type HelixHeadlessDateInputHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixHeadlessDateInputHelixBeforeOpenElementEvent =
   HelixHeadlessDateInputElementEvent<HelixBeforeOpenEvent>;
+/** `toggle` event type */
+export type HelixHeadlessDateInputToggleElementEvent =
+  HelixHeadlessDateInputElementEvent<ToggleEvent>;
 
 export type HelixHeadlessDateInputVueProps = {
   /** What the browser may autofill here, as one of the platform's own tokens.
@@ -3409,6 +3627,10 @@ 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 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. */
+  calendarLabel?: (HelixHeadlessDateInput["calendarLabel"]) | undefined;
   /** How a date is written in the field: `short` through `full`, or ISO.
 
 **The field renders when it is idle and holds the value when it is being
@@ -3455,21 +3677,29 @@ rather than reading it, or where the ISO form is itself the point.
 The value is always `YYYY-MM-DD` regardless, because that is what a form
 submits and what `min` and `max` compare against. */
   dateStyle?: (HelixHeadlessDateInput["dateStyle"]) | undefined;
-  /** Dates that cannot be chosen, as a comma-separated `YYYY-MM-DD` list. */
+  /** Dates that cannot be chosen, as `YYYY-MM-DD`, separated by commas or
+spaces. */
   "disable-dates"?: (HelixHeadlessDateInput["disableDates"]) | undefined;
-  /** Dates that cannot be chosen, as a comma-separated `YYYY-MM-DD` list. */
+  /** Dates that cannot be chosen, as `YYYY-MM-DD`, separated by commas or
+spaces. */
   disableDates?: (HelixHeadlessDateInput["disableDates"]) | undefined;
   /** Days of the week that cannot be chosen, from `0` for Sunday to `6` for
-Saturday. */
+Saturday, separated by commas or spaces. */
   "disable-days"?: (HelixHeadlessDateInput["disableDays"]) | undefined;
   /** Days of the week that cannot be chosen, from `0` for Sunday to `6` for
-Saturday. */
+Saturday, separated by commas or spaces. */
   disableDays?: (HelixHeadlessDateInput["disableDays"]) | undefined;
   /** The day in the calendar's first column, from `0` for Sunday to `6` for
-Saturday. */
+Saturday.
+
+Absent follows `locale`, where the engine knows the week of that language,
+and is Sunday otherwise. */
   "first-day-of-week"?: (HelixHeadlessDateInput["firstDayOfWeek"] | `${number}`) | undefined;
   /** The day in the calendar's first column, from `0` for Sunday to `6` for
-Saturday. */
+Saturday.
+
+Absent follows `locale`, where the engine knows the week of that language,
+and is Sunday otherwise. */
   firstDayOfWeek?: (HelixHeadlessDateInput["firstDayOfWeek"]) | undefined;
   /** The language tag for the names of months and days in the calendar. */
   locale?: (HelixHeadlessDateInput["locale"]) | undefined;
@@ -3490,8 +3720,16 @@ an end in April otherwise means paging between them and losing sight of the
 first. The panel is sized by its content, so this widens it, and where the
 window has no room for that width it shows one month until there is. */
   months?: (HelixHeadlessDateInput["months"]) | undefined;
+  /** The name of the calendar's control that moves to the next month. */
+  "next-label"?: (HelixHeadlessDateInput["nextLabel"]) | undefined;
+  /** The name of the calendar's control that moves to the next month. */
+  nextLabel?: (HelixHeadlessDateInput["nextLabel"]) | undefined;
   /** The text the field shows before a date is entered. */
   placeholder?: (HelixHeadlessDateInput["placeholder"]) | undefined;
+  /** The name of the calendar's control that moves to the previous month. */
+  "previous-label"?: (HelixHeadlessDateInput["previousLabel"]) | undefined;
+  /** The name of the calendar's control that moves to the previous month. */
+  previousLabel?: (HelixHeadlessDateInput["previousLabel"]) | 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**,
@@ -3535,10 +3773,18 @@ so the field and the grid agree about which dates exist. Counted from `min`
 where there is one and from 1 January 1970 where there is not, which is the
 platform's base. */
   step?: (HelixHeadlessDateInput["step"]) | undefined;
+  /** The message shown when a date is not on `step`. */
+  "step-mismatch-message"?: (HelixHeadlessDateInput["stepMismatchMessage"]) | undefined;
+  /** The message shown when a date is not on `step`. */
+  stepMismatchMessage?: (HelixHeadlessDateInput["stepMismatchMessage"]) | undefined;
   /** The name of the button that opens the calendar, read by screen readers. */
   "trigger-label"?: (HelixHeadlessDateInput["triggerLabel"]) | undefined;
   /** The name of the button that opens the calendar, read by screen readers. */
   triggerLabel?: (HelixHeadlessDateInput["triggerLabel"]) | undefined;
+  /** The message shown when `disable-dates` or `disable-days` bars a date. */
+  "unavailable-message"?: (HelixHeadlessDateInput["unavailableMessage"]) | undefined;
+  /** The message shown when `disable-dates` or `disable-days` bars a date. */
+  unavailableMessage?: (HelixHeadlessDateInput["unavailableMessage"]) | undefined;
   /** Whether the value is locked. A read-only control still submits its value.
 
 **Enforced by refusing every request in one place**, which is the seam this
@@ -3624,9 +3870,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixHeadlessDateInput["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessDateInput["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessDateInput["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessDateInput["feedback"]) | undefined;
@@ -3709,7 +3953,7 @@ export type HelixHeadlessDateInputVueEvents = {
   /** Fired after the value changes. */
   input: HelixHeadlessDateInputElementEvent;
   /** Fired when the calendar opens or closes, with `newState` and `oldState`. */
-  toggle: HelixHeadlessDateInputElementEvent;
+  toggle: HelixHeadlessDateInputToggleElementEvent;
 };
 
 /** `HelixHeadlessDatePicker` component event */
@@ -3741,17 +3985,27 @@ speaks it. Absent is the control's own sentence, in English. */
   "default-month"?: (HelixHeadlessDatePicker["defaultMonth"]) | undefined;
   /** The month to open on when `month` is not set. */
   defaultMonth?: (HelixHeadlessDatePicker["defaultMonth"]) | undefined;
-  /** Dates that cannot be chosen, comma separated, as `YYYY-MM-DD`. */
+  /** Dates that cannot be chosen, as `YYYY-MM-DD`, separated by commas or
+spaces. */
   "disable-dates"?: (HelixHeadlessDatePicker["disableDates"]) | undefined;
-  /** Dates that cannot be chosen, comma separated, as `YYYY-MM-DD`. */
+  /** Dates that cannot be chosen, as `YYYY-MM-DD`, separated by commas or
+spaces. */
   disableDates?: (HelixHeadlessDatePicker["disableDates"]) | undefined;
-  /** Days of the week that cannot be chosen, comma separated, `0` to `6`. */
+  /** Days of the week that cannot be chosen, `0` for Sunday to `6` for
+Saturday, separated by commas or spaces. */
   "disable-days"?: (HelixHeadlessDatePicker["disableDays"]) | undefined;
-  /** Days of the week that cannot be chosen, comma separated, `0` to `6`. */
+  /** Days of the week that cannot be chosen, `0` for Sunday to `6` for
+Saturday, separated by commas or spaces. */
   disableDays?: (HelixHeadlessDatePicker["disableDays"]) | undefined;
-  /** First column of the week, `0` for Sunday through `6` for Saturday. */
+  /** First column of the week, `0` for Sunday through `6` for Saturday.
+
+Absent follows `locale`, where the engine knows the week of that language
+(Firefox does not), and is Sunday otherwise. */
   "first-day-of-week"?: (HelixHeadlessDatePicker["firstDayOfWeek"] | `${number}`) | undefined;
-  /** First column of the week, `0` for Sunday through `6` for Saturday. */
+  /** First column of the week, `0` for Sunday through `6` for Saturday.
+
+Absent follows `locale`, where the engine knows the week of that language
+(Firefox does not), and is Sunday otherwise. */
   firstDayOfWeek?: (HelixHeadlessDatePicker["firstDayOfWeek"]) | undefined;
   /** Whether the current selection fails validation. */
   invalid?: (HelixHeadlessDatePicker["invalid"]) | undefined;
@@ -3794,6 +4048,18 @@ would otherwise still announce its controls in English. `attribute:`
 spelled out, since Lit lowercases a camelCase name rather than dash-casing
 it. */
   previousLabel?: (HelixHeadlessDatePicker["previousLabel"]) | undefined;
+  /** The validation message for a date after `max`. `{max}` is replaced with
+`max`, written as a date in `locale`. */
+  "range-overflow-message"?: (HelixHeadlessDatePicker["rangeOverflowMessage"]) | undefined;
+  /** The validation message for a date after `max`. `{max}` is replaced with
+`max`, written as a date in `locale`. */
+  rangeOverflowMessage?: (HelixHeadlessDatePicker["rangeOverflowMessage"]) | undefined;
+  /** The validation message for a date before `min`. `{min}` is replaced with
+`min`, written as a date in `locale`. */
+  "range-underflow-message"?: (HelixHeadlessDatePicker["rangeUnderflowMessage"]) | undefined;
+  /** The validation message for a date before `min`. `{min}` is replaced with
+`min`, written as a date in `locale`. */
+  rangeUnderflowMessage?: (HelixHeadlessDatePicker["rangeUnderflowMessage"]) | undefined;
   /** Blocks changes to the dates. The value is still submitted with the form.
 
 **Enforced by refusing every request in one place**, which is the seam this
@@ -3832,6 +4098,16 @@ One is every date and needs no rule, which is why anything below one is
 treated as one rather than as an error: a step of zero would block every
 date including the one already chosen. */
   step?: (HelixHeadlessDatePicker["step"]) | undefined;
+  /** The validation message for a date that `step` skips. */
+  "step-mismatch-message"?: (HelixHeadlessDatePicker["stepMismatchMessage"]) | undefined;
+  /** The validation message for a date that `step` skips. */
+  stepMismatchMessage?: (HelixHeadlessDatePicker["stepMismatchMessage"]) | undefined;
+  /** The validation message for a date that `disable-dates` or `disable-days`
+bars. */
+  "unavailable-message"?: (HelixHeadlessDatePicker["unavailableMessage"]) | undefined;
+  /** The validation message for a date that `disable-dates` or `disable-days`
+bars. */
+  unavailableMessage?: (HelixHeadlessDatePicker["unavailableMessage"]) | undefined;
   /** The validation message for a required date picker with no date chosen. */
   "value-missing-message"?: (HelixHeadlessDatePicker["valueMissingMessage"]) | undefined;
   /** The validation message for a required date picker with no date chosen. */
@@ -3941,6 +4217,9 @@ export type HelixHeadlessDialogHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixHeadlessDialogHelixBeforeOpenElementEvent =
   HelixHeadlessDialogElementEvent<HelixBeforeOpenEvent>;
+/** `toggle` event type */
+export type HelixHeadlessDialogToggleElementEvent =
+  HelixHeadlessDialogElementEvent<ToggleEvent>;
 
 export type HelixHeadlessDialogVueProps = {
   /** Which close requests the browser handles on its own.
@@ -3965,7 +4244,8 @@ the property this component exists to keep.
 Absent by default, which is the platform's `auto` and this library's rule
 that a resting value is an attribute's absence. */
   closedBy?: (HelixHeadlessDialog["closedBy"]) | undefined;
-  /** Accessible name for the dialog. */
+  /** Accessible name for the dialog. When it is empty, the heading in the
+`header` slot names the dialog. */
   label?: (HelixHeadlessDialog["label"]) | undefined;
   /** Stops Escape and a press on the backdrop from closing the dialog.
 
@@ -4015,7 +4295,7 @@ export type HelixHeadlessDialogVueEvents = {
   /** Fired before it opens, and cancelable. */
   "helix-before-open": HelixHeadlessDialogHelixBeforeOpenElementEvent;
   /** Sent when the dialog opens or closes, with `newState` and `oldState`. */
-  toggle: HelixHeadlessDialogElementEvent;
+  toggle: HelixHeadlessDialogToggleElementEvent;
 };
 
 export type HelixHeadlessDividerVueProps = {
@@ -4101,6 +4381,12 @@ shadow root reads a table in that root rather than one in the document. A
 Absent falls back to the table's own caption, which is usually the right
 words and is already written. */
   label?: (HelixHeadlessDonutChart["label"]) | undefined;
+  /** 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. */
+  locale?: (HelixHeadlessDonutChart["locale"]) | undefined;
 };
 
 export type HelixHeadlessDonutChartVueEvents = {};
@@ -4116,6 +4402,9 @@ export type HelixHeadlessDrawerHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixHeadlessDrawerHelixBeforeOpenElementEvent =
   HelixHeadlessDrawerElementEvent<HelixBeforeOpenEvent>;
+/** `toggle` event type */
+export type HelixHeadlessDrawerToggleElementEvent =
+  HelixHeadlessDrawerElementEvent<ToggleEvent>;
 
 export type HelixHeadlessDrawerVueProps = {
   /** Which close requests the browser handles on its own.
@@ -4140,7 +4429,8 @@ the property this component exists to keep.
 Absent by default, which is the platform's `auto` and this library's rule
 that a resting value is an attribute's absence. */
   closedBy?: (HelixHeadlessDrawer["closedBy"]) | undefined;
-  /** Accessible name for the panel. */
+  /** Accessible name for the panel. When it is empty, the heading in the
+`header` slot names the panel. */
   label?: (HelixHeadlessDrawer["label"]) | undefined;
   /** Whether the drawer blocks the page behind it.
 
@@ -4203,7 +4493,7 @@ export type HelixHeadlessDrawerVueEvents = {
   /** Fired before the panel opens, and cancelable. Canceling it keeps the panel closed. */
   "helix-before-open": HelixHeadlessDrawerHelixBeforeOpenElementEvent;
   /** Sent when the drawer opens or closes, with `newState` and `oldState`. */
-  toggle: HelixHeadlessDrawerElementEvent;
+  toggle: HelixHeadlessDrawerToggleElementEvent;
 };
 
 /** `HelixHeadlessDrilldownItem` component event */
@@ -4257,7 +4547,11 @@ export type HelixHeadlessDrilldownHelixSelectElementEvent =
   HelixHeadlessDrilldownElementEvent<HelixSelectEvent>;
 
 export type HelixHeadlessDrilldownVueProps = {
-  /** The region's name, read by screen readers. */
+  /** The name of the top page's menu, read by screen readers. A page below it is
+named by its title.
+
+An `aria-label` or `aria-labelledby` on the host names the top page too,
+and wins over this. */
   label?: (HelixHeadlessDrilldown["label"]) | undefined;
   /** The text of the back button. */
   "back-label"?: (HelixHeadlessDrilldown["backLabel"]) | undefined;
@@ -4311,7 +4605,10 @@ export type HelixHeadlessFileInputHelixBeforeChangeElementEvent =
   HelixHeadlessFileInputElementEvent<HelixBeforeChangeEvent>;
 
 export type HelixHeadlessFileInputVueProps = {
-  /** Which files the picker offers, as a native `accept` list. */
+  /** Which files the picker offers and a drop takes, as a native `accept` list.
+
+A dropped file the list does not name is left out, because the picker's
+filter is the only check the platform makes and a drop never meets it. */
   accept?: (HelixHeadlessFileInput["accept"]) | undefined;
   /** Which camera or microphone a mobile picker should offer, if any. */
   capture?: (HelixHeadlessFileInput["capture"]) | undefined;
@@ -4340,9 +4637,7 @@ removes rather than as "Remove" said once per file. A label with no
   /** The trigger's text when nothing is slotted into it. */
   triggerLabel?: (HelixHeadlessFileInput["triggerLabel"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessFileInput["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessFileInput["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessFileInput["feedback"]) | undefined;
@@ -4599,6 +4894,9 @@ export type HelixHeadlessFilterInputHelixFacetElementEvent =
 /** `helix-select` event type */
 export type HelixHeadlessFilterInputHelixSelectElementEvent =
   HelixHeadlessFilterInputElementEvent<HelixSelectEvent>;
+/** `toggle` event type */
+export type HelixHeadlessFilterInputToggleElementEvent =
+  HelixHeadlessFilterInputElementEvent<ToggleEvent>;
 
 export type HelixHeadlessFilterInputVueProps = {
   /** Shows a button that empties the field.
@@ -4663,9 +4961,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixHeadlessFilterInput["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessFilterInput["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessFilterInput["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessFilterInput["feedback"]) | undefined;
@@ -4740,7 +5036,7 @@ export type HelixHeadlessFilterInputVueEvents = {
   /** Fired when the text changes. */
   input: HelixHeadlessFilterInputElementEvent;
   /** Fired when the suggestions panel opens or closes, with `newState` and `oldState`. */
-  toggle: HelixHeadlessFilterInputElementEvent;
+  toggle: HelixHeadlessFilterInputToggleElementEvent;
 };
 
 export type HelixHeadlessFormatDateVueProps = {
@@ -5201,6 +5497,12 @@ shadow root reads a table in that root rather than one in the document. A
 Absent falls back to the table's own caption, which is usually the right
 words and is already written. */
   label?: (HelixHeadlessHeatmap["label"]) | undefined;
+  /** 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. */
+  locale?: (HelixHeadlessHeatmap["locale"]) | undefined;
 };
 
 export type HelixHeadlessHeatmapVueEvents = {
@@ -5381,6 +5683,12 @@ invoker without an id in the same tree needs. */
 
 export type HelixHeadlessIconButtonVueEvents = {};
 
+/** `HelixHeadlessIcon` component event */
+export type HelixHeadlessIconElementEvent<E = Event> = TypedEvent<
+  HelixHeadlessIcon,
+  E
+>;
+
 export type HelixHeadlessIconVueProps = {
   /** The icon's name, read by screen readers. Set it for an icon that is not
 decorative. */
@@ -5416,7 +5724,10 @@ for. Set both and this wins, the value being the more specific statement. */
   icon?: (HelixHeadlessIcon["icon"]) | undefined;
 };
 
-export type HelixHeadlessIconVueEvents = {};
+export type HelixHeadlessIconVueEvents = {
+  /** `name` matches no icon in the set, so nothing is drawn. */
+  error: HelixHeadlessIconElementEvent;
+};
 
 /** `HelixHeadlessImage` component event */
 export type HelixHeadlessImageElementEvent<E = Event> = TypedEvent<
@@ -5428,7 +5739,9 @@ export type HelixHeadlessImageVueProps = {
   /** A text description of the image, read by screen readers.
 
 Empty is a real answer and means decoration. Omitting the attribute is not
-the same thing: a reader with nothing to read announces the file name. */
+the same thing: the inner image is then written with no `alt` either, as a
+native one would be, so a screen reader announces the file name and an
+accessibility checker reports the missing description. */
   alt?: (HelixHeadlessImage["alt"]) | undefined;
   /** How the image is fetched across origins. It decides whether a canvas can
 read the image. */
@@ -5515,6 +5828,9 @@ export type HelixHeadlessInputHelixBeforeChangeElementEvent =
   HelixHeadlessInputElementEvent<HelixBeforeChangeEvent>;
 
 export type HelixHeadlessInputVueProps = {
+  /** Whether a phone capitalizes as the reader types: `off`, `sentences`,
+`words` or `characters`, as the platform's `autocapitalize`. */
+  autocapitalize?: (HelixHeadlessInput["autocapitalize"]) | undefined;
   /** What the browser may autofill in the field, as an HTML `autocomplete`
 token.
 
@@ -5532,10 +5848,29 @@ is broken. */
   "clear-label"?: (HelixHeadlessInput["clearLabel"]) | undefined;
   /** The accessible name of the clear button, which shows only an icon. */
   clearLabel?: (HelixHeadlessInput["clearLabel"]) | undefined;
+  /** The key the on-screen keyboard shows for Enter, as the platform's
+`enterkeyhint`: `search`, `send`, `go`, `next`, `previous`, `done` or
+`enter`. */
+  enterkeyhint?: (HelixHeadlessInput["enterKeyHint"]) | undefined;
+  /** The key the on-screen keyboard shows for Enter, as the platform's
+`enterkeyhint`: `search`, `send`, `go`, `next`, `previous`, `done` or
+`enter`. */
+  enterKeyHint?: (HelixHeadlessInput["enterKeyHint"]) | undefined;
+  /** The keyboard a phone offers, as the platform's `inputmode`, such as
+`numeric` for a code typed as text. */
+  inputmode?: (HelixHeadlessInput["inputMode"]) | undefined;
+  /** The keyboard a phone offers, as the platform's `inputmode`, such as
+`numeric` for a code typed as text. */
+  inputMode?: (HelixHeadlessInput["inputMode"]) | undefined;
+  /** The greatest value, for `type="number"`. Number Input adds steppers and
+keys to the same bounds. */
+  max?: (HelixHeadlessInput["max"]) | undefined;
   /** Most characters the value may have. */
   maxlength?: (HelixHeadlessInput["maxLength"] | `${number}`) | undefined;
   /** Most characters the value may have. */
   maxLength?: (HelixHeadlessInput["maxLength"]) | undefined;
+  /** The least value, for `type="number"`. */
+  min?: (HelixHeadlessInput["min"]) | undefined;
   /** Fewest characters the value may have. */
   minlength?: (HelixHeadlessInput["minLength"] | `${number}`) | undefined;
   /** Fewest characters the value may have. */
@@ -5587,6 +5922,9 @@ The state is `aria-pressed`, not this. */
 
 The state is `aria-pressed`, not this. */
   revealLabel?: (HelixHeadlessInput["revealLabel"]) | undefined;
+  /** The step a valid value is a multiple of, counted from `min`, for
+`type="number"`. */
+  step?: (HelixHeadlessInput["step"]) | undefined;
   /** The kind of text the field accepts. It sets the on-screen keyboard and the
 validation.
 
@@ -5612,9 +5950,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixHeadlessInput["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessInput["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessInput["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessInput["feedback"]) | undefined;
@@ -5706,11 +6042,16 @@ export type HelixHeadlessKbdHelixShortcutElementEvent =
   HelixHeadlessKbdElementEvent<HelixShortcutEvent>;
 
 export type HelixHeadlessKbdVueProps = {
-  /** The key or chord to show, such as `mod+k`, `shift+?`, or `/`.
+  /** The key or chord to show, such as `mod+k`, `?`, or `/`.
 
 `mod` is the platform's own command modifier, which is the reason to write
 a chord here rather than a glyph: it is the one token whose right answer
-differs per reader. */
+differs per reader.
+
+A symbol such as `?` or `!` is written as itself, without `shift`. It is
+matched whether or not Shift was held to type it, since that depends on
+the keyboard layout. Bound to the document, a chord that types a character
+is not taken from a field a reader is typing in. */
   keys?: (HelixHeadlessKbd["keys"]) | undefined;
   /** Where the chord is listened for. `control` listens inside the control the
 key sits in, and `document` listens on the whole page.
@@ -5757,6 +6098,11 @@ shadow root reads a table in that root rather than one in the document.
 **In React this arrives as a property and not as an attribute**, the way
 `Tooltip.for` does, so it does not reflect and nothing styles on it. */
   for?: (HelixHeadlessLegend["for"]) | undefined;
+  /** The name of the list, which a screen reader announces before its entries.
+
+Absent names the list after the table's caption, so a page with several
+charts has a legend list for each that says which chart it keys. */
+  label?: (HelixHeadlessLegend["label"]) | undefined;
 };
 
 export type HelixHeadlessLegendVueEvents = {};
@@ -5766,7 +6112,8 @@ export type HelixHeadlessLightboxItemVueProps = {
 
 Written by the root, which is the only thing that sees the set. */
   current?: (HelixHeadlessLightboxItem["current"]) | undefined;
-  /** The item's name, used in the status text that says which item is shown. */
+  /** The item's name. It names the item's group, and fills `{label}` in the
+lightbox's `status-label`. */
   label?: (HelixHeadlessLightboxItem["label"]) | undefined;
   /** The item's identifier. The root compares its `active` value against it. */
   value?: (HelixHeadlessLightboxItem["value"]) | undefined;
@@ -5791,6 +6138,9 @@ export type HelixHeadlessLightboxHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixHeadlessLightboxHelixBeforeOpenElementEvent =
   HelixHeadlessLightboxElementEvent<HelixBeforeOpenEvent>;
+/** `toggle` event type */
+export type HelixHeadlessLightboxToggleElementEvent =
+  HelixHeadlessLightboxElementEvent<ToggleEvent>;
 
 export type HelixHeadlessLightboxVueProps = {
   /** How long the user can be idle before the header and footer hide, in
@@ -5811,15 +6161,15 @@ keep the chrome up is the consumer's to decide with this. */
   label?: (HelixHeadlessLightbox["label"]) | undefined;
   /** Whether moving past the last item returns to the first. */
   loop?: (HelixHeadlessLightbox["loop"]) | undefined;
-  /** The status text that says which item is shown, with `{index}` and `{count}`
-filled in.
+  /** The status text that says which item is shown, with `{index}`, `{count}`
+and the item's `{label}` filled in.
 
 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}` and `{count}`
-filled in.
+  /** The status text that says which item is shown, with `{index}`, `{count}`
+and the item's `{label}` filled in.
 
 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
@@ -5873,7 +6223,7 @@ export type HelixHeadlessLightboxVueEvents = {
   /** Fired before the viewer opens. Cancelable. */
   "helix-before-open": HelixHeadlessLightboxHelixBeforeOpenElementEvent;
   /** Fired when the viewer opens or closes, with `newState` and `oldState`. */
-  toggle: HelixHeadlessLightboxElementEvent;
+  toggle: HelixHeadlessLightboxToggleElementEvent;
 };
 
 export type HelixHeadlessLineChartVueProps = {
@@ -5984,6 +6334,12 @@ shadow root reads a table in that root rather than one in the document. A
 Absent falls back to the table's own caption, which is usually the right
 words and is already written. */
   label?: (HelixHeadlessLineChart["label"]) | undefined;
+  /** 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. */
+  locale?: (HelixHeadlessLineChart["locale"]) | undefined;
 };
 
 export type HelixHeadlessLineChartVueEvents = {};
@@ -6104,6 +6460,13 @@ own search boxes would be three copies of one field. */
   "filter-label"?: (HelixHeadlessListbox["filterLabel"]) | undefined;
   /** Placeholder text for the filter field. */
   filterLabel?: (HelixHeadlessListbox["filterLabel"]) | undefined;
+  /** Stops the arrow keys from choosing each option they move to. Enter, Space
+or a click chooses the highlighted option.
+
+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. */
   multiple?: (HelixHeadlessListbox["multiple"]) | undefined;
   /** Whether the rows are still loading.
@@ -6128,9 +6491,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixHeadlessListbox["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessListbox["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessListbox["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessListbox["feedback"]) | undefined;
@@ -6530,6 +6891,12 @@ export type HelixHeadlessMapElementEvent<E = Event> = TypedEvent<
 /** `helix-activate` event type */
 export type HelixHeadlessMapHelixActivateElementEvent =
   HelixHeadlessMapElementEvent<HelixActivateEvent>;
+/** `helix-before-change` event type */
+export type HelixHeadlessMapHelixBeforeChangeElementEvent =
+  HelixHeadlessMapElementEvent<HelixBeforeChangeEvent>;
+/** `helix-before-toggle` event type */
+export type HelixHeadlessMapHelixBeforeToggleElementEvent =
+  HelixHeadlessMapElementEvent<HelixBeforeToggleEvent>;
 /** `helix-map-cluster` event type */
 export type HelixHeadlessMapHelixMapClusterElementEvent =
   HelixHeadlessMapElementEvent<HelixMapClusterEvent>;
@@ -6833,8 +7200,14 @@ elsewhere. Absent is the family's own. */
 };
 
 export type HelixHeadlessMapVueEvents = {
+  /** The layers menu changed the map type, which `map-type` now holds. */
+  change: HelixHeadlessMapElementEvent;
   /** A marker was pressed. The value is the marker's `name`, or its `label` if it has no name. A cluster sends `helix-map-cluster` instead. */
   "helix-activate": HelixHeadlessMapHelixActivateElementEvent;
+  /** A map type was chosen in the layers menu, with its name: `standard`, `hybrid`, or `satellite`. Cancelable: cancel it to keep the current type. */
+  "helix-before-change": HelixHeadlessMapHelixBeforeChangeElementEvent;
+  /** A layer's tile in the layers menu was pressed. Sent from the layer, with `checked` true when it is to be shown. Cancelable: cancel it to keep the layer as it is. */
+  "helix-before-toggle": HelixHeadlessMapHelixBeforeToggleElementEvent;
   /** A cluster was pressed. Sent from the marker that shows the cluster, with the names of its places. */
   "helix-map-cluster": HelixHeadlessMapHelixMapClusterElementEvent;
   /** A pan button or arrow key was pressed. Move your map in response. */
@@ -6937,6 +7310,9 @@ export type HelixHeadlessMegamenuHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixHeadlessMegamenuHelixBeforeOpenElementEvent =
   HelixHeadlessMegamenuElementEvent<HelixBeforeOpenEvent>;
+/** `toggle` event type */
+export type HelixHeadlessMegamenuToggleElementEvent =
+  HelixHeadlessMegamenuElementEvent<ToggleEvent>;
 
 export type HelixHeadlessMegamenuVueProps = {
   /** The page width, in pixels, below which a card panel is shown as a band. At
@@ -7053,7 +7429,7 @@ export type HelixHeadlessMegamenuVueEvents = {
   /** The panel is about to open. Cancelable. */
   "helix-before-open": HelixHeadlessMegamenuHelixBeforeOpenElementEvent;
   /** The panel opened or closed. Carries `newState` and `oldState`. */
-  toggle: HelixHeadlessMegamenuElementEvent;
+  toggle: HelixHeadlessMegamenuToggleElementEvent;
 };
 
 /** `HelixHeadlessMenuItem` component event */
@@ -7061,6 +7437,9 @@ export type HelixHeadlessMenuItemElementEvent<E = Event> = TypedEvent<
   HelixHeadlessMenuItem,
   E
 >;
+/** `helix-before-toggle` event type */
+export type HelixHeadlessMenuItemHelixBeforeToggleElementEvent =
+  HelixHeadlessMenuItemElementEvent<HelixBeforeToggleEvent>;
 /** `helix-select` event type */
 export type HelixHeadlessMenuItemHelixSelectElementEvent =
   HelixHeadlessMenuItemElementEvent<HelixSelectEvent>;
@@ -7074,9 +7453,15 @@ was never tickable look identical from here. Announcing only the ticked one
 as a checkbox tells a reader its siblings are commands, which is the one
 thing they are not.
 
-`checked` implies it, so a row that is on never has to say both. */
+`checked` implies it, so a row that is on never has to say both.
+
+Choosing the row checks or unchecks it, after a `helix-before-toggle` that
+you can cancel. */
   checkable?: (HelixHeadlessMenuItem["checkable"]) | undefined;
-  /** Whether the row is checked. */
+  /** Whether the row is checked.
+
+The row changes it when it is chosen. Not reflected: the attribute is the
+state you start the row in, and `:state(checked)` carries the current one. */
   checked?: (HelixHeadlessMenuItem["checked"]) | undefined;
   /** Whether the row is disabled, so it cannot be chosen. */
   disabled?: (HelixHeadlessMenuItem["disabled"]) | undefined;
@@ -7088,11 +7473,11 @@ about who may name a file on somebody's disk rather than a gap here. */
   download?: (HelixHeadlessMenuItem["download"]) | undefined;
   /** Whether only one row in its set can be checked at a time.
 
-Announcement and nothing else, the way `checkable` is: this element applies
-no choice and polices no group, so what it does is tell a reader which kind
-of set they are in. `menuitemcheckbox` says every row here is independent,
-which for a run of comparisons, or the values of a filter that compares
-against one, is the opposite of true.
+The set is the run of `exclusive` rows next to this one, up to the first
+element that is not one, such as a divider. Choosing a row in it checks
+that row and unchecks the others. Choosing the row that is checked leaves
+it checked. `menuitemradio` tells a reader which kind of set they are in,
+where `menuitemcheckbox` says every row is independent.
 
 Meaningless without `checkable`, since a row that cannot be ticked is not
 one of a set of anything. */
@@ -7140,6 +7525,8 @@ Three levels deep, the topmost row holds the slot the middle one lives in. */
 };
 
 export type HelixHeadlessMenuItemVueEvents = {
+  /** A choice row is about to be checked or unchecked, carrying the state asked for. Cancelable: cancel it to keep the row as it is. */
+  "helix-before-toggle": HelixHeadlessMenuItemHelixBeforeToggleElementEvent;
   /** The row was chosen. Cancelable: cancel it to keep the menu open. */
   "helix-select": HelixHeadlessMenuItemHelixSelectElementEvent;
 };
@@ -7158,13 +7545,20 @@ export type HelixHeadlessMenuHelixBeforeOpenElementEvent =
 /** `helix-select` event type */
 export type HelixHeadlessMenuHelixSelectElementEvent =
   HelixHeadlessMenuElementEvent<HelixSelectEvent>;
+/** `toggle` event type */
+export type HelixHeadlessMenuToggleElementEvent =
+  HelixHeadlessMenuElementEvent<ToggleEvent>;
 
 export type HelixHeadlessMenuVueProps = {
   /** The text of the row that returns from a submenu. */
   "back-label"?: (HelixHeadlessMenu["backLabel"]) | undefined;
   /** The text of the row that returns from a submenu. */
   backLabel?: (HelixHeadlessMenu["backLabel"]) | undefined;
-  /** Accessible name for the surface. */
+  /** Accessible name for the surface.
+
+Empty by default, which names the surface by its trigger, so a menu opened
+from "Actions" is announced as "Actions". An `aria-label` or
+`aria-labelledby` on the host names it too, and wins over both. */
   label?: (HelixHeadlessMenu["label"]) | undefined;
   /** Space between the trigger and the surface, in pixels. */
   offset?: (HelixHeadlessMenu["offset"]) | undefined;
@@ -7213,7 +7607,7 @@ export type HelixHeadlessMenuVueEvents = {
   /** An item was chosen. Cancelable: cancel it to keep the menu open. */
   "helix-select": HelixHeadlessMenuHelixSelectElementEvent;
   /** The menu opened or closed. The event carries `newState` and `oldState`. */
-  toggle: HelixHeadlessMenuElementEvent;
+  toggle: HelixHeadlessMenuToggleElementEvent;
 };
 
 export type HelixHeadlessMeterVueProps = {
@@ -7251,6 +7645,10 @@ Absent leaves the range unbanded. */
   high?: (HelixHeadlessMeter["high"]) | undefined;
   /** Accessible name for the reading. */
   label?: (HelixHeadlessMeter["label"]) | undefined;
+  /** The locale the percentage is written in, such as `fr` for `72 %`.
+
+Absent uses the runtime's own. */
+  locale?: (HelixHeadlessMeter["locale"]) | undefined;
   /** Top of the low band.
 
 Absent leaves the range unbanded. */
@@ -7315,7 +7713,11 @@ fair summary of a task and a poor one of a quantity. */
 export type HelixHeadlessMeterVueEvents = {};
 
 export type HelixHeadlessNavigationVueProps = {
-  /** The landmark's name, read by screen readers. */
+  /** The landmark's name, read by screen readers.
+
+An `aria-label` or `aria-labelledby` on the host names the landmark too,
+and wins over this, so a footer navigation written the usual way is not a
+second "Main". */
   label?: (HelixHeadlessNavigation["label"]) | undefined;
   /** Stacks the destinations in a column, for a sidebar, where unset is a row
 for a header or a footer. The marker follows the current destination down
@@ -7336,6 +7738,9 @@ export type HelixHeadlessNotificationGroupHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixHeadlessNotificationGroupHelixBeforeOpenElementEvent =
   HelixHeadlessNotificationGroupElementEvent<HelixBeforeOpenEvent>;
+/** `toggle` event type */
+export type HelixHeadlessNotificationGroupToggleElementEvent =
+  HelixHeadlessNotificationGroupElementEvent<ToggleEvent>;
 
 export type HelixHeadlessNotificationGroupVueProps = {
   /** Whether the group can be collapsed to its first row.
@@ -7380,6 +7785,8 @@ export type HelixHeadlessNotificationGroupVueEvents = {
   "helix-before-close": HelixHeadlessNotificationGroupHelixBeforeCloseElementEvent;
   /** Fired before the group expands. Cancelable: cancel it to keep the group collapsed. */
   "helix-before-open": HelixHeadlessNotificationGroupHelixBeforeOpenElementEvent;
+  /** The group expanded or collapsed. The event carries `newState` and `oldState`. */
+  toggle: HelixHeadlessNotificationGroupToggleElementEvent;
 };
 
 /** `HelixHeadlessNotification` component event */
@@ -7424,6 +7831,16 @@ as a hydration mismatch, and which a copy of the serialized element
 re-parses as a declaration. `:state(read)` is what the stylesheet reads.
 `hydration.dom.spec.ts` holds it. */
   read?: (HelixHeadlessNotification["read"]) | undefined;
+  /** What a screen reader hears before an unread notification's text.
+
+The unread mark is drawn, so a reader who cannot see it hears this word in
+its place. Translate it with the rest of your interface. */
+  "unread-label"?: (HelixHeadlessNotification["unreadLabel"]) | undefined;
+  /** What a screen reader hears before an unread notification's text.
+
+The unread mark is drawn, so a reader who cannot see it hears this word in
+its place. Translate it with the rest of your interface. */
+  unreadLabel?: (HelixHeadlessNotification["unreadLabel"]) | undefined;
   /** Whether the element shows a control that dismisses it. */
   dismissible?: (HelixHeadlessNotification["dismissible"]) | undefined;
   /** The dismiss control's label, read by screen readers.
@@ -7548,6 +7965,13 @@ Ten steps, which is the convention every spinner on the platform follows,
 and a property because ten of a step of `0.01` is a hundredth and rarely
 what a reader wants from a whole key. */
   largeStep?: (HelixHeadlessNumberInput["largeStep"]) | undefined;
+  /** The locale a typed number is read in, such as `de-DE`. Empty reads it in
+the browser's language.
+
+Where the locale writes a decimal comma, `1,5` is read as one and a half,
+which is what the decimal keypad on a phone in that locale types. A dot is
+read as a decimal point in every locale. */
+  locale?: (HelixHeadlessNumberInput["locale"]) | undefined;
   /** The largest value allowed.
 
 Absent has no ceiling. */
@@ -7585,8 +8009,29 @@ been asked for. Where it earns its place is a value a reader tunes rather
 than states: a duration, a weight, a count they are looking for rather than
 one they already know. */
   scrub?: (HelixHeadlessNumberInput["scrub"]) | undefined;
-  /** How far one step moves. */
+  /** How far one step moves. A value off the step grid, counted from `min`, is
+invalid, as it is 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. */
+  "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. */
+  stepMismatchMessage?: (HelixHeadlessNumberInput["stepMismatchMessage"]) | undefined;
+  /** What a screen reader says for the value, with `{value}` filled in, such as
+`{value} kilograms`.
+
+A unit slotted into `end` is drawn beside the number and is not part of
+what the spinbutton announces, so it goes here too. Empty announces the
+number alone. */
+  "value-text"?: (HelixHeadlessNumberInput["valueText"]) | undefined;
+  /** What a screen reader says for the value, with `{value}` filled in, such as
+`{value} kilograms`.
+
+A unit slotted into `end` is drawn beside the number and is not part of
+what the spinbutton announces, so it goes here too. Empty announces the
+number alone. */
+  valueText?: (HelixHeadlessNumberInput["valueText"]) | undefined;
   /** The value the control starts with. A form reset returns it to this value. */
   "default-value"?: (HelixHeadlessNumberInput["defaultValue"]) | undefined;
   /** The value the control starts with. A form reset returns it to this value. */
@@ -7599,9 +8044,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixHeadlessNumberInput["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessNumberInput["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessNumberInput["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessNumberInput["feedback"]) | undefined;
@@ -7719,6 +8162,22 @@ 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. */
+  "item-label"?: (HelixHeadlessObjectInspector["itemLabel"]) | undefined;
+  /** How an array of one entry counts it. `{count}` is replaced with the count. */
+  itemLabel?: (HelixHeadlessObjectInspector["itemLabel"]) | undefined;
+  /** How an array of any other number of entries counts them. `{count}` is replaced with the count. */
+  "items-label"?: (HelixHeadlessObjectInspector["itemsLabel"]) | undefined;
+  /** How an array of any other number of entries counts them. `{count}` is replaced with the count. */
+  itemsLabel?: (HelixHeadlessObjectInspector["itemsLabel"]) | undefined;
+  /** How an object of one key counts it. `{count}` is replaced with the count. */
+  "key-label"?: (HelixHeadlessObjectInspector["keyLabel"]) | undefined;
+  /** How an object of one key counts it. `{count}` is replaced with the count. */
+  keyLabel?: (HelixHeadlessObjectInspector["keyLabel"]) | undefined;
+  /** How an object of any other number of keys counts them. `{count}` is replaced with the count. */
+  "keys-label"?: (HelixHeadlessObjectInspector["keysLabel"]) | undefined;
+  /** How an object of any other number of keys counts them. `{count}` is replaced with the count. */
+  keysLabel?: (HelixHeadlessObjectInspector["keysLabel"]) | undefined;
   /** Accessible name for the tree, and the text of the header where there is one. */
   label?: (HelixHeadlessObjectInspector["label"]) | undefined;
   /** Hides the copy button.
@@ -7745,6 +8204,12 @@ 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;
+  /** The tree's accessible name when `label` is empty and the host names it
+with neither `aria-label` nor `aria-labelledby`. */
+  "tree-label"?: (HelixHeadlessObjectInspector["treeLabel"]) | undefined;
+  /** The tree's accessible name when `label` is empty and the host names it
+with neither `aria-label` nor `aria-labelledby`. */
+  treeLabel?: (HelixHeadlessObjectInspector["treeLabel"]) | undefined;
   /** Whether to draw only the rows in view.
 
 For a value of thousands of entries. Reflected, because the box it scrolls
@@ -7781,11 +8246,15 @@ export type HelixHeadlessOptionHelixSelectElementEvent =
 export type HelixHeadlessOptionVueProps = {
   /** Whether this is the option the keyboard is on.
 
-Written by the listbox. */
+Written by the listbox, which writes it once a reader moves the highlight.
+It shows as `:state(active)`, and as a `data-active` attribute for the
+stylesheets written before the state existed. */
   "data-active"?: (HelixHeadlessOption["active"]) | undefined;
   /** Whether this is the option the keyboard is on.
 
-Written by the listbox. */
+Written by the listbox, which writes it once a reader moves the highlight.
+It shows as `:state(active)`, and as a `data-active` attribute for the
+stylesheets written before the state existed. */
   active?: (HelixHeadlessOption["active"]) | undefined;
   /** A second destination for the row, opened when you choose it with the
 modifier key held.
@@ -7943,6 +8412,9 @@ export type HelixHeadlessPaginationElementEvent<E = Event> = TypedEvent<
   HelixHeadlessPagination,
   E
 >;
+/** `helix-activate` event type */
+export type HelixHeadlessPaginationHelixActivateElementEvent =
+  HelixHeadlessPaginationElementEvent<HelixActivateEvent>;
 /** `helix-navigate` event type */
 export type HelixHeadlessPaginationHelixNavigateElementEvent =
   HelixHeadlessPaginationElementEvent<HelixNavigateEvent>;
@@ -8090,7 +8562,9 @@ to a reader, and takes its own. */
 };
 
 export type HelixHeadlessPaginationVueEvents = {
-  /** Fired before the page changes, and cancelable. Canceling it is the only way to stop a page change. */
+  /** Fired after the page changes, with the new page as a string in `detail.value`. In `href` mode it comes a task after the click, once the page has moved. */
+  "helix-activate": HelixHeadlessPaginationHelixActivateElementEvent;
+  /** Fired before the page changes, and cancelable. Canceling it is the only way to stop a page change. `detail.page` is the page asked for, as a number, and `detail.value` is the same page as a string. */
   "helix-navigate": HelixHeadlessPaginationHelixNavigateElementEvent;
 };
 
@@ -8129,8 +8603,12 @@ Reading gives the real one; writing declares it the consumer's, and
 };
 
 export type HelixHeadlessPaginationSizeVueEvents = {
+  /** Fired after the size changes. */
+  change: HelixHeadlessPaginationSizeElementEvent;
   /** Fired before the size changes, and cancelable. Canceling it is the only way to stop a size change. */
   "helix-before-change": HelixHeadlessPaginationSizeHelixBeforeChangeElementEvent;
+  /** Fired after the size changes, with `change`. */
+  input: HelixHeadlessPaginationSizeElementEvent;
 };
 
 export type HelixHeadlessPaginationSummaryVueProps = {
@@ -8246,9 +8724,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixHeadlessPinInput["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessPinInput["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessPinInput["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessPinInput["feedback"]) | undefined;
@@ -8327,6 +8803,9 @@ export type HelixHeadlessPopoverHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixHeadlessPopoverHelixBeforeOpenElementEvent =
   HelixHeadlessPopoverElementEvent<HelixBeforeOpenEvent>;
+/** `toggle` event type */
+export type HelixHeadlessPopoverToggleElementEvent =
+  HelixHeadlessPopoverElementEvent<ToggleEvent>;
 
 export type HelixHeadlessPopoverVueProps = {
   /** The panel's name, read by screen readers. */
@@ -8362,7 +8841,7 @@ export type HelixHeadlessPopoverVueEvents = {
   /** Fired before it opens, and cancelable. */
   "helix-before-open": HelixHeadlessPopoverHelixBeforeOpenElementEvent;
   /** Fired after the panel opens or closes, with `newState` and `oldState`. */
-  toggle: HelixHeadlessPopoverElementEvent;
+  toggle: HelixHeadlessPopoverToggleElementEvent;
 };
 
 export type HelixHeadlessProgressVueProps = {
@@ -8381,8 +8860,17 @@ place in the layout when the answer arrives and it becomes determinate. */
   indeterminate?: (HelixHeadlessProgress["indeterminate"]) | undefined;
   /** Accessible name for what is in progress. */
   label?: (HelixHeadlessProgress["label"]) | undefined;
+  /** The locale the percentage is written in, such as `fr` for `72 %`.
+
+Absent uses the runtime's own. */
+  locale?: (HelixHeadlessProgress["locale"]) | undefined;
   /** The total the work is measured against. */
   max?: (HelixHeadlessProgress["max"]) | undefined;
+  /** Where the work starts, in the same units as `max`. Defaults to zero.
+
+For a measure that does not start at nothing, such as a migration from
+version 12 to version 20, where 12 is the empty bar. */
+  min?: (HelixHeadlessProgress["min"]) | undefined;
   /** Whether the value is drawn as a bar or as a ring.
 
 **On this tier because it changes the markup**, which is the headless tier's to
@@ -8419,7 +8907,7 @@ saying "uploading" while the bar runs. */
   showValue?: (HelixHeadlessProgress["showValue"]) | undefined;
   /** What has been done so far, in the same units as `max`.
 
-Clamped between zero and `max` for both the fill and the announcement, so
+Clamped between `min` and `max` for both the fill and the announcement, so
 the two can never disagree about what is on screen. */
   value?: (HelixHeadlessProgress["value"]) | undefined;
   /** Text that describes the value when the number alone is not enough, such as
@@ -8442,6 +8930,12 @@ report progress. */
 
 export type HelixHeadlessProgressVueEvents = {};
 
+/** `HelixHeadlessQrCode` component event */
+export type HelixHeadlessQrCodeElementEvent<E = Event> = TypedEvent<
+  HelixHeadlessQrCode,
+  E
+>;
+
 export type HelixHeadlessQrCodeVueProps = {
   /** The error correction level, which sets how much of the code can be lost
 and still scan.
@@ -8475,7 +8969,10 @@ which is what makes it read as dots rather than as a softened square code. */
   value?: (HelixHeadlessQrCode["value"]) | undefined;
 };
 
-export type HelixHeadlessQrCodeVueEvents = {};
+export type HelixHeadlessQrCodeVueEvents = {
+  /** The value is too long for a code at the correction level, so no code is drawn. */
+  error: HelixHeadlessQrCodeElementEvent;
+};
 
 export type HelixHeadlessQuoteVueProps = {
   /** URL identifying where the quotation came from. */
@@ -8518,9 +9015,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixHeadlessRadioGroup["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessRadioGroup["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessRadioGroup["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessRadioGroup["feedback"]) | undefined;
@@ -8575,6 +9070,16 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixHeadlessRadioGroup["name"]) | undefined;
+  /** Whether the group holds a tab stop of its own.
+
+A toolbar is one tab stop, so a toolbar the group sits in sets this to
+`false` while its stop is on another control, and every radio, the chosen
+one too, is then out of the tab order. The arrow keys inside the group
+work as before once focus is in it.
+
+No attribute: it is coordination between elements, and a consumer has no
+reason to set it. */
+  focusable?: (HelixHeadlessRadioGroup["focusable"]) | undefined;
 };
 
 export type HelixHeadlessRadioGroupVueEvents = {
@@ -8635,11 +9140,14 @@ name is the fault `TreeItem` avoids by mirroring to `data-selected`.
 Splitting them means moving what every stylesheet selects on, which is a
 change of its own rather than a property being added. */
   defaultSelected?: (HelixHeadlessRadio["defaultSelected"]) | undefined;
-  /** Whether the radio holds the group's tab stop while nothing is chosen.
+  /** Whether the radio holds the group's tab stop. Unset, the chosen radio
+holds it.
 
 The stop rides on the selection, and an unanswered group has no selection,
 so without this every choice is `tabindex="-1"` and the keyboard cannot
-enter the set at all.
+enter the set at all. The group writes `true` for the chosen radio, or for
+the first that can be chosen while nothing is, and `false` for every radio,
+the chosen one too, while a toolbar the group sits in holds the stop.
 
 **Written by the group, with no attribute, and it reaches the control
 rather than the host.** A `tabindex` on the host is two faults at once: it
@@ -8710,6 +9218,18 @@ read as `max`, which collapses the scale to its top score rather than
 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".
+
+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".
+
+Also what a read-only rating says for its score where `value-text` is
+empty. */
+  optionLabel?: (HelixHeadlessRating["optionLabel"]) | undefined;
   /** Shows the score without letting users change it.
 
 A readout is not a control that has been switched off. It takes no focus,
@@ -8773,9 +9293,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixHeadlessRating["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessRating["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessRating["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessRating["feedback"]) | undefined;
@@ -8877,6 +9395,12 @@ shadow root reads a table in that root rather than one in the document. A
 Absent falls back to the table's own caption, which is usually the right
 words and is already written. */
   label?: (HelixHeadlessScatterChart["label"]) | undefined;
+  /** 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. */
+  locale?: (HelixHeadlessScatterChart["locale"]) | undefined;
 };
 
 export type HelixHeadlessScatterChartVueEvents = {};
@@ -8904,6 +9428,12 @@ export type HelixHeadlessSelectHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixHeadlessSelectHelixBeforeOpenElementEvent =
   HelixHeadlessSelectElementEvent<HelixBeforeOpenEvent>;
+/** `helix-filter` event type */
+export type HelixHeadlessSelectHelixFilterElementEvent =
+  HelixHeadlessSelectElementEvent<HelixFilterEvent>;
+/** `toggle` event type */
+export type HelixHeadlessSelectToggleElementEvent =
+  HelixHeadlessSelectElementEvent<ToggleEvent>;
 
 export type HelixHeadlessSelectVueProps = {
   /** The text shown when no options match the filter. */
@@ -8958,9 +9488,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixHeadlessSelect["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessSelect["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessSelect["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessSelect["feedback"]) | undefined;
@@ -9033,13 +9561,21 @@ export type HelixHeadlessSelectVueEvents = {
   "helix-before-close": HelixHeadlessSelectHelixBeforeCloseElementEvent;
   /** Fired before the list opens. Cancelable: canceling it keeps the list closed and leaves the decision to you. */
   "helix-before-open": HelixHeadlessSelectHelixBeforeOpenElementEvent;
+  /** Fired as the user types in the filter field of a `filterable` select, with the text the list is filtered by. Cancelable: cancel it to leave the list unfiltered and filter the options yourself. */
+  "helix-filter": HelixHeadlessSelectHelixFilterElementEvent;
   /** Fired after the value changes. */
   input: HelixHeadlessSelectElementEvent;
   /** Fired after the list opens or closes, with `newState` and `oldState`. */
-  toggle: HelixHeadlessSelectElementEvent;
+  toggle: HelixHeadlessSelectToggleElementEvent;
 };
 
-export type HelixHeadlessSkeletonVueProps = {};
+export type HelixHeadlessSkeletonVueProps = {
+  /** What is loading, read out as the placeholder's name, such as "Loading
+profile".
+
+Absent hides the placeholder from screen readers. */
+  label?: (HelixHeadlessSkeleton["label"]) | undefined;
+};
 
 export type HelixHeadlessSkeletonVueEvents = {};
 
@@ -9135,6 +9671,12 @@ the two, since a range has no single number. */
   showValue?: (HelixHeadlessSlider["showValue"]) | undefined;
   /** How far one press of an arrow key moves the thumb. */
   step?: (HelixHeadlessSlider["step"]) | undefined;
+  /** What a screen reader says for a thumb's value, with `{value}` filled in,
+such as `{value} degrees`. Empty announces the number alone. */
+  "value-text"?: (HelixHeadlessSlider["valueText"]) | undefined;
+  /** What a screen reader says for a thumb's value, with `{value}` filled in,
+such as `{value} degrees`. Empty announces the number alone. */
+  valueText?: (HelixHeadlessSlider["valueText"]) | undefined;
   /** The value the control starts with. A form reset returns it to this value. */
   "default-value"?: (HelixHeadlessSlider["defaultValue"]) | undefined;
   /** The value the control starts with. A form reset returns it to this value. */
@@ -9147,9 +9689,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixHeadlessSlider["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessSlider["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessSlider["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessSlider["feedback"]) | undefined;
@@ -9261,8 +9801,8 @@ than announced without a name. */
   label?: (HelixHeadlessSparkline["label"]) | undefined;
   /** What the readings are drawn as.
 
-Absent is a line, `area` is a line with the region beneath it washed, and
-`bar` is a column per reading.
+Absent is `area`, a line with the region beneath it washed. `line` is the
+bare stroke, and `bar` is a column per reading.
 
 **A bar plot measures from zero and the other two measure from the data's
 own range**, which is the one way the plots are not interchangeable. A line
@@ -9289,10 +9829,10 @@ is markup, the same reason `curve` lives here. */
   plot?: (HelixHeadlessSparkline["plot"]) | undefined;
   /** The numbers, separated by whitespace or by commas.
 
-Both separators, so `values="1240 1318"` and an array assigned to the
-property both work: assigning `[1240, 1318]` stringifies to `1240,1318`,
-and a string is what survives React's hydration where an array property
-does not. */
+An array assigned to the property works too, which is what React 19 does
+with `values={[1240, 1318]}`. The attribute is the form to prefer, because
+a string is what survives React's hydration where an array property does
+not. */
   values?: (HelixHeadlessSparkline["values"]) | undefined;
 };
 
@@ -9333,6 +9873,9 @@ export type HelixHeadlessSpeedDialHelixBeforeOpenElementEvent =
 /** `helix-select` event type */
 export type HelixHeadlessSpeedDialHelixSelectElementEvent =
   HelixHeadlessSpeedDialElementEvent<HelixSelectEvent>;
+/** `toggle` event type */
+export type HelixHeadlessSpeedDialToggleElementEvent =
+  HelixHeadlessSpeedDialElementEvent<ToggleEvent>;
 
 export type HelixHeadlessSpeedDialVueProps = {
   /** Accessible name for the trigger and the set of actions it opens. */
@@ -9372,7 +9915,7 @@ export type HelixHeadlessSpeedDialVueEvents = {
   /** An action was chosen. The action sends the event, and the dial closes after it. Cancelable: cancel it to keep the dial open. */
   "helix-select": HelixHeadlessSpeedDialHelixSelectElementEvent;
   /** The dial opened or closed. The event carries `newState` and `oldState`. */
-  toggle: HelixHeadlessSpeedDialElementEvent;
+  toggle: HelixHeadlessSpeedDialToggleElementEvent;
 };
 
 /** `HelixHeadlessSplitter` component event */
@@ -9386,6 +9929,12 @@ export type HelixHeadlessSplitterHelixBeforeCollapseElementEvent =
 /** `helix-before-resize` event type */
 export type HelixHeadlessSplitterHelixBeforeResizeElementEvent =
   HelixHeadlessSplitterElementEvent<HelixBeforeResizeEvent>;
+/** `helix-collapse` event type */
+export type HelixHeadlessSplitterHelixCollapseElementEvent =
+  HelixHeadlessSplitterElementEvent<HelixCollapseEvent>;
+/** `helix-resized` event type */
+export type HelixHeadlessSplitterHelixResizedElementEvent =
+  HelixHeadlessSplitterElementEvent<HelixResizedEvent>;
 
 export type HelixHeadlessSplitterVueProps = {
   /** Which pane is shut, if either.
@@ -9440,7 +9989,10 @@ consumer's to set. */
   "default-position"?: (HelixHeadlessSplitter["defaultPosition"] | `${number}`) | undefined;
   /** Where the divider starts, when `position` is not set. */
   defaultPosition?: (HelixHeadlessSplitter["defaultPosition"]) | undefined;
-  /** The divider's name, read by screen readers. */
+  /** The divider's name, read by screen readers.
+
+An `aria-label` or `aria-labelledby` on the host names the divider too,
+and wins over this. */
   label?: (HelixHeadlessSplitter["label"]) | undefined;
   /** How close the divider can come to the end, in the same units as `min`. */
   max?: (HelixHeadlessSplitter["max"]) | undefined;
@@ -9502,6 +10054,10 @@ export type HelixHeadlessSplitterVueEvents = {
   "helix-before-collapse": HelixHeadlessSplitterHelixBeforeCollapseElementEvent;
   /** Fired before the divider settles, and only when the gesture moved it. A press that moved nothing, a drag that came back, an arrow key with no room left, and a corner that moved only the other divider do not fire it. Cancelable: canceling it leaves the position to you and keeps the rest of the gesture, so a collapse the gesture reached still fires `helix-before-collapse`, which you can also cancel. A dragged divider stays where it was dropped until you set your own `position`. */
   "helix-before-resize": HelixHeadlessSplitterHelixBeforeResizeElementEvent;
+  /** Fired after a pane shuts or reopens, with the side that is shut, or empty where both are open. */
+  "helix-collapse": HelixHeadlessSplitterHelixCollapseElementEvent;
+  /** Fired after the divider settles somewhere new, with the new position. */
+  "helix-resized": HelixHeadlessSplitterHelixResizedElementEvent;
 };
 
 export type HelixHeadlessStatGroupVueProps = {
@@ -9526,6 +10082,11 @@ A property rather than a `Flex` around it, because the unit has to stay on
 the value's baseline whichever way the pair goes, and only this element
 knows which of its children the unit belongs to.
 
+**`Trend` has a `direction` too, and there it means which way a number
+moved:** `up`, `down` or `neutral`. A Stat and a Trend are often written
+side by side, so watch for the mix-up. On a Stat those three words are not
+layouts, and the pair stays the column.
+
 **Optional rather than defaulted to `column`, which is not a style
 preference.** A reflecting property with a default writes its attribute onto
 the host the moment the element upgrades, and the host is markup the
@@ -9661,9 +10222,7 @@ stylesheets. */
   /** Whether the control starts checked. A form reset returns it to this state. */
   defaultChecked?: (HelixHeadlessSwitch["defaultChecked"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessSwitch["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessSwitch["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessSwitch["feedback"]) | undefined;
@@ -9730,7 +10289,8 @@ export type HelixHeadlessSwitchVueEvents = {
 };
 
 export type HelixHeadlessTableCellVueProps = {
-  /** Whether the cell is the header cell of its column. */
+  /** Whether the cell is a header: of its row in a row of values, and of its
+column in a row of headers alone. */
   header?: (HelixHeadlessTableCell["header"]) | undefined;
 };
 
@@ -9914,7 +10474,20 @@ export type HelixHeadlessTableColumnVueEvents = {
   "helix-before-resize": HelixHeadlessTableColumnHelixBeforeResizeElementEvent;
 };
 
+/** `HelixHeadlessTable` component event */
+export type HelixHeadlessTableElementEvent<E = Event> = TypedEvent<
+  HelixHeadlessTable,
+  E
+>;
+/** `helix-sort` event type */
+export type HelixHeadlessTableHelixSortElementEvent =
+  HelixHeadlessTableElementEvent<HelixSortEvent>;
+
 export type HelixHeadlessTableVueProps = {
+  /** The word for an ascending sort, in `sorted-label`. */
+  "ascending-label"?: (HelixHeadlessTable["ascendingLabel"]) | undefined;
+  /** The word for an ascending sort, in `sorted-label`. */
+  ascendingLabel?: (HelixHeadlessTable["ascendingLabel"]) | 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
@@ -9944,8 +10517,37 @@ and a list here would be a second way to say what that says. This table's
 cells are markup, and a table written as rows of cells with no column
 declared in it has nowhere else to be sized from. */
   columns?: (HelixHeadlessTable["columns"]) | undefined;
-  /** Accessible name for the table. */
+  /** The starting sort order, used until `sort` 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`. */
+  "descending-label"?: (HelixHeadlessTable["descendingLabel"]) | undefined;
+  /** The word for a descending sort, in `sorted-label`. */
+  descendingLabel?: (HelixHeadlessTable["descendingLabel"]) | 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;
+  /** The sort order, as `field:direction`, where `field` is a sortable column's
+`field`.
+
+The rows are compared by the text of their cells in that column, numbers by
+their value. A reader's click on a sortable heading fires `helix-sort`
+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`. */
+  "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`. */
+  sortedLabel?: (HelixHeadlessTable["sortedLabel"]) | undefined;
+  /** What screen readers hear when the table stops being sorted. */
+  "unsorted-label"?: (HelixHeadlessTable["unsortedLabel"]) | undefined;
+  /** What screen readers hear when the table stops being sorted. */
+  unsortedLabel?: (HelixHeadlessTable["unsortedLabel"]) | undefined;
   /** The text shown and announced when there are no rows and none are loading. */
   "empty-text"?: (HelixHeadlessTable["emptyText"]) | undefined;
   /** The text shown and announced when there are no rows and none are loading. */
@@ -9962,7 +10564,10 @@ say that without the component knowing what a row looks like. */
   loadingText?: (HelixHeadlessTable["loadingText"]) | undefined;
 };
 
-export type HelixHeadlessTableVueEvents = {};
+export type HelixHeadlessTableVueEvents = {
+  /** A different sort order was requested, as `field:direction`, or empty for the order the rows were written in. Cancelable: cancel it to keep the current order. */
+  "helix-sort": HelixHeadlessTableHelixSortElementEvent;
+};
 
 export type HelixHeadlessTableRowVueProps = {};
 
@@ -10005,7 +10610,10 @@ export type HelixHeadlessTabsHelixSelectElementEvent =
   HelixHeadlessTabsElementEvent<HelixSelectEvent>;
 
 export type HelixHeadlessTabsVueProps = {
-  /** The tab list's name, read by screen readers. */
+  /** The tab list's name, read by screen readers.
+
+An `aria-label` or `aria-labelledby` on the host names the tab list too,
+and wins over this. */
   label?: (HelixHeadlessTabs["label"]) | undefined;
   /** Stops the arrow keys from selecting each tab they move to. By default,
 arrowing to a tab also selects it.
@@ -10216,9 +10824,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixHeadlessTextarea["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessTextarea["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessTextarea["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessTextarea["feedback"]) | undefined;
@@ -10314,6 +10920,9 @@ export type HelixHeadlessTimeInputHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixHeadlessTimeInputHelixBeforeOpenElementEvent =
   HelixHeadlessTimeInputElementEvent<HelixBeforeOpenEvent>;
+/** `toggle` event type */
+export type HelixHeadlessTimeInputToggleElementEvent =
+  HelixHeadlessTimeInputElementEvent<ToggleEvent>;
 
 export type HelixHeadlessTimeInputVueProps = {
   /** What the browser may autofill here, as one of the platform's own tokens.
@@ -10321,6 +10930,16 @@ export type HelixHeadlessTimeInputVueProps = {
 Empty leaves the attribute off, which is the browser's default and is what
 lets autofill work at all. */
   autocomplete?: (HelixHeadlessTimeInput["autocomplete"]) | undefined;
+  /** Times that cannot be chosen, as `HH:mm`, separated by commas or spaces.
+
+Handed to the list, which offers them as unavailable, and checked against
+a typed time, which is then invalid. */
+  "disable-times"?: (HelixHeadlessTimeInput["disableTimes"]) | undefined;
+  /** Times that cannot be chosen, as `HH:mm`, separated by commas or spaces.
+
+Handed to the list, which offers them as unavailable, and checked against
+a typed time, which is then invalid. */
+  disableTimes?: (HelixHeadlessTimeInput["disableTimes"]) | undefined;
   /** Language tag the times are written in.
 
 Absent uses the runtime's own. */
@@ -10394,6 +11013,10 @@ never something this element would refuse to read back. */
   "trigger-label"?: (HelixHeadlessTimeInput["triggerLabel"]) | undefined;
   /** The name of the button that opens the list, read by screen readers. */
   triggerLabel?: (HelixHeadlessTimeInput["triggerLabel"]) | undefined;
+  /** The message shown when `disable-times` bars a time. */
+  "unavailable-message"?: (HelixHeadlessTimeInput["unavailableMessage"]) | undefined;
+  /** The message shown when `disable-times` bars a time. */
+  unavailableMessage?: (HelixHeadlessTimeInput["unavailableMessage"]) | undefined;
   /** Whether the panel shows one list of times or a column for each part of the
 time.
 
@@ -10494,9 +11117,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixHeadlessTimeInput["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessTimeInput["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessTimeInput["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessTimeInput["feedback"]) | undefined;
@@ -10576,7 +11197,7 @@ export type HelixHeadlessTimeInputVueEvents = {
   /** Fired after the value changes. */
   input: HelixHeadlessTimeInputElementEvent;
   /** Fired after the list opens or closes, with `newState` and `oldState`. */
-  toggle: HelixHeadlessTimeInputElementEvent;
+  toggle: HelixHeadlessTimeInputToggleElementEvent;
 };
 
 /** `HelixHeadlessTimePicker` component event */
@@ -10601,7 +11222,7 @@ speaks it. Absent is the control's own sentence, in English. */
 named for the validity flag it reports, so a form in another language
 speaks it. Absent is the control's own sentence, in English. */
   badInputMessage?: (HelixHeadlessTimePicker["badInputMessage"]) | undefined;
-  /** Times that cannot be chosen, comma separated, as `HH:mm`.
+  /** Times that cannot be chosen, as `HH:mm`, separated by commas or spaces.
 
 The counterpart to Date Picker's `disable-dates`, and it exists for the same
 shape of problem: `min` and `max` take away a span, and what a booking
@@ -10612,7 +11233,7 @@ A time not on the step is simply never offered, so it is not an error to
 name one, and naming every time in the list is how the empty state is
 reached honestly rather than by handing over an empty range. */
   "disable-times"?: (HelixHeadlessTimePicker["disableTimes"]) | undefined;
-  /** Times that cannot be chosen, comma separated, as `HH:mm`.
+  /** Times that cannot be chosen, as `HH:mm`, separated by commas or spaces.
 
 The counterpart to Date Picker's `disable-dates`, and it exists for the same
 shape of problem: `min` and `max` take away a span, and what a booking
@@ -10623,6 +11244,10 @@ A time not on the step is simply never offered, so it is not an error to
 name one, and naming every time in the list is how the empty state is
 reached honestly rather than by handing over an empty range. */
   disableTimes?: (HelixHeadlessTimePicker["disableTimes"]) | undefined;
+  /** What the wheel of hours is called, read by screen readers. */
+  "hour-label"?: (HelixHeadlessTimePicker["hourLabel"]) | undefined;
+  /** What the wheel of hours is called, read by screen readers. */
+  hourLabel?: (HelixHeadlessTimePicker["hourLabel"]) | undefined;
   /** Whether the current selection fails validation.
 
 A flag rather than a message, the same split Date Picker draws. A flat
@@ -10631,16 +11256,34 @@ the label, the hint and the feedback, and a second message inside the panel
 would be the same error said twice. What is left for the picker is the one
 thing the field cannot draw from outside, the mark on the answer itself. */
   invalid?: (HelixHeadlessTimePicker["invalid"]) | undefined;
-  /** Accessible name for the list, which has no visible one of its own. */
+  /** Accessible name for the list, which has no visible one of its own.
+
+An `aria-label` or `aria-labelledby` on the host names the list instead. */
   label?: (HelixHeadlessTimePicker["label"]) | undefined;
   /** Language tag the times are written in.
 
 Absent uses the runtime's own. */
   locale?: (HelixHeadlessTimePicker["locale"]) | undefined;
+  /** Stops the arrow keys in the list from choosing each time they move to.
+Enter, Space or a click chooses.
+
+Time Input sets it, so a reader moves through the list before the panel
+closes on a time. */
+  manual?: (HelixHeadlessTimePicker["manual"]) | undefined;
   /** Latest time offered, as `HH:mm`. */
   max?: (HelixHeadlessTimePicker["max"]) | undefined;
+  /** What the wheel of the half of the day is called, read by screen readers.
+Its two options are written as the locale writes them, such as AM and PM. */
+  "meridiem-label"?: (HelixHeadlessTimePicker["meridiemLabel"]) | undefined;
+  /** What the wheel of the half of the day is called, read by screen readers.
+Its two options are written as the locale writes them, such as AM and PM. */
+  meridiemLabel?: (HelixHeadlessTimePicker["meridiemLabel"]) | undefined;
   /** Earliest time offered, as `HH:mm`. */
   min?: (HelixHeadlessTimePicker["min"]) | undefined;
+  /** What the wheel of minutes is called, read by screen readers. */
+  "minute-label"?: (HelixHeadlessTimePicker["minuteLabel"]) | undefined;
+  /** What the wheel of minutes is called, read by screen readers. */
+  minuteLabel?: (HelixHeadlessTimePicker["minuteLabel"]) | undefined;
   /** How many times can be held at once.
 
 Absent is one. `range` holds a start and an end with everything between
@@ -10659,6 +11302,18 @@ and a wheel has exactly one value by construction. Rather than draw
 something that cannot say what it holds, `wheels` renders as a list
 whenever a mode is set. */
   mode?: (HelixHeadlessTimePicker["mode"]) | undefined;
+  /** The validation message for a time after `max`. `{max}` is replaced with
+`max`, written in `locale`. */
+  "range-overflow-message"?: (HelixHeadlessTimePicker["rangeOverflowMessage"]) | undefined;
+  /** The validation message for a time after `max`. `{max}` is replaced with
+`max`, written in `locale`. */
+  rangeOverflowMessage?: (HelixHeadlessTimePicker["rangeOverflowMessage"]) | undefined;
+  /** The validation message for a time before `min`. `{min}` is replaced with
+`min`, written in `locale`. */
+  "range-underflow-message"?: (HelixHeadlessTimePicker["rangeUnderflowMessage"]) | undefined;
+  /** The validation message for a time before `min`. `{min}` is replaced with
+`min`, written in `locale`. */
+  rangeUnderflowMessage?: (HelixHeadlessTimePicker["rangeUnderflowMessage"]) | undefined;
   /** Blocks changes to the time. The value is still submitted with the form.
 
 **Enforced by refusing every request in one place**, which is the seam this
@@ -10691,6 +11346,14 @@ Fifteen, which is four rows an hour and ninety-six in a day: enough that a
 reader scrolls rather than hunts, and few enough that the list is a list.
 Anything under five is a thousand rows and wants a field instead. */
   step?: (HelixHeadlessTimePicker["step"]) | undefined;
+  /** The validation message for a time that `step` skips. */
+  "step-mismatch-message"?: (HelixHeadlessTimePicker["stepMismatchMessage"]) | undefined;
+  /** The validation message for a time that `step` skips. */
+  stepMismatchMessage?: (HelixHeadlessTimePicker["stepMismatchMessage"]) | undefined;
+  /** The validation message for a time that `disable-times` bars. */
+  "unavailable-message"?: (HelixHeadlessTimePicker["unavailableMessage"]) | undefined;
+  /** The validation message for a time that `disable-times` bars. */
+  unavailableMessage?: (HelixHeadlessTimePicker["unavailableMessage"]) | undefined;
   /** The validation message for a required time picker with no time chosen. */
   "value-missing-message"?: (HelixHeadlessTimePicker["valueMissingMessage"]) | undefined;
   /** The validation message for a required time picker with no time chosen. */
@@ -10954,9 +11617,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixHeadlessToggleGroup["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixHeadlessToggleGroup["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixHeadlessToggleGroup["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixHeadlessToggleGroup["feedback"]) | undefined;
@@ -11011,12 +11672,22 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixHeadlessToggleGroup["name"]) | undefined;
+  /** Whether the group holds a tab stop of its own.
+
+A toolbar is one tab stop, so a toolbar the group sits in sets this to
+`false` while its stop is on another control, and every item, the chosen
+one too, is then out of the tab order. The arrow keys inside the group
+work as before once focus is in it.
+
+No attribute: it is coordination between elements, and a consumer has no
+reason to set it. */
+  focusable?: (HelixHeadlessToggleGroup["focusable"]) | undefined;
 };
 
 export type HelixHeadlessToggleGroupVueEvents = {
   /** Fired after the value changes. */
   change: HelixHeadlessToggleGroupElementEvent;
-  /** Fired before the choice changes. Cancelable: call `preventDefault()` to keep the current choice. It is the only way to block a change. */
+  /** Fired before the choice changes. Cancelable: call `preventDefault()` to keep the current choice. */
   "helix-before-change": HelixHeadlessToggleGroupHelixBeforeChangeElementEvent;
   /** Fired when an item is chosen. The item sends it, and you listen for it on the group. Cancelable: call `preventDefault()` to keep the current choice. */
   "helix-select": HelixHeadlessToggleGroupHelixSelectElementEvent;
@@ -11071,13 +11742,15 @@ name is the fault `TreeItem` avoids by mirroring to `data-selected`.
 Splitting them means moving what every stylesheet selects on, which is a
 change of its own rather than a property being added. */
   defaultSelected?: (HelixHeadlessToggle["defaultSelected"]) | undefined;
-  /** Whether the item holds the group's tab stop while nothing is chosen.
+  /** Whether the item holds the group's tab stop. Unset, the chosen item holds
+it.
 
-The stop normally rides on the selection, and an unanswered group has no
-selection, so without this the keyboard cannot reach it. Written by the
-group, with no attribute: it is coordination between elements, and
-`tabindex` on a host the consumer rendered is the change a React consumer's
-hydration reports and does not patch up. */
+Written by the group on every item: `true` for the chosen item, or for the
+first item that can be chosen while there is no selection to carry the
+stop, and `false` for every item, the chosen one too, while a toolbar the
+group sits in holds the stop. No attribute: it is coordination between
+elements, and `tabindex` on a host the consumer rendered is the change a
+React consumer's hydration reports and does not patch up. */
   focusable?: (HelixHeadlessToggle["focusable"]) | undefined;
 };
 
@@ -11087,7 +11760,10 @@ export type HelixHeadlessToggleVueEvents = {
 };
 
 export type HelixHeadlessToolbarVueProps = {
-  /** The toolbar's name, read by screen readers. */
+  /** The toolbar's name, read by screen readers.
+
+An `aria-label` or `aria-labelledby` on the host names the toolbar too,
+and wins over this. */
   label?: (HelixHeadlessToolbar["label"]) | undefined;
   /** The direction the arrow keys move focus in. */
   orientation?: (HelixHeadlessToolbar["orientation"]) | undefined;
@@ -11106,6 +11782,9 @@ export type HelixHeadlessTooltipHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixHeadlessTooltipHelixBeforeOpenElementEvent =
   HelixHeadlessTooltipElementEvent<HelixBeforeOpenEvent>;
+/** `toggle` event type */
+export type HelixHeadlessTooltipToggleElementEvent =
+  HelixHeadlessTooltipElementEvent<ToggleEvent>;
 
 export type HelixHeadlessTooltipVueProps = {
   /** The text shown in the bubble.
@@ -11212,7 +11891,7 @@ export type HelixHeadlessTooltipVueEvents = {
   /** The bubble is about to show. Cancelable: cancel it to keep it hidden. */
   "helix-before-open": HelixHeadlessTooltipHelixBeforeOpenElementEvent;
   /** The bubble opened or closed. The event carries `newState` and `oldState`. */
-  toggle: HelixHeadlessTooltipElementEvent;
+  toggle: HelixHeadlessTooltipToggleElementEvent;
 };
 
 /** `HelixHeadlessTour` component event */
@@ -11220,18 +11899,27 @@ export type HelixHeadlessTourElementEvent<E = Event> = TypedEvent<
   HelixHeadlessTour,
   E
 >;
+/** `helix-activate` event type */
+export type HelixHeadlessTourHelixActivateElementEvent =
+  HelixHeadlessTourElementEvent<HelixActivateEvent>;
 /** `helix-before-activate` event type */
 export type HelixHeadlessTourHelixBeforeActivateElementEvent =
   HelixHeadlessTourElementEvent<HelixBeforeActivateEvent>;
 /** `helix-before-close` event type */
 export type HelixHeadlessTourHelixBeforeCloseElementEvent =
   HelixHeadlessTourElementEvent<HelixBeforeCloseEvent>;
+/** `helix-before-open` event type */
+export type HelixHeadlessTourHelixBeforeOpenElementEvent =
+  HelixHeadlessTourElementEvent<HelixBeforeOpenEvent>;
 /** `helix-complete` event type */
 export type HelixHeadlessTourHelixCompleteElementEvent =
   HelixHeadlessTourElementEvent<HelixCompleteEvent>;
 /** `helix-tour-ask` event type */
 export type HelixHeadlessTourHelixTourAskElementEvent =
   HelixHeadlessTourElementEvent<HelixTourAskEvent>;
+/** `toggle` event type */
+export type HelixHeadlessTourToggleElementEvent =
+  HelixHeadlessTourElementEvent<ToggleEvent>;
 
 export type HelixHeadlessTourVueProps = {
   /** Label for the control that goes back, passed to every stop. */
@@ -11263,8 +11951,6 @@ The shape is `Carousel`'s, which is the nearest thing in the library: a
   "next-label"?: (HelixHeadlessTour["nextLabel"]) | undefined;
   /** Label for the control that goes on. */
   nextLabel?: (HelixHeadlessTour["nextLabel"]) | undefined;
-  /** Whether the tour is running. */
-  open?: (HelixHeadlessTour["open"]) | undefined;
   /** Label for the control that leaves the tour. */
   "skip-label"?: (HelixHeadlessTour["skipLabel"]) | undefined;
   /** Label for the control that leaves the tour. */
@@ -11273,17 +11959,40 @@ The shape is `Carousel`'s, which is the nearest thing in the library: a
   "spotlight-padding"?: (HelixHeadlessTour["spotlightPadding"] | `${number}`) | undefined;
   /** The space around the target inside the spotlight, in pixels. */
   spotlightPadding?: (HelixHeadlessTour["spotlightPadding"]) | undefined;
+  /** Whether the element starts open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessTour["defaultOpen"]) | undefined;
+  /** Whether the element starts open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessTour["defaultOpen"]) | undefined;
+  /** Whether the element is open.
+
+One property, not two, so `dialog.open` answers the question anyone
+asking it meant. Writing always applies; `<helix-dialog open>` is the
+same statement in markup.
+
+**Not reflected, and that is required rather than tidy.** Reflection
+writes the resolved state back as an attribute, so an element that opened
+itself would put `open` on its own host: cloned, serialized for
+hydration, or diffed by a framework, it comes back holding whatever the
+last reader did rather than what the author wrote. `:state(open)` carries
+the resolved state for stylesheets, which is what the mirror is for. */
+  open?: (HelixHeadlessTour["open"]) | undefined;
 };
 
 export type HelixHeadlessTourVueEvents = {
+  /** Fired after the current stop changes, with the new index. */
+  "helix-activate": HelixHeadlessTourHelixActivateElementEvent;
   /** Fired before the current stop changes, with the new index. Cancelable: call `preventDefault()` to stay on the current stop. */
   "helix-before-activate": HelixHeadlessTourHelixBeforeActivateElementEvent;
   /** Fired before the user ends the tour early. Cancelable: call `preventDefault()` to keep the tour open. */
   "helix-before-close": HelixHeadlessTourHelixBeforeCloseElementEvent;
+  /** Fired before `requestOpen(true)` starts the tour. Cancelable: call `preventDefault()` to keep it closed. */
+  "helix-before-open": HelixHeadlessTourHelixBeforeOpenElementEvent;
   /** Fired when the last stop is finished. */
   "helix-complete": HelixHeadlessTourHelixCompleteElementEvent;
   /** Fired when a stop's control is pressed to move the tour. The stop sends it, and the tour handles it. */
   "helix-tour-ask": HelixHeadlessTourHelixTourAskElementEvent;
+  /** Sent when the tour starts or ends, with `newState` and `oldState`. */
+  toggle: HelixHeadlessTourToggleElementEvent;
 };
 
 /** `HelixHeadlessTourStop` component event */
@@ -11349,6 +12058,9 @@ export type HelixHeadlessTreeItemHelixBeforeOpenElementEvent =
 /** `helix-select` event type */
 export type HelixHeadlessTreeItemHelixSelectElementEvent =
   HelixHeadlessTreeItemElementEvent<HelixSelectEvent>;
+/** `toggle` event type */
+export type HelixHeadlessTreeItemToggleElementEvent =
+  HelixHeadlessTreeItemElementEvent<ToggleEvent>;
 
 export type HelixHeadlessTreeItemVueProps = {
   /** The URL this node links to. Setting it makes the row a link.
@@ -11427,7 +12139,7 @@ export type HelixHeadlessTreeItemVueEvents = {
   /** Fired when the item is chosen, and cancelable. Canceling it changes nothing. */
   "helix-select": HelixHeadlessTreeItemHelixSelectElementEvent;
   /** Sent when the branch opens or closes, with `newState` and `oldState`. */
-  toggle: HelixHeadlessTreeItemElementEvent;
+  toggle: HelixHeadlessTreeItemToggleElementEvent;
 };
 
 /** `HelixHeadlessTree` component event */
@@ -11446,7 +12158,10 @@ export type HelixHeadlessTreeHelixSelectElementEvent =
   HelixHeadlessTreeElementEvent<HelixSelectEvent>;
 
 export type HelixHeadlessTreeVueProps = {
-  /** Accessible name for the tree. */
+  /** 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 a deeper level means: `peer` for no change, `subordinate` for a lower
 rank, or `heading` for a parent that heads the items under it.
@@ -11526,6 +12241,10 @@ export type HelixHeadlessTreeVueEvents = {
 };
 
 export type HelixHeadlessTrendVueProps = {
+  /** The word read out after the direction when the move is an improvement. */
+  "better-label"?: (HelixHeadlessTrend["betterLabel"]) | undefined;
+  /** The word read out after the direction when the move is an improvement. */
+  betterLabel?: (HelixHeadlessTrend["betterLabel"]) | undefined;
   /** Which way the measurement moved.
 
 Absent is neutral, so a trend with nothing to report draws a bar rather
@@ -11535,6 +12254,10 @@ attribute onto the host the moment the element upgrades, and the host is
 markup the consumer rendered, which React compares against what it rendered
 and reports as a hydration mismatch. */
   direction?: (HelixHeadlessTrend["direction"]) | undefined;
+  /** The word read out for a move down. */
+  "down-label"?: (HelixHeadlessTrend["downLabel"]) | undefined;
+  /** The word read out for a move down. */
+  downLabel?: (HelixHeadlessTrend["downLabel"]) | undefined;
   /** Which direction counts as an improvement for this metric.
 
 Absent states the movement without judging it, which is the honest default:
@@ -11542,6 +12265,20 @@ 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
 direction changes underneath. */
   good?: (HelixHeadlessTrend["good"]) | undefined;
+  /** The word read out for no move, or for a direction that is not one of the
+three. */
+  "unchanged-label"?: (HelixHeadlessTrend["unchangedLabel"]) | undefined;
+  /** The word read out for no move, or for a direction that is not one of the
+three. */
+  unchangedLabel?: (HelixHeadlessTrend["unchangedLabel"]) | undefined;
+  /** The word read out for a move up. */
+  "up-label"?: (HelixHeadlessTrend["upLabel"]) | undefined;
+  /** The word read out for a move up. */
+  upLabel?: (HelixHeadlessTrend["upLabel"]) | undefined;
+  /** The word read out after the direction when the move is a setback. */
+  "worse-label"?: (HelixHeadlessTrend["worseLabel"]) | undefined;
+  /** The word read out after the direction when the move is a setback. */
+  worseLabel?: (HelixHeadlessTrend["worseLabel"]) | undefined;
 };
 
 export type HelixHeadlessTrendVueEvents = {};
@@ -12025,7 +12762,10 @@ right whenever the rows really are one height and is the cheaper of the two. */
   /** The id of the script element that holds the rows as JSON. */
   for?: (HelixHeadlessVirtualList["for"]) | undefined;
   /** The list's name, read by screen readers, because only some of its rows
-are rendered at a time. */
+are rendered at a time.
+
+An `aria-label` or `aria-labelledby` on the host names the list too, and
+wins over this. */
   label?: (HelixHeadlessVirtualList["label"]) | undefined;
   /** Places rows by their measured height. Without it, every row is placed by
 `estimate`.
@@ -12169,25 +12909,25 @@ export type CustomCssProperties = {
 // Note: Some tooling expects this augmentation under "@vue/runtime-core", while
 // other docs/examples use "vue". We emit both for compatibility.
 export interface WcToolkitVueGlobalComponents {
-  /** Holds its own open state. Used alone, outside an accordion, it works as a disclosure.  Content stays mounted when the item is closed, so it can animate and its text is present in server-rendered HTML. Closed content has both 'hidden' and 'inert'. 'hidden' collapses it when no stylesheet is loaded. 'inert' keeps it out of the tab order and the accessibility tree after the styled tier's 'display' overrides 'hidden'. */
+  /** Holds its own open state. Used alone, outside an accordion, it works as a disclosure.  The trigger sits inside a heading, so a screen reader lists the section with the page's headings. The level is the item's 'heading-level', then the accordion's, then 3.  Content stays mounted when the item is closed, so it can animate and its text is present in server-rendered HTML. Closed content has both 'hidden' and 'inert'. 'hidden' collapses it when no stylesheet is loaded. 'inert' keeps it out of the tab order and the accessibility tree after the styled tier's 'display' overrides 'hidden'. */
   "helix-headless-accordion-item": DefineCustomElement<
     HelixHeadlessAccordionItem,
     HelixHeadlessAccordionItemVueProps,
     HelixHeadlessAccordionItemVueEvents
   >;
-  /** Holds the mode. Each item coordinates itself: when you click an item, it finds the nearest accordion, reads the mode, and closes the other items.  The accordion does not listen for items opening. 'helix-before-open' does not bubble and is not composed, because overlays nest and an inner overlay's events must stay separate from the outer one's.  Items are found when they are clicked, so there is no registry to keep up to date. An item added after render coordinates on its first click. Items are matched with 'instanceof HelixHeadlessAccordionItem', so the headless tier does not depend on the styled tier's tag names.  The keyboard listener belongs to the controller and is attached on connect, so it does not run on the server. */
+  /** Holds the mode. Each item coordinates itself: when you click an item, it finds the nearest accordion, reads the mode, and closes the other items.  The accordion does not listen for items opening. 'helix-before-open' does not bubble and is not composed, because overlays nest and an inner overlay's events must stay separate from the outer one's.  Items are found when they are clicked, so there is no registry to keep up to date. An item added after render coordinates on its first click. Items are matched with 'instanceof HelixHeadlessAccordionItem', so the headless tier does not depend on the styled tier's tag names.  The keyboard listener belongs to the controller and is attached on connect, so it does not run on the server.  Each trigger sits inside a heading, level 3 unless 'heading-level' says otherwise, so the sections are in a screen reader's list of headings. Set the level that fits the page's outline. */
   "helix-headless-accordion": DefineCustomElement<
     HelixHeadlessAccordion,
     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. When the announcement is in the served HTML, the region is filled at once 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()'. */
+  /** 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, so the message is not in the page twice. 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. */
   "helix-headless-announcement": DefineCustomElement<
     HelixHeadlessAnnouncement,
     HelixHeadlessAnnouncementVueProps,
     HelixHeadlessAnnouncementVueEvents
   >;
-  /** Tracks whether the page has scrolled and sets the custom state 'scrolled', so the styled tier can lift the bar without a scroll handler of its own. The state is read when the element connects. A fresh load starts at the top, which matches the server markup, and a reload partway down the page is corrected on hydration.  The element uses a custom state because an attribute such as 'data-scrolled', written onto its own host, is one the server did not send. A hydrating framework would report a mismatch whenever the page reloads far enough down. 'ElementInternals.states' is not in the DOM, so hydration has nothing to compare. Select the state with ':state(scrolled)'. */
+  /** Tracks whether the page has scrolled and sets the custom state 'scrolled', so the styled tier can lift the bar without a scroll handler of its own. The state is read when the element connects. A fresh load starts at the top, which matches the server markup, and a reload partway down the page is corrected on hydration.  The element uses a custom state because an attribute such as 'data-scrolled', written onto its own host, is one the server did not send. A hydrating framework would report a mismatch whenever the page reloads far enough down. 'ElementInternals.states' is not in the DOM, so hydration has nothing to compare. Select the state with ':state(scrolled)'.  The page is the window unless 'scroller' names the element that scrolls, for an app shell whose content scrolls inside a container. */
   "helix-headless-app-header": DefineCustomElement<
     HelixHeadlessAppHeader,
     HelixHeadlessAppHeaderVueProps,
@@ -12199,7 +12939,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessAreaChartVueProps,
     HelixHeadlessAreaChartVueEvents
   >;
-  /** A part of 'Avatar' that arranges avatars.  The group computes the overflow count from 'max' and renders the "+3" itself. There is no slot for it, because the number has to match which avatars are hidden.  Avatars past 'max' stay in the DOM and are hidden. Changing 'max' re-renders nothing, and the accessible name is still built from all of them. */
+  /** A part of 'Avatar' that arranges avatars.  The group computes the overflow count from 'max' and renders the "+3" itself. There is no slot for it, because the number has to match which avatars are hidden.  Avatars past 'max' stay in the DOM and are hidden. The group writes 'hidden' on each of them, so they are hidden on the headless tier as well, and the count is read out as 'overflow-label', such as "3 more", so a screen reader hears that there are more people than the ones it can reach. */
   "helix-headless-avatar-group": DefineCustomElement<
     HelixHeadlessAvatarGroup,
     HelixHeadlessAvatarGroupVueProps,
@@ -12211,19 +12951,19 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessAvatarVueProps,
     HelixHeadlessAvatarVueEvents
   >;
-  /** Badge wraps the element it decorates and pins an indicator to its corner, so the wrapped element keeps its place in the layout.  What the indicator shows depends on 'value':  - A 'value' of zero shows no indicator. - No 'value' shows a dot. - Any other value shows the value. Above 'max', the indicator shows '{max}+',   so its width stays the same as the count grows.  A count is announced from its own text, and 'label' replaces that with a fuller name, such as '4 unread'. A dot needs a 'label'. Without one, the dot is a colored circle that screen readers do not announce. */
+  /** Badge wraps the element it decorates and pins an indicator to its corner, so the wrapped element keeps its place in the layout.  What the indicator shows depends on 'value':  - A 'value' of zero shows no indicator. - No 'value' shows a dot. - Any other value shows the value. Above 'max', the indicator shows '{max}+',   so its width stays the same as the count grows.  A count is announced from its own text, and 'label' replaces that with a fuller name, such as '4 unread'. A dot needs a 'label'. Without one, the dot is a colored circle that screen readers do not announce.  **The count is not part of the wrapped control's name.** It is a status of its own, read when it changes and when a reader moves to it, so focusing a button inside a badge announces the button's name alone. Where the count belongs in that name, write it into the control's own label, such as 'aria-label="Inbox, 8 unread"' on a button that reads "Inbox". The badge cannot add it: a reference from the control to the count would point into the badge's shadow root, which the platform does not allow. */
   "helix-headless-badge": DefineCustomElement<
     HelixHeadlessBadge,
     HelixHeadlessBadgeVueProps,
     HelixHeadlessBadgeVueEvents
   >;
-  /** Every bar is measured from zero, and no property changes the baseline, because a bar's length is its value. To show the differences between values, use a line chart.  The labels are HTML beside the drawing. An '<svg>' that fills its box scales the text inside it: the same 'font-size' renders at 10px in a narrow chart and 43px in a wide one, and SVG has no setting that keeps text at one size the way 'vector-effect' does for strokes.  The table is the accessible representation, and the drawing is 'aria-hidden', so screen reader users get the numbers themselves.  The component writes the custom properties below with numbers it computes, and the stylesheet that draws the chart reads them. Do not set them yourself. */
+  /** Every bar is measured from zero, and no property changes the baseline, because a bar's length is its value. To show the differences between values, use a line chart.  The labels are HTML beside the drawing. An '<svg>' that fills its box scales the text inside it: the same 'font-size' renders at 10px in a narrow chart and 43px in a wide one, and SVG has no setting that keeps text at one size the way 'vector-effect' does for strokes.  The table is the accessible representation, and the drawing is 'aria-hidden', so screen reader users get the numbers themselves. The 'summary' part names the chart, from 'label' or the table's caption, and gives each series' highest reading.  The component writes the custom properties below with numbers it computes, and the stylesheet that draws the chart reads them. Do not set them yourself. */
   "helix-headless-bar-chart": DefineCustomElement<
     HelixHeadlessBarChart,
     HelixHeadlessBarChartVueProps,
     HelixHeadlessBarChartVueEvents
   >;
-  /** Renders a '<blockquote>' with a '<footer>' for the attribution, the structure the HTML spec describes. The attribution sits outside the quoted text because it is about the quotation.  For a quotation inside a sentence, use 'Quote'. */
+  /** 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'. */
   "helix-headless-blockquote": DefineCustomElement<
     HelixHeadlessBlockquote,
     HelixHeadlessBlockquoteVueProps,
@@ -12235,7 +12975,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessBreadcrumbVueProps,
     HelixHeadlessBreadcrumbVueEvents
   >;
-  /** The host is the navigation landmark, so an 'aria-label' on it names the trail. When a page has more than one navigation landmark, screen reader users choose between them by name.  The '<ol>' has an explicit 'role="list"', because Safari removes list semantics from a list with 'list-style: none', and the trail always hides its markers.  The items are slotted directly, so they are '<ol>' children in the flat tree, and each item sets 'role="listitem"' on itself.  The trail does not measure itself, and you write its overflow in markup: put the crumb that holds the folded items where the gap should appear. */
+  /** The host is the navigation landmark, named "Breadcrumb" by default. An 'aria-label' on the host names the trail instead, and so does 'label'. When a page has more than one navigation landmark, screen reader users choose between them by name.  The '<ol>' has an explicit 'role="list"', because Safari removes list semantics from a list with 'list-style: none', and the trail always hides its markers.  The items are slotted directly, so they are '<ol>' children in the flat tree, and each item sets 'role="listitem"' on itself.  The trail does not measure itself, and you write its overflow in markup: put the crumb that holds the folded items where the gap should appear. */
   "helix-headless-breadcrumbs": DefineCustomElement<
     HelixHeadlessBreadcrumbs,
     HelixHeadlessBreadcrumbsVueProps,
@@ -12247,13 +12987,13 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessButtonGroupVueProps,
     HelixHeadlessButtonGroupVueEvents
   >;
-  /** Renders a real '<button>', so activation, focus, and other browser behavior come from the platform.  **It never renders an anchor.** A router renders its own '<a>' to intercept a click, and it cannot render one inside the button's shadow root. For a link that looks like a button, use the base layer recipe on your own anchor: '<Link data-button="solid">' draws the same control.  'delegatesFocus' moves focus to the inner control. It is serialized into the server markup, so the button is reachable by keyboard before any JavaScript loads.  The inner control is always 'type="button"', because a '<button type="submit">' inside a shadow root cannot submit a form outside it. To submit, the button calls 'requestSubmit()' on its form, which runs validation, unlike 'submit()'. */
+  /** Renders a real '<button>', so activation, focus, and other browser behavior come from the platform.  **It never renders an anchor.** A router renders its own '<a>' to intercept a click, and it cannot render one inside the button's shadow root. For a link that looks like a button, use the base layer recipe on your own anchor: '<Link data-button="solid">' draws the same control.  'delegatesFocus' moves focus to the inner control. It is serialized into the server markup, so the button is reachable by keyboard before any JavaScript loads.  The inner control is always 'type="button"', because a '<button type="submit">' inside a shadow root cannot submit a form outside it. To submit, the button calls 'requestSubmit()' on its form, which runs validation, unlike 'submit()'.  A 'submit' listener reads 'event.submitter' as 'null', because the platform accepts only a native submit button there. The button's 'name' and 'value' are in the form data, so read them from 'new FormData(form)' to tell two submit buttons apart.  As the first submit button in its form, it is the form's default button: Enter in a text field of the form presses it, as it presses a native one. */
   "helix-headless-button": DefineCustomElement<
     HelixHeadlessButton,
     HelixHeadlessButtonVueProps,
     HelixHeadlessButtonVueEvents
   >;
-  /** 'tone' is on the headless tier because it carries meaning. It picks the icon and the icon's accessible name, so a screen reader announces "Error" for an error callout whether or not the color is seen.  The icon is the fallback content of a slot. Slot your own icon to replace it, and the default disappears with no extra check.  A callout sets a passage apart inside a document and is read where it sits. For page-level chrome above the masthead that is a live region and can be dismissed, use 'Announcement'. */
+  /** 'tone' is on the headless tier because it carries meaning. It picks the icon and the icon region's accessible name, so a screen reader announces "Error" for an error callout whether or not the color is seen. Set 'tone-label' to say the name in another language.  The icon is the fallback content of a slot. Slot your own icon to replace it, and the default disappears with no extra check. The tone's name stays on the region around it.  A callout sets a passage apart inside a document and is read where it sits. For page-level chrome above the masthead that is a live region and can be dismissed, use 'Announcement'. */
   "helix-headless-callout": DefineCustomElement<
     HelixHeadlessCallout,
     HelixHeadlessCalloutVueProps,
@@ -12283,7 +13023,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessCardVueProps,
     HelixHeadlessCardVueEvents
   >;
-  /** The track is a scroll container with scroll snapping, so dragging, trackpad swipes, and the browser's momentum scrolling all work. The controls scroll the track.  Slides are your own elements, and the carousel writes nothing onto them. It renders a pane for each slide with 'role="group"', 'aria-roledescription="slide"', and a name that gives the slide's position in the set, and assigns the slide into it. A screen reader announces the position, and a slide that is a link stays a link. See 'assign'.  **Rotation stops on focus and on hover, and stays stopped** until the user starts it again, as the APG requires. The rotation control is labeled with the action it performs and is first in the tab order. */
+  /** The track is a scroll container with scroll snapping, so dragging, trackpad swipes, and the browser's momentum scrolling all work. The controls scroll the track.  Slides are your own elements, and the carousel writes nothing onto them. It renders a pane for each slide with 'role="group"', 'aria-roledescription="slide"', and a name that gives the slide's position in the set, and assigns the slide into it. A screen reader announces the position, and a slide that is a link stays a link. See 'assign'.  **Rotation stops on focus and on hover, and stays stopped** until the user starts it again, as the APG requires. The rotation control is labeled with the action it performs and is first in the tab order. Rotation goes on from the last slide to the first, with or without 'loop', which is about the reader's own moves.  A move the reader makes is announced, the slide's position read from a polite live region. While the carousel rotates the region is off, so a screen reader is not interrupted every few seconds.  The indicators are one tab stop. The arrow keys along the track move between them, Up and Down on a vertical carousel, and Home and End go to the first and the last. Without 'loop', Previous on the first slide and Next on the last are marked 'aria-disabled'. */
   "helix-headless-carousel": DefineCustomElement<
     HelixHeadlessCarousel,
     HelixHeadlessCarouselVueProps,
@@ -12307,7 +13047,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessChatVueProps,
     HelixHeadlessChatVueEvents
   >;
-  /** The host is the group. It has 'role="group"' through internals, and 'label' names it. Without a name, screen readers announce the checkboxes as separate controls.  **Each checkbox submits its own value.** Checkboxes are already form-associated, and a native group is several inputs that share a name, so the group adds no form value of its own. It adds the grouping, a shared 'name' that you write once, and one place to read and write the whole set.  'value' is the checked values, separated by commas, in the order the checkboxes are written. Setting it checks exactly those values and unchecks the rest.  **The group shows the message you set in 'feedback'.** It is form-associated only for validity and never calls 'setFormValue', so the browser does not generate a message for it. */
+  /** The host is the group. It has 'role="group"' through internals, and 'label' names it. Without a name, screen readers announce the checkboxes as separate controls.  **Each checkbox submits its own value.** Checkboxes are already form-associated, and a native group is several inputs that share a name, so the group adds no form value of its own. It adds the grouping, a shared 'name' that you write once, and one place to read and write the whole set.  'value' is the checked values, separated by commas, in the order the checkboxes are written, read from the boxes themselves. Setting it checks exactly those values and unchecks the rest.  A checkbox is a member wherever it sits inside the group, in a row or a grid cell of your own, unless another group inside this one holds it. A field of another kind inside the group, such as an "Other" text field, sends its own 'input' and 'change' past the group.  **The group shows the message you set in 'feedback'.** It is form-associated only for validity and never calls 'setFormValue', so the browser does not generate a message for it. */
   "helix-headless-checkbox-group": DefineCustomElement<
     HelixHeadlessCheckboxGroup,
     HelixHeadlessCheckboxGroupVueProps,
@@ -12331,19 +13071,19 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessCodeVueProps,
     HelixHeadlessCodeVueEvents
   >;
-  /** A text field with a button that opens 'ColorPicker' in an overlay. 'ColorPicker' provides the square, the ramps, the eyedropper, and the syntax toggle, and you can also use it on its own, flat on the page. Color Input adds the field, the overlay, and the form value, the same arrangement Date Input has with 'DatePicker'.  You can type or paste a color into the field without opening the picker. Color Input is a custom control, unlike '<input type="color">', so you can style the panel to match your interface.  The field reads every color syntax, including '#f00', '#ff0000', 'rgb(255 0 0)', 'rgba(255,0,0,.5)', 'rgb(255 0 0 / 50%)', and 'hsl(0 100% 50%)'. It writes colors in the syntax that 'format' names. The field shows the value without reformatting it, because half-typed input does not survive a round trip through a formatter. Date Input does the same with dates.  The component sets '--color-input-swatch', so do not set it yourself. It holds the resolved color, so the styled tier can paint the swatch without parsing the value. */
+  /** A text field with a button that opens 'ColorPicker' in an overlay. 'ColorPicker' provides the square, the ramps, the eyedropper, and the syntax toggle, and you can also use it on its own, flat on the page. Color Input adds the field, the overlay, and the form value, the same arrangement Date Input has with 'DatePicker'.  You can type or paste a color into the field without opening the picker. Color Input is a custom control, unlike '<input type="color">', so you can style the panel to match your interface.  The field reads every color syntax, including '#f00', '#ff0000', 'rgb(255 0 0)', 'rgba(255,0,0,.5)', 'rgb(255 0 0 / 50%)', and 'hsl(0 100% 50%)'. It writes colors in the syntax that 'format' names. The field shows the value without reformatting it, because half-typed input does not survive a round trip through a formatter. Date Input does the same with dates.  Typing sends 'input' on each keystroke and 'change' when you leave the field, as a text field does, so the message about a color it cannot read waits until you are done. Dragging in the panel sends 'input' as the color moves and 'change' when it settles.  The component sets '--color-input-swatch', so do not set it yourself. It holds the resolved color, so the styled tier can paint the swatch without parsing the value. */
   "helix-headless-color-input": DefineCustomElement<
     HelixHeadlessColorInput,
     HelixHeadlessColorInputVueProps,
     HelixHeadlessColorInputVueEvents
   >;
-  /** The picker on its own, with no field around it, for a settings pane or a toolbar. Color Input shows this element in a panel behind a text field.  The saturation and brightness square is two '<input type="range">' elements, laid over the square and made invisible, and the handle is drawn from their values. The keyboard behavior, the announcements, and the touch targets come from the platform, and there is no 'role="application"'.  The picker works in HSB and derives the value from it. A value set from outside is read into the model once. Black is 'brightness: 0', which has no hue or saturation, so a model read back from the value would turn red into gray after you drag to the bottom of the square and back. */
+  /** The picker on its own, with no field around it, for a settings pane or a toolbar. Color Input shows this element in a panel behind a text field.  The saturation and brightness square is two '<input type="range">' elements, laid over the square and made invisible, and the handle is drawn from their values. The keyboard behavior, the announcements, and the touch targets come from the platform, and there is no 'role="application"'.  The picker works in HSB and derives the value from it. A value set from outside is read into the model once. Black is 'brightness: 0', which has no hue or saturation, so a model read back from the value would turn red into gray after you drag to the bottom of the square and back.  The square is one tab stop. In it, the up and down arrows move brightness and the left and right arrows move saturation, and PageUp and PageDown move brightness by ten. The picker sends 'input' as the color moves and 'change' when a drag, a key, a typed value or a preset settles it, as '<input type="color">' does. */
   "helix-headless-color-picker": DefineCustomElement<
     HelixHeadlessColorPicker,
     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.  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. 'role="combobox"' is on the input itself. ArrowDown and ArrowUp open the list on the chosen option, and Enter chooses the highlighted one. 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.  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,
@@ -12355,25 +13095,25 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessCommandVueProps,
     HelixHeadlessCommandVueEvents
   >;
-  /** Copies text to the clipboard and confirms the copy. The platform gives no feedback for a clipboard write, so without a confirmation a press that copies looks the same as one that fails.  The confirmation and the event wait for the write to finish. The browser can refuse a clipboard write, for example on an insecure origin, in a document that is not focused, or after a gesture that does not qualify. A refused write leaves the button unchanged. */
+  /** Copies text to the clipboard and confirms the copy. The platform gives no feedback for a clipboard write, so without a confirmation a press that copies looks the same as one that fails.  The confirmation and the event wait for the write to finish. The browser can refuse a clipboard write, for example on an insecure origin, in a document that is not focused, or after a gesture that does not qualify. A refused write leaves the button unchanged.  It replaces Button's render and its press, so it never submits a form or sends a command: 'type', 'command', 'commandfor' and the 'form*' overrides have no effect, and the 'start' and 'end' slots and the 'text' part are not rendered. An 'aria-label' on the element names it before a copy, in place of 'label'. */
   "helix-headless-copy-button": DefineCustomElement<
     HelixHeadlessCopyButton,
     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.  To act on a single row, such as opening it, put a link or a button in a cell.  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.  To act on a single row, such as opening it, put a link or a button in a cell.  The grid is one tab stop, and the arrow keys move between its cells, the headings included:  - The arrow keys move one cell, and Home and End to the ends of the row. - Control with Home or End moves to the first or the last cell of the grid. - Page Up and Page Down move by the rows that fit in view. - Enter or F2 moves into the cell's controls, and Escape moves back to the   cell. Tab moves between the controls of one cell. - Enter or Space on a sortable heading sorts by it, and Space on a row of a   'selectable' table selects it.  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'. */
   "helix-headless-data-table": DefineCustomElement<
     HelixHeadlessDataTable,
     HelixHeadlessDataTableVueProps,
     HelixHeadlessDataTableVueEvents
   >;
-  /** The calendar is 'DatePicker', which handles months, ranges, disabled days, the first day of the week, and the grid's keyboard behavior. The date input adds the field, the overlay, and the connection between them.  You can type a date as well as pick one. The native '<input type="date">' gives a picker and locale formatting but allows almost no styling, so the field is a text field. */
+  /** The calendar is 'DatePicker', which handles months, ranges, disabled days, the first day of the week, and the grid's keyboard behavior. The date input adds the field, the overlay, and the connection between them.  You can type a date as well as pick one. The native '<input type="date">' gives a picker and locale formatting but allows almost no styling, so the field is a text field. Typing sends 'input' on each keystroke and 'change' when you leave the field, as a text field does. A date picked from the calendar sends both.  The trigger opens the calendar with focus on the selected day, and Escape closes it and returns focus to the field. Focusing the field opens the calendar too, and Tab out of the field closes it again. */
   "helix-headless-date-input": DefineCustomElement<
     HelixHeadlessDateInput,
     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'. */
+  /** 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'.  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,
@@ -12391,7 +13131,7 @@ 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  '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. */
+  /** 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  '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. */
   "helix-headless-dialog": DefineCustomElement<
     HelixHeadlessDialog,
     HelixHeadlessDialogVueProps,
@@ -12403,13 +13143,13 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessDividerVueProps,
     HelixHeadlessDividerVueEvents
   >;
-  /** A donut chart divides one whole into parts, so the component reads one column.  **The first column of numbers is the series, and each row is a slice.** Other Helix charts take one column per series.  **Negative values are skipped.** An arc cannot show a negative number, so those rows are left out and the total is the sum of the remaining rows. */
+  /** A donut chart divides one whole into parts, so the component reads one column.  **The first column of numbers is the series, and each row is a slice.** Other Helix charts take one column per series.  **Negative values are skipped.** An arc cannot show a negative number, so those rows are left out and the total is the sum of the remaining rows.  The ring is 'aria-hidden'. The 'summary' part names the chart, from 'label' or the table's caption, and gives each slice's share, and the table beside the chart has every amount. */
   "helix-headless-donut-chart": DefineCustomElement<
     HelixHeadlessDonutChart,
     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 three things:  - focus is trapped inside - Escape and a press outside close it - the page behind is covered  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 - 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.  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> ''' */
   "helix-headless-drawer": DefineCustomElement<
     HelixHeadlessDrawer,
     HelixHeadlessDrawerVueProps,
@@ -12421,7 +13161,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessDrilldownItemVueProps,
     HelixHeadlessDrilldownItemVueEvents
   >;
-  /** One panel whose content changes as you move between pages. Use it where there is no room for a second column, such as on a phone, or on a touch screen with no hover to open one.  It is a region that stays where you put it, such as inside a drawer, a sidebar, or a settings panel. A 'Menu' opens from a trigger and closes when you are done. 'Menu' can drill into pages too, through the same controller.  Rows are places to go and commands to run. Nothing here is form-associated and nothing is submitted. To choose a value, use a 'Listbox'.  A row that opens a page contains that page, so the stack holds one reference and reads the rest from the DOM. The behavior lives in 'DrilldownController', which 'Menu' shares. */
+  /** One panel whose content changes as you move between pages. Use it where there is no room for a second column, such as on a phone, or on a touch screen with no hover to open one.  It is a region that stays where you put it, such as inside a drawer, a sidebar, or a settings panel. A 'Menu' opens from a trigger and closes when you are done. 'Menu' can drill into pages too, through the same controller.  Rows are places to go and commands to run. Nothing here is form-associated and nothing is submitted. To choose a value, use a 'Listbox'.  A row that opens a page contains that page, so the stack holds one reference and reads the rest from the DOM. The behavior lives in 'DrilldownController', which 'Menu' shares.  The rows of the page showing are a 'menu', named by 'label' on the top page and by the page's title below it. The back button and the title sit above the menu. Disabled rows stay reachable with the arrow keys, and typing a letter moves to the next row whose name starts with it. */
   "helix-headless-drilldown": DefineCustomElement<
     HelixHeadlessDrilldown,
     HelixHeadlessDrilldownVueProps,
@@ -12469,7 +13209,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.  **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.  **The output is always '<time datetime>'**, so screen readers, copy and paste, and scripts parsing the page get the exact instant, whatever the visible text says. */
+  /** 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.  **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.  **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. */
   "helix-headless-format-date": DefineCustomElement<
     HelixHeadlessFormatDate,
     HelixHeadlessFormatDateVueProps,
@@ -12493,7 +13233,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessIconButtonVueProps,
     HelixHeadlessIconButtonVueEvents
   >;
-  /** The icons are Phosphor, drawn on a 256 box at stroke-width 16. Each glyph renders its full inner markup, because most icons are several elements, each with its own stroke and fill.  The markup is generated at build time from SVG files in this repository and never comes from user input, so rendering it with 'unsafeSVG' is safe.  The '<svg>' carries 'fill="currentColor"'. The generator keeps only the inner markup, and Phosphor sets its fill on the root tag that the generator discards. Without it, the 65 solid glyphs fall back to black and disappear on a dark background. Shapes that set their own 'fill' or 'stroke' are unaffected.  A name with no match renders nothing.  An icon is decorative by default and hidden from assistive technology. Set 'label' only when the icon is the only carrier of meaning, such as in a button with no text. */
+  /** The icons are Phosphor, drawn on a 256 box at stroke-width 16. Each glyph renders its full inner markup, because most icons are several elements, each with its own stroke and fill.  The markup is generated at build time from SVG files in this repository and never comes from user input, so rendering it with 'unsafeSVG' is safe.  The '<svg>' carries 'fill="currentColor"'. The generator keeps only the inner markup, and Phosphor sets its fill on the root tag that the generator discards. Without it, the 65 solid glyphs fall back to black and disappear on a dark background. Shapes that set their own 'fill' or 'stroke' are unaffected.  A name with no match renders nothing, and the element fires 'error', so a typo in a name can be heard.  An icon is decorative by default and hidden from assistive technology. Set 'label' only when the icon is the only carrier of meaning, such as in a button with no text. An 'aria-label' on the element works too: the element is then an image with that name. */
   "helix-headless-icon": DefineCustomElement<
     HelixHeadlessIcon,
     HelixHeadlessIconVueProps,
@@ -12529,19 +13269,19 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessLightboxItemVueProps,
     HelixHeadlessLightboxItemVueEvents
   >;
-  /** The frame around content you open, such as a picture, a video frame, or a chart. The lightbox draws no content of its own. It provides the frame, the keyboard behavior, and text that states the current position in the set.  The modal behavior comes from a native '<dialog>' opened with 'showModal()', which provides the top layer, a backdrop, Escape to close, and 'inert' on the rest of the document. Every way of closing goes through 'requestOpen', as in 'Dialog' and 'Drawer'.  A lightbox shows one item at a time and has no scrolling track, so 'active' holds the current item, as in 'Tabs'. The arrow keys change the item while focus stays in the dialog.  The chrome hides when there is no input, through 'IdleController', and comes back on a pointer move or a focus. 'fullscreen' uses 'FullscreenController', as 'Video' does. */
+  /** The frame around content you open, such as a picture, a video frame, or a chart. The lightbox draws no content of its own. It provides the frame, the keyboard behavior, and text that states the current position in the set.  The modal behavior comes from a native '<dialog>' opened with 'showModal()', which provides the top layer, a backdrop, Escape to close, and 'inert' on the rest of the document. Every way of closing goes through 'requestOpen', as in 'Dialog' and 'Drawer'.  A lightbox shows one item at a time and has no scrolling track, so 'active' holds the current item, as in 'Tabs'. The arrow keys change the item while focus stays in the dialog.  The chrome hides when there is no input, through 'IdleController', and comes back on a pointer move, a key press, or a focus. It stays while focus is on a control in the header or the footer, so a keyboard reader is never left on a control that has gone. 'fullscreen' uses 'FullscreenController', as 'Video' does. While the viewer is open, the page behind it does not scroll. */
   "helix-headless-lightbox": DefineCustomElement<
     HelixHeadlessLightbox,
     HelixHeadlessLightboxVueProps,
     HelixHeadlessLightboxVueEvents
   >;
-  /** A line chart shows the shape of each series: where the readings went.  The scale covers the range of the data. Including zero in the range of a series that moves between 980 and 1020 would flatten the line into a rule across the top of the box. 'BarChart' always starts at zero, because a bar's length is its value. Set 'zero' when the distance from zero is the point.  Every series shares one scale, as in the bar chart.  'area' fills each series down to the floor on its own, so the fills overlap. For a total made of parts, use 'Area Chart', which stacks the series so the top edge is the total and each band is a share.  The labels are HTML beside the drawing, as in 'BarChart'. Text inside an '<svg>' that fills its box scales with the box, so the same 'font-size' can render at 10px in a narrow chart and 43px in a wide one.  The table is the accessible representation, and the drawing is 'aria-hidden'. Screen reader users get the numbers. */
+  /** A line chart shows the shape of each series: where the readings went.  The scale covers the range of the data. Including zero in the range of a series that moves between 980 and 1020 would flatten the line into a rule across the top of the box. 'BarChart' always starts at zero, because a bar's length is its value. Set 'zero' when the distance from zero is the point.  Every series shares one scale, as in the bar chart.  'area' fills each series down to the floor on its own, so the fills overlap. For a total made of parts, use 'Area Chart', which stacks the series so the top edge is the total and each band is a share.  The labels are HTML beside the drawing, as in 'BarChart'. Text inside an '<svg>' that fills its box scales with the box, so the same 'font-size' can render at 10px in a narrow chart and 43px in a wide one.  The table is the accessible representation, and the drawing is 'aria-hidden'. Screen reader users get the numbers. The 'summary' part names the chart, from 'label' or the table's caption, and gives each series' latest reading. */
   "helix-headless-line-chart": DefineCustomElement<
     HelixHeadlessLineChart,
     HelixHeadlessLineChartVueProps,
     HelixHeadlessLineChartVueEvents
   >;
-  /** Provides layout and semantics. The row is a target only when you set 'href'.  **'href' makes the whole row a link.** The component wraps its own layout in an '<a part="row">', as 'Tree.Item' does. An anchor of your own cannot wrap slots it does not own. With the anchor, the whole 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.  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. */
+  /** 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. */
   "helix-headless-list-item": DefineCustomElement<
     HelixHeadlessListItem,
     HelixHeadlessListItemVueProps,
@@ -12553,7 +13293,7 @@ export interface WcToolkitVueGlobalComponents {
     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 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, 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. */
   "helix-headless-listbox": DefineCustomElement<
     HelixHeadlessListbox,
     HelixHeadlessListboxVueProps,
@@ -12613,7 +13353,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessMapRasterVueProps,
     HelixHeadlessMapRasterVueEvents
   >;
-  /** Wraps a map drawn by MapLibre, Leaflet, or another renderer. The frame adds a name for the map, a column of controls, and a strip for the map credit. Helix does not draw the map itself.  The controls are one column, and 'controls' names which ones: 'fullscreen', 'layers', 'tilt', 'zoom', and 'compass', top to bottom. 'zoom compass fullscreen' by default. The compass's needle points north as the map turns, and pressing it turns the map to face north.  Add 'pan' and 'rotate' for buttons around the compass that move and turn the map. Dragging is otherwise the only way a pointer moves the map, so add them where the map has to be usable without dragging, as WCAG 2.2 asks at level AA. The arrow keys pan the map and Shift with Left or Right turns it either way.  The pan and zoom buttons and the arrow keys send 'helix-map-pan' and 'helix-map-zoom'. Move your map in response, or connect it with 'connectMap' from '@fusion.dev/helix-map', which does this for you.  Add 'tilt' to 'controls' for the 3D button, which a map with 3D buildings or terrain needs. It is a toggle. Pressed, it tilts the map 50 degrees, and 'connectMap' raises the buildings and the ground. Pressed again, it makes the map flat, and lays them flat too. Shift with Up or Down tilts the map in steps. Turning and tilting send 'helix-map-rotate' and 'helix-map-tilt', which 'connectMap' answers on MapLibre. Leaflet draws maps flat and does not rotate.  Add 'layers' to 'controls' for a layers button. It opens a menu with a tile for each layer, which sets the layer's 'hidden' attribute. Layers with the same 'group', such as a route and its dotted legs, share one tile.  Imagery, a 'helix-map-raster' with 'ground', is a map type and not a tile. The menu opens with a card for each type, Standard, Hybrid, and Satellite, with a picture of the map in it, and 'map-type' says which is chosen. Standard hides the imagery, Hybrid draws it under the roads and names, and Satellite draws it alone. 'connectMap' does not draw a hidden layer, so a layer you write with 'hidden' starts turned off.  Markers, routes, areas, live positions, and points layers go inside the frame as child elements. */
+  /** Wraps a map drawn by MapLibre, Leaflet, or another renderer. The frame adds a name for the map, a column of controls, and a strip for the map credit. Helix does not draw the map itself.  The controls are one column, and 'controls' names which ones: 'fullscreen', 'layers', 'tilt', 'zoom', and 'compass', top to bottom. 'zoom compass fullscreen' by default. The compass's needle points north as the map turns, and pressing it turns the map to face north.  Add 'pan' and 'rotate' for buttons around the compass that move and turn the map. Dragging is otherwise the only way a pointer moves the map, so add them where the map has to be usable without dragging, as WCAG 2.2 asks at level AA. The arrow keys pan the map and Shift with Left or Right turns it either way.  The pan and zoom buttons and the arrow keys send 'helix-map-pan' and 'helix-map-zoom'. Move your map in response, or connect it with 'connectMap' from '@fusion.dev/helix-map', which does this for you.  Add 'tilt' to 'controls' for the 3D button, which a map with 3D buildings or terrain needs. It is a toggle. Pressed, it tilts the map 50 degrees, and 'connectMap' raises the buildings and the ground. Pressed again, it makes the map flat, and lays them flat too. Shift with Up or Down tilts the map in steps. Turning and tilting send 'helix-map-rotate' and 'helix-map-tilt', which 'connectMap' answers on MapLibre. Leaflet draws maps flat and does not rotate.  Add 'layers' to 'controls' for a layers button. It opens a menu with a tile for each layer, which sets the layer's 'hidden' attribute. Layers with the same 'group', such as a route and its dotted legs, share one tile. A tile sends 'helix-before-toggle' from the layer first, so you can store the choice or refuse it.  Imagery, a 'helix-map-raster' with 'ground', is a map type and not a tile. The menu opens with a card for each type, Standard, Hybrid, and Satellite, with a picture of the map in it, and 'map-type' says which is chosen. Standard hides the imagery, Hybrid draws it under the roads and names, and Satellite draws it alone. Choosing one sends 'helix-before-change' with its name, and 'change' once 'map-type' holds it. 'connectMap' does not draw a hidden layer, so a layer you write with 'hidden' starts turned off.  Markers, routes, areas, live positions, and points layers go inside the frame as child elements. */
   "helix-headless-map": DefineCustomElement<
     HelixHeadlessMap,
     HelixHeadlessMapVueProps,
@@ -12637,13 +13377,13 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessMegamenuVueProps,
     HelixHeadlessMegamenuVueEvents
   >;
-  /** One element covers three kinds of row, and what you give it decides which: - Content in the 'submenu' slot makes the row open a submenu page. - 'checked' makes the row a choice. - With neither, the row is a command.  The role follows the kind. A row with 'checked' is 'menuitemcheckbox' with 'aria-checked', and 'exclusive' makes it 'menuitemradio', for a set where only one can be on. A row that opens a page keeps 'menuitem' and sets 'aria-haspopup'.  The menu sets whether the row's page is showing as a property, never as an attribute. An attribute written onto your element after it upgrades causes a hydration mismatch. */
+  /** One element covers three kinds of row, and what you give it decides which: - Content in the 'submenu' slot makes the row open a submenu page. - 'checked' makes the row a choice. - With neither, the row is a command.  The role follows the kind. A row with 'checked' is 'menuitemcheckbox' with 'aria-checked', and 'exclusive' makes it 'menuitemradio', for a set where only one can be on. A row that opens a page keeps 'menuitem' and sets 'aria-haspopup'.  Choosing a choice row checks or unchecks it before 'helix-select' is sent, so a listener reads the new 'checked'. An 'exclusive' row turns on and turns off the 'exclusive' rows next to it. Cancel 'helix-before-toggle' to keep a row as it is and set 'checked' yourself.  The menu sets whether the row's page is showing as a property, never as an attribute. An attribute written onto your element after it upgrades causes a hydration mismatch. */
   "helix-headless-menu-item": DefineCustomElement<
     HelixHeadlessMenuItem,
     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'.  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. */
+  /** 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. */
   "helix-headless-menu": DefineCustomElement<
     HelixHeadlessMenu,
     HelixHeadlessMenuVueProps,
@@ -12655,7 +13395,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessMeterVueProps,
     HelixHeadlessMeterVueEvents
   >;
-  /** Renders a real '<nav>', the landmark that screen reader users jump to. Navigation is its own component, separate from 'AppHeader', so you can use it in a header, a footer, or a sidebar.  **It renders no links.** Bring your own, mark the current one with 'aria-current="page"', and style them with the 'data-navigation-item' recipe. A router renders its own anchors and cannot render them inside the component's shadow root.  The component moves a marker to the current item. It finds the current item by reading 'aria-current', so the attribute that screen readers announce also places the marker.  Set 'orientation="vertical"' to stack the destinations in a column, for a sidebar. */
+  /** Renders a real '<nav>', the landmark that screen reader users jump to. Navigation is its own component, separate from 'AppHeader', so you can use it in a header, a footer, or a sidebar.  **It renders no links.** Bring your own, mark the current one with 'aria-current="page"', and style them with the 'data-navigation-item' recipe. A router renders its own anchors and cannot render them inside the component's shadow root.  The component moves a marker to the current item. It finds the current item by reading 'aria-current', so the attribute that screen readers announce also places the marker. Any value but 'false' counts, so a sidebar of sections on one page can mark the section in view with 'aria-current="location"'. Where several are marked, 'page' wins.  Set 'orientation="vertical"' to stack the destinations in a column, for a sidebar. */
   "helix-headless-navigation": DefineCustomElement<
     HelixHeadlessNavigation,
     HelixHeadlessNavigationVueProps,
@@ -12679,13 +13419,13 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessNotificationsVueProps,
     HelixHeadlessNotificationsVueEvents
   >;
-  /** A separate family from 'Input''s 'type="number"'. It renders two buttons, binds four keys 'Input' does not, and handles clamping and stepping.  The field is 'type="text"' with 'inputmode="decimal"'. Tested in a real browser, 'type="number"' fails in three ways: - Typing '12e' gives a '.value' of '""', so the element cannot see what you   typed. A 'type="text"' field keeps '"12e"'. - The mouse wheel over a focused field changes the value, for example from 5   to 4, when you only meant to scroll the page. - 'selectionStart' is 'null', so the caret cannot be managed.  'inputmode="decimal"' keeps the numeric keypad on phones.  Validity still comes from the platform: 'min', 'max', and 'step' are mirrored onto the host's own 'setValidity'.  Stepping is separate from typing, so a number is not corrected while you type it. */
+  /** A separate family from 'Input''s 'type="number"'. It renders two buttons, binds four keys 'Input' does not, and handles clamping and stepping.  The field is 'type="text"' with 'inputmode="decimal"'. Tested in a real browser, 'type="number"' fails in three ways: - Typing '12e' gives a '.value' of '""', so the element cannot see what you   typed. A 'type="text"' field keeps '"12e"'. - The mouse wheel over a focused field changes the value, for example from 5   to 4, when you only meant to scroll the page. - 'selectionStart' is 'null', so the caret cannot be managed.  'inputmode="decimal"' keeps the numeric keypad on phones.  Validity follows the platform's rules: 'min', 'max', and 'step' are checked and reported through the host's own 'setValidity', under the platform's flag names.  Stepping is separate from typing, so a number is not corrected while you type it. */
   "helix-headless-number-input": DefineCustomElement<
     HelixHeadlessNumberInput,
     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.  The tree is one tab stop. Up and Down move between rows, Right opens a branch or moves into it, Left closes it or moves to its parent, and Home and End move to the first and last rows. Focus stays on the tree, and 'aria-activedescendant' marks the active row. Each row carries its real level, position, and set size, including in a windowed tree.  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.  The tree is one tab stop. Up and Down move between rows, Right opens a branch or moves into it, Left closes it or moves to its parent, and Home and End move to the first and last rows. Typing moves to the next row whose key starts with what was typed, and '*' opens every branch beside the active row. Focus stays on the tree, and 'aria-activedescendant' marks the active row. Each row carries its real level, position, and set size, including in a windowed 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,
@@ -12703,7 +13443,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessOptionVueProps,
     HelixHeadlessOptionVueEvents
   >;
-  /** Outline is a table of contents for a document. 'Navigation' does the same job for a site.  The links are your own anchors. A router renders its own '<a>' and cannot render one inside the outline's shadow root, and the hrefs are fragments on the same page.  The current section is decided by the headings' positions. An 'IntersectionObserver' with a band near the top fails both ways: when headings are far apart, none is in the band and no section is marked, and when they are close together, several are in the band at once. */
+  /** Outline is a table of contents for a document. 'Navigation' does the same job for a site.  The links are your own anchors. A router renders its own '<a>' and cannot render one inside the outline's shadow root, and the hrefs are fragments on the same page.  Write the anchors flat, with 'data-level' for their depth, or nested in lists, '<ul><li><a>'. A screen reader hears a nested list's levels; it hears 'data-level' as a flat run of links.  The current section is decided by the headings' positions. An 'IntersectionObserver' with a band near the top fails both ways: when headings are far apart, none is in the band and no section is marked, and when they are close together, several are in the band at once. */
   "helix-headless-outline": DefineCustomElement<
     HelixHeadlessOutline,
     HelixHeadlessOutlineVueProps,
@@ -12715,7 +13455,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessPaginationVueProps,
     HelixHeadlessPaginationVueEvents
   >;
-  /** A separate element that you place beside 'Pagination', like 'Pagination.Summary', so you choose the direction and order of your footer.  It uses 'Select', so it matches a table's filter dropdowns in the same footer, both open and closed. The caret is 'Select''s, so it follows 'currentColor', and the label is a real '<label for>' pointing at the trigger's id.  The label sits on the same row as the select. 'Select''s host is a column, and an outer-tree rule overrides a ':host' rule, so the row layout needs no property on 'Select' and nothing added to your markup.  An empty 'sizes' renders nothing and does not fall back to the built-in list. 'Pagination' does the same with a single page, and both report it through 'ElementInternals.states'.  'value' is the current size, and 'default-value' is the size from the markup. Changing it dispatches 'helix-before-change'. Re-querying and returning to page one is up to you, because only you know whether the current position should be kept. */
+  /** A separate element that you place beside 'Pagination', like 'Pagination.Summary', so you choose the direction and order of your footer.  It uses 'Select', so it matches a table's filter dropdowns in the same footer, both open and closed. The caret is 'Select''s, so it follows 'currentColor', and the label is a real '<label for>' pointing at the trigger's id.  The label sits on the same row as the select. 'Select''s host is a column, and an outer-tree rule overrides a ':host' rule, so the row layout needs no property on 'Select' and nothing added to your markup.  An empty 'sizes' renders nothing and does not fall back to the built-in list. 'Pagination' does the same with a single page, and both report it through 'ElementInternals.states'.  'value' is the current size, and 'default-value' is the size from the markup. Changing it dispatches 'helix-before-change', and then 'input' and 'change' once the size has moved, as a native '<select>' sends them together. Re-querying and returning to page one is up to you, because only you know whether the current position should be kept. */
   "helix-headless-pagination-size": DefineCustomElement<
     HelixHeadlessPaginationSize,
     HelixHeadlessPaginationSizeVueProps,
@@ -12733,7 +13473,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessPinInputVueProps,
     HelixHeadlessPinInputVueEvents
   >;
-  /** Popover is the general overlay that the specific ones build on. 'Menu' holds commands, 'Select' holds options, and 'Tooltip' holds a description. Popover holds any content you put in it, so it has no keyboard handling of its own.  The trigger is slotted and stays your own element. The popover writes nothing onto it, including 'aria-expanded', 'id', and 'tabindex', because changing your markup after upgrade causes a React hydration mismatch.  The panel is in the top layer through the popover API, so it needs no 'z-index', and an ancestor with 'overflow: hidden', 'transform', 'filter', or 'contain' does not clip or move it.  It opens on click and from a command. 'command="--show"' and the related commands work as they do on 'Dialog' and 'Drawer', so a button anywhere on the page can open the popover with no script. */
+  /** Popover is the general overlay that the specific ones build on. 'Menu' holds commands, 'Select' holds options, and 'Tooltip' holds a description. Popover holds any content you put in it, so it has no keyboard handling of its own.  The trigger is slotted and stays your own element. The popover writes nothing onto it, including 'aria-expanded', 'id', and 'tabindex', because changing your markup after upgrade causes a React hydration mismatch.  The panel is in the top layer through the popover API, so it needs no 'z-index', and an ancestor with 'overflow: hidden', 'transform', 'filter', or 'contain' does not clip or move it.  It opens on click and from a command. 'command="--show"' and the related commands work as they do on 'Dialog' and 'Drawer', so a button anywhere on the page can open the popover with no script.  It closes on Escape, on a press outside it, and when focus moves out of the trigger and the panel to somewhere else on the page. It does not trap focus. An 'aria-labelledby' on the host names the panel in place of 'label'. */
   "helix-headless-popover": DefineCustomElement<
     HelixHeadlessPopover,
     HelixHeadlessPopoverVueProps,
@@ -12745,7 +13485,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 the name to what the code is for. When you pass no name, the value is the name. Most codes hold a URL, and a URL read aloud gives the destination.  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. */
+  /** 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 the name to what the code is for. When you pass no name, the value is the name. Most codes hold a URL, and a URL read aloud gives the destination.  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, and the element fires 'error'. */
   "helix-headless-qr-code": DefineCustomElement<
     HelixHeadlessQrCode,
     HelixHeadlessQrCodeVueProps,
@@ -12787,13 +13527,13 @@ 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. */
+  /** 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.  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. */
   "helix-headless-select": DefineCustomElement<
     HelixHeadlessSelect,
     HelixHeadlessSelectVueProps,
     HelixHeadlessSelectVueEvents
   >;
-  /** Sets 'aria-busy' and a polite live region, so a screen reader announces that the region is loading. Both are set through 'ElementInternals', which writes no attributes.  There is no 'shape' property. Whether a placeholder is a line, a block, or a circle is presentation, which belongs to the styled tier. */
+  /** A skeleton is hidden from screen readers unless it has a 'label'. An empty placeholder has nothing to say, and a page of them would be a page of unnamed shapes. Tell a screen reader that a region is loading on the region itself: set 'aria-busy="true"' on it while it loads, and put a 'Loader' or a status message in it. Set 'label' on one skeleton to have it read out by name, such as "Loading profile", when a reader reaches it. The role and the name are set through 'ElementInternals', which writes no attributes.  There is no 'shape' property. Whether a placeholder is a line, a block, or a circle is presentation, which belongs to the styled tier. */
   "helix-headless-skeleton": DefineCustomElement<
     HelixHeadlessSkeleton,
     HelixHeadlessSkeletonVueProps,
@@ -12811,7 +13551,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessSliderVueProps,
     HelixHeadlessSliderVueEvents
   >;
-  /** Takes its numbers from the 'values' attribute. The other charts read a table, but a table behind a small trend line would be read aloud row by row. Set 'values' to the data and 'label' to the one sentence a screen reader announces.  This follows the library's rule that a content property is the fallback for its slot, as with 'Tooltip''s 'content' and 'Avatar''s 'name'. Use 'for' when a sparkline has a real table behind it. 'for' wins when both are set.  Without a 'label' the sparkline is decorative and 'aria-hidden', for example beside a stat that already says "Sessions, 1,102". With a 'label' it is an image named by that sentence.  Place it beside a 'Stat', because a change beside a figure is a second fact, as 'Stat''s own spec says. 'Trend' is composed the same way.  The component writes the properties listed below, and the stylesheet that draws the sparkline reads them. Do not set them yourself. They carry numbers the component computes and CSS cannot, so a stylesheet can draw the sparkline without measuring anything. */
+  /** Takes its numbers from the 'values' attribute. The other charts read a table, but a table behind a small trend line would be read aloud row by row. Set 'values' to the data and 'label' to the one sentence a screen reader announces.  Use 'for' when a sparkline has a real table behind it. 'for' wins when both are set.  Without a 'label' the sparkline is decorative and 'aria-hidden', for example beside a stat that already says "Sessions, 1,102". With a 'label' it is an image named by that sentence.  Place it beside a 'Stat', because a change beside a figure is a second fact, as 'Stat''s own spec says. 'Trend' is composed the same way.  The component writes the properties listed below, and the stylesheet that draws the sparkline reads them. Do not set them yourself. They carry numbers the component computes and CSS cannot, so a stylesheet can draw the sparkline without measuring anything. */
   "helix-headless-sparkline": DefineCustomElement<
     HelixHeadlessSparkline,
     HelixHeadlessSparklineVueProps,
@@ -12823,13 +13563,13 @@ export interface WcToolkitVueGlobalComponents {
     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, checkable items, or type-ahead.  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. */
+  /** 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. */
   "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'. Drag it with a pointer or move it with the arrow keys, and press 'Home' or 'End' to move it to its bounds. 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', 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,
@@ -12865,19 +13605,19 @@ 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 'columnheader', so a screen reader announces the heading with the value, for example "Attribute, appearance".  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. */
   "helix-headless-table-cell": DefineCustomElement<
     HelixHeadlessTableCell,
     HelixHeadlessTableCellVueProps,
     HelixHeadlessTableCellVueEvents
   >;
-  /** Each column provides both its heading and its grid track. Adding a column adds a track, and removing one removes it. 'Table''s 'columns' is applied one track at a time to the columns declared under it:  - A heading name in the list affects only its own column's width. - A list longer or shorter than the columns is trimmed or shared. - A column's own 'width' overrides the track in its place.  This protects the table from a track list that contains the headings by mistake, which is invalid CSS that the grid ignores silently, drawing the whole table as one column.  Every per-column setting goes on the column, so 'DataTable' needs no column configuration object:  - 'field' names the key the cell reads. - 'sortable' lets people sort by the column. - 'text-align' sets which edge the values line up against. - 'cell' takes a function for anything 'field' alone cannot express.  The same element works in both 'Table' and 'DataTable'. It is identified by a flag, so the two roots share nothing else.  The column generates no box of its own, the same as a row. The heading is a grid item of the table, so it lines up with the cells below it.  'hidden' takes the column out of the grid, both its heading and its track, so the other columns keep their widths and every row keeps its cells under their headings. 'hidden="until-found"' keeps the track and leaves the heading drawn, as it does on every Helix element. 'DataTable' leaves out the cells under a hidden column. In a 'Table' the cells are markup you wrote, so hide them with the column: a row with more cells than the table has tracks wraps onto the next line.  A heading that does something holds a control. A column header is not focusable, so a sortable heading contains a '<button>', which is the pattern for a sortable table and the only way to reach the sort by keyboard. A resizable column has a 'separator' on its end edge, moved by dragging or with the arrow keys. In a table with reorderable columns, each column has a grip that the table moves. */
+  /** Each column provides both its heading and its grid track. Adding a column adds a track, and removing one removes it. 'Table''s 'columns' is applied one track at a time to the columns declared under it:  - A heading name in the list affects only its own column's width. - A list longer or shorter than the columns is trimmed or shared. - A column's own 'width' overrides the track in its place.  This protects the table from a track list that contains the headings by mistake, which is invalid CSS that the grid ignores silently, drawing the whole table as one column.  Every per-column setting goes on the column, so 'DataTable' needs no column configuration object:  - 'field' names the key the cell reads. - 'sortable' lets people sort by the column. - 'text-align' sets which edge the values line up against. - 'cell' takes a function for anything 'field' alone cannot express.  The same element works in both 'Table' and 'DataTable'. It is identified by a flag, so the two roots share nothing else.  The column generates no box of its own, the same as a row. The heading is a grid item of the table, so it lines up with the cells below it.  'hidden' takes the column out of the grid, both its heading and its track, so the other columns keep their widths and every row keeps its cells under their headings. 'hidden="until-found"' keeps the track and leaves the heading drawn, as it does on every Helix element. 'DataTable' leaves out the cells under a hidden column. In a 'Table' the cells are markup you wrote, so hide them with the column: a row with more cells than the table has tracks wraps onto the next line.  A heading that does something holds a control. In a 'Table' a column header is not focusable, so a sortable heading contains a '<button>', which is the pattern for a sortable table and the only way to reach the sort by keyboard. In a 'DataTable' the heading is a cell of the grid, reached with the arrow keys, and its controls with Enter or F2. A resizable column has a 'separator' on its end edge, moved by dragging or with the arrow keys. In a table with reorderable columns, each column has a grip that the table moves. */
   "helix-headless-table-column": DefineCustomElement<
     HelixHeadlessTableColumn,
     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', and 'columnheader'. Rows are 'display: contents', so their cells become items of the one grid.  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.  A column with 'sortable' and a 'field' 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. 'helix-sort' asks first, so you can refuse it and reorder the rows yourself.  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,
@@ -12907,7 +13647,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessTabVueProps,
     HelixHeadlessTabVueEvents
   >;
-  /** A label that people can optionally remove. 'dismissible' is the difference from a badge: a badge shows a state that people cannot change, and a tag names something they can remove.  The remove button sends 'helix-dismiss'. The tag does not remove itself, because your code owns the list it is in, so remove it in your handler. A listener can cancel 'helix-dismiss', and 'dismiss()' then returns 'false'. */
+  /** A label that people can optionally remove. 'dismissible' is the difference from a badge: a badge shows a state that people cannot change, and a tag names something they can remove.  The remove button sends 'helix-dismiss'. The tag does not remove itself, because your code owns the list it is in, so remove it in your handler. A listener can cancel 'helix-dismiss', and 'dismiss()' then returns 'false'. When the handler removes a tag whose remove button has focus, focus moves to the next tag's remove button, or to the previous one's after the last tag.  The remove button is named for its tag, such as "Remove Apple", so a list of buttons says which tag each one removes. Write '{label}' in 'dismiss-label' to put the tag's words somewhere else, such as 'dismiss-label="{label} entfernen"'. */
   "helix-headless-tag": DefineCustomElement<
     HelixHeadlessTag,
     HelixHeadlessTagVueProps,
@@ -12919,7 +13659,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessTextareaVueProps,
     HelixHeadlessTextareaVueEvents
   >;
-  /** The list is a 'TimePicker', which you can also use on its own, for example in a settings pane. This element adds the field, the overlay, and the form association, the same arrangement Date Input has with 'DatePicker' and Color Input has with 'ColorPicker'.  You can type a time or pick one. The list offers times at a step, and the field lets you enter any time, such as '09:07'.  The value is always 'HH:mm' on a 24-hour clock, because that is what the form submits, what 'min' and 'max' compare against, and what sorts correctly as a string. While idle, the field shows the time in the user's locale format. Once the caret is in the field, it shows the value itself, because a formatted time such as '2:30 PM' cannot be typed back and 'Intl' has no parser for it. */
+  /** The list is a 'TimePicker', which you can also use on its own, for example in a settings pane. This element adds the field, the overlay, and the form association, the same arrangement Date Input has with 'DatePicker' and Color Input has with 'ColorPicker'.  You can type a time or pick one. The list offers times at a step, and the field lets you enter any time, such as '09:07'.  The value is always 'HH:mm' on a 24-hour clock, because that is what the form submits, what 'min' and 'max' compare against, and what sorts correctly as a string. While idle, the field shows the time in the user's locale format. Once the caret is in the field, it shows the value itself, because a formatted time such as '2:30 PM' cannot be typed back and 'Intl' has no parser for it.  Typing sends 'input' on each keystroke and 'change' when you leave the field. In the list, the arrow keys, typed digits and PageUp and PageDown move through the times, and Enter, Space or a click chooses one and closes the panel. With 'variant="wheels"' each wheel moves the time as you turn it, the panel stays open, and Enter or Escape closes it. */
   "helix-headless-time-input": DefineCustomElement<
     HelixHeadlessTimeInput,
     HelixHeadlessTimeInputVueProps,
@@ -12949,7 +13689,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessToastItemVueProps,
     HelixHeadlessToastItemVueEvents
   >;
-  /** The region and its items are one family because a live region must be in the document before a message is added to it. Assistive technology often does not announce a region that arrives already holding its message. 'Radio.Group' is part of its family for the same reason.  **The region is polite, never assertive.** 'role="alert"' interrupts whatever a screen reader is reading. For something that cannot wait, use a 'Dialog', which stops the page for every user.  **The region never creates or removes items.** You render items and remove them. An item requests closing with a cancelable 'helix-dismiss' event. A dismissed item hides itself and stays in the DOM, so your framework's state and the DOM stay in sync. It hides on its own unless you set 'open', which makes the state yours.  There is no 'toast.show()'. For a 'toast()' function, write a small one over your app's state, which also lets you render the same messages on the server, in a test, or more than once. */
+  /** The region and its items are one family because a live region must be in the document before a message is added to it. Assistive technology often does not announce a region that arrives already holding its message. 'Radio.Group' is part of its family for the same reason.  **The region is polite, never assertive.** 'role="alert"' interrupts whatever a screen reader is reading. For something that cannot wait, use a 'Dialog', which stops the page for every user.  **The region never creates or removes items.** You render items and remove them. An item requests closing with a cancelable 'helix-dismiss' event. A dismissed item hides itself and stays in the DOM, so your framework's state and the DOM stay in sync. It hides on its own unless you set 'open', which makes the state yours.  There is no 'toast.show()'. For a 'toast()' function, write a small one over your app's state, which also lets you render the same messages on the server, in a test, or more than once.  **The stack is in the top layer.** The 'region' part is a 'popover="manual"' shown while a message is showing, and shown again above a modal dialog that opened after it. Position the 'region' part, which is the box in the top layer. While a modal 'Dialog', 'Drawer' or 'Lightbox' is open, the browser makes everything outside it inert, the stack included, so a message stays visible and its actions cannot be pressed. Where the browser has 'ariaNotify', a message that arrives then is announced through it. For a message with an action, render a second region inside the dialog.  When a message with focus inside it is dismissed, focus moves to the next message, then the one before it, then back to where it was before it entered the stack. */
   "helix-headless-toast": DefineCustomElement<
     HelixHeadlessToast,
     HelixHeadlessToastVueProps,
@@ -12967,43 +13707,43 @@ 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 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 nested composite, such as a 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. */
   "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.  Wrapping the trigger is the convenient form. Use it where the trigger already has an accessible name, because the tooltip cannot describe a slotted trigger: an IDREF cannot cross a shadow boundary.  To add a description, place the tooltip beside the trigger and name the trigger with 'for':  '''html <helix-headless-button id="save" aria-describedby="save-tip">Save</helix-headless-button> <helix-headless-tooltip id="save-tip" for="save" content="Save your work"></helix-headless-tooltip> '''  Write the 'aria-describedby' yourself, pointing at the tooltip host. Setting it at runtime causes a hydration mismatch that React does not fix. With 'for', the tooltip warns once on first open if the attribute is missing.  The tooltip shows on hover and on focus. It hides on pointer leave, on blur, on Escape, and when the trigger is activated. */
+  /** 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.  Wrapping the trigger is the convenient form. Use it where the trigger already has an accessible name, because the tooltip cannot describe a slotted trigger: an IDREF cannot cross a shadow boundary.  To add a description, place the tooltip beside the trigger and name the trigger with 'for':  '''html <helix-headless-button id="save" aria-describedby="save-tip">Save</helix-headless-button> <helix-headless-tooltip id="save-tip" for="save" content="Save your work"></helix-headless-tooltip> '''  Write the 'aria-describedby' yourself, pointing at the tooltip host. Setting it at runtime causes a hydration mismatch that React does not fix. With 'for', the tooltip warns once on first open if the attribute is missing.  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.  Once one tooltip is showing, moving to another trigger shows its tooltip with no 'delay', and the first one hides. The same holds for 300 milliseconds after a tooltip hides. */
   "helix-headless-tooltip": DefineCustomElement<
     HelixHeadlessTooltip,
     HelixHeadlessTooltipVueProps,
     HelixHeadlessTooltipVueEvents
   >;
-  /** The root holds the order of the stops: which stop is current, what Next and Back do, and when the tour is finished. Each stop holds its target, and you write all the text.  **The spotlight is a shadow.** The scrim is a box the size of the current target with a very large 'box-shadow' spread, and the shadow paints the darkness. A 'clip-path' on a full-screen scrim breaks as soon as an element between the scrim and the viewport is transformed.  The root measures the target's position in the browser. Nothing is measured on the server, because a tour starts only on request. */
+  /** The root holds the order of the stops: which stop is current, what Next and Back do, and when the tour is finished. Each stop holds its target, and you write all the text.  **The spotlight is a shadow.** The scrim is a box the size of the current target with a very large 'box-shadow' spread, and the shadow paints the darkness. A 'clip-path' on a full-screen scrim breaks as soon as an element between the scrim and the viewport is transformed.  The root measures the target's position in the browser. Nothing is measured on the server, because a tour starts only on request.  'open', 'default-open', 'helix-before-open', 'helix-before-close' and 'toggle' work as they do on 'Dialog'. Setting 'open' starts the run, and 'skip()' and 'requestOpen(false)' end it early.  **Focus follows the run.** Opening moves focus to the first stop's panel, and moving on from a control in a stop moves it to the next one. Ending the tour puts focus back on the element that had it when the tour opened, unless you have moved it somewhere else on the page. A stop does not trap focus, so you can still 'Tab' out to the element it describes. */
   "helix-headless-tour": DefineCustomElement<
     HelixHeadlessTour,
     HelixHeadlessTourVueProps,
     HelixHeadlessTourVueEvents
   >;
-  /** A stop names its target with 'for' and holds the content you put in it. The stop handles three things:  - **Placement.** The panel is anchored to the target by the same floating   positioning as the other Helix overlays. - **Stacking.** The panel is a popover, so it is in the top layer and shows   above dialogs, scrolling regions, and other stacking contexts. - **Visibility.** The stop shows when it is 'current', which the root sets.  Put any content in the stop, such as a 'Card', or a heading and a line of text. There are no fixed title or body parts.  **The buttons are slot fallback.** With nothing in the 'actions' slot, you get Back, Next, and Skip, already wired. Slot your own 'actions' and drive them with 'next()', 'back()', and 'skip()' on the root.  **'for' is an id, as with 'Tooltip'**, so you can point at a target elsewhere on the page from markup. It resolves against the stop's root node, so a stop inside a shadow tree points at a target in that tree. */
+  /** A stop names its target with 'for' and holds the content you put in it. The stop handles three things:  - **Placement.** The panel is anchored to the target by the same floating   positioning as the other Helix overlays. - **Stacking.** The panel is a popover, so it is in the top layer and shows   above dialogs, scrolling regions, and other stacking contexts. - **Visibility.** The stop shows when it is 'current', which the root sets.  Put any content in the stop, such as a 'Card', or a heading and a line of text. There are no fixed title or body parts.  **The buttons are slot fallback.** With nothing in the 'actions' slot, you get Back, Next, and Skip, already wired. Slot your own 'actions' and drive them with 'next()', 'back()', and 'skip()' on the root.  **'for' is an id, as with 'Tooltip'**, so you can point at a target elsewhere on the page from markup. It resolves against the stop's root node, so a stop inside a shadow tree points at a target in that tree.  The panel is a 'group', named by the first heading in the stop's content, and only while the stop is shown. 'focus()' moves focus to the panel, which is what the tour does when it opens or moves on. */
   "helix-headless-tour-stop": DefineCustomElement<
     HelixHeadlessTourStop,
     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. */
+  /** '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. */
   "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. */
+  /** 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. */
   "helix-headless-tree": DefineCustomElement<
     HelixHeadlessTree,
     HelixHeadlessTreeVueProps,
     HelixHeadlessTreeVueEvents
   >;
-  /** A trend has three parts: a direction of up, down, or neutral, the metric that moved, and a label for the period it moved over. The arrow shows the direction and its color shows whether the change is good. Direction and judgment are separate properties because they are separate facts.  'good' is unset by default, so a trend with no judgment is gray. For churn, latency, error rate, cost, and bounce rate, up is bad. Set the metric's polarity once with 'good', and the component picks the color from the direction.  The direction is also written as a word, so a screen reader reads it. The styled tier hides 'part="direction"' visually and keeps it in the accessibility tree.  The metric and the label are bare slots. An element that assigned its own slot on connect would add an attribute to its host after upgrade, which the React server markup did not have. */
+  /** A trend has three parts: a direction of up, down, or neutral, the metric that moved, and a label for the period it moved over. The arrow shows the direction and its color shows whether the change is good. Direction and judgment are separate properties because they are separate facts.  'good' is unset by default, so a trend with no judgment is gray. For churn, latency, error rate, cost, and bounce rate, up is bad. Set the metric's polarity once with 'good', and the component picks the color from the direction.  The direction is also written as a word, so a screen reader reads it. The styled tier hides 'part="direction"' visually and keeps it in the accessibility tree. The words are properties, 'up-label' through 'worse-label', so a page in another language can set its own.  The metric and the label are bare slots. An element that assigned its own slot on connect would add an attribute to its host after upgrade, which the React server markup did not have. */
   "helix-headless-trend": DefineCustomElement<
     HelixHeadlessTrend,
     HelixHeadlessTrendVueProps,
@@ -13033,7 +13773,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessVideoVueProps,
     HelixHeadlessVideoVueEvents
   >;
-  /** The items arrive as data:  - 'for' names a '<script type="application/json">' that holds an array of   objects. - A '<template>' child defines one row. Elements with 'data-field="name"' are   filled with that field of the item.  Both are markup. React hydration skips every property it would have to set imperatively, so an 'items' property would be lost, and light-DOM children would all exist before anything could window them. The JSON text is one node whatever the row count.  For assistive technology the list exposes the rendered window with 'aria-setsize'. Charts that use the same 'for="<id>"' shape render an accessible '<table>', and ten thousand rows in one is the cost this component avoids.  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:  - 'for' names a '<script type="application/json">' that holds an array of   objects. - A '<template>' child defines one row. Elements with 'data-field="name"' are   filled with that field of the item.  Both are markup. React hydration skips every property it would have to set imperatively, so an 'items' property would be lost, and light-DOM children would all exist before anything could window them. The JSON text is one node whatever the row count.  For assistive technology the list exposes the rendered window with 'aria-setsize'. Charts that use the same 'for="<id>"' shape render an accessible '<table>', and ten thousand rows in one is the cost this component avoids.  The list follows the source: editing the script's text, or replacing the script under the same id, draws the new rows. A row that stays in view keeps its element as the list scrolls, and the row holding focus stays drawn when it scrolls out, so a link or a button in a row keeps focus.  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,