@fusion.dev/helix 0.142.1 → 0.143.0

package/types/vue.d.ts

@@ -155,6 +155,7 @@ import type {
   HelixVideoPlaylist,
   HelixVideo,
   HelixVirtualList,
+  ToggleEvent,
   HelixBeforeCloseEvent,
   HelixBeforeOpenEvent,
   HelixDismissEvent,
@@ -172,9 +173,11 @@ import type {
   HelixRelabelEvent,
   HelixRemoveEvent,
   HelixSelectEvent,
+  HelixActivateEvent,
   HelixSendEvent,
   HelixBeforePinEvent,
   HelixHistoryEvent,
+  HelixPinEvent,
   HelixBeforeChangeEvent,
   HelixBeforeToggleEvent,
   HelixCopyEvent,
@@ -182,11 +185,14 @@ import type {
   HelixSampleStartEvent,
   HelixCreateEvent,
   HelixFilterEvent,
+  HelixFilteredEvent,
   HelixNavigateEvent,
   HelixReorderEvent,
+  HelixReorderedEvent,
+  HelixSelectedEvent,
   HelixSortEvent,
+  HelixSortedEvent,
   HelixFacetEvent,
-  HelixActivateEvent,
   HelixBeforeActivateEvent,
   HelixGraphFilterEvent,
   HelixGraphLayoutEvent,
@@ -213,6 +219,8 @@ import type {
   HelixCaretEvent,
   HelixBeforeCollapseEvent,
   HelixBeforeResizeEvent,
+  HelixCollapseEvent,
+  HelixResizedEvent,
   HelixTourAskEvent,
   HelixNextEvent,
   HelixPreviousEvent,
@@ -261,6 +269,9 @@ export type HelixAccordionItemElementEvent<E = Event> = TypedEvent<
   HelixAccordionItem,
   E
 >;
+/** `toggle` event type */
+export type HelixAccordionItemToggleElementEvent =
+  HelixAccordionItemElementEvent<ToggleEvent>;
 /** `helix-before-close` event type */
 export type HelixAccordionItemHelixBeforeCloseElementEvent =
   HelixAccordionItemElementEvent<HelixBeforeCloseEvent>;
@@ -304,6 +315,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?: (HelixAccordionItem["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?: (HelixAccordionItem["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"?: (HelixAccordionItem["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?: (HelixAccordionItem["headingLevel"]) | undefined;
   /** A group name. Opening an item closes the other items with the same name,
 as `<details name>` does.
 
@@ -326,12 +350,12 @@ absence. Caught by `hydration.dom.spec.ts`. */
 };
 
 export type HelixAccordionItemVueEvents = {
+  /** The section opened or closed. The event carries `newState` and `oldState`. */
+  toggle: HelixAccordionItemToggleElementEvent;
   /** The section is about to close. Cancelable: cancel it to keep it open. */
   "helix-before-close": HelixAccordionItemHelixBeforeCloseElementEvent;
   /** The section is about to open. Cancelable: cancel it to keep it closed. */
   "helix-before-open": HelixAccordionItemHelixBeforeOpenElementEvent;
-  /** The section opened or closed. The event carries `newState` and `oldState`. */
-  toggle: HelixAccordionItemElementEvent;
 };
 
 export type HelixAccordionVueProps = {
@@ -356,12 +380,25 @@ third statement and a fill a second.
 Both are writable, so a generated page can say which it means rather than
 relying on the absence of an attribute. */
   separation?: (HelixAccordion["separation"]) | 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. */
+  "heading-level"?: (HelixAccordion["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?: (HelixAccordion["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?: (HelixAccordion["mode"]) | undefined;
@@ -422,9 +459,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
@@ -529,6 +565,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?: (HelixAppHeader["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?: (HelixAppHeader["scroller"]) | undefined;
 };
 
 export type HelixAppHeaderVueEvents = {
@@ -551,6 +590,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?: (HelixAreaChart["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?: (HelixAreaChart["locale"]) | undefined;
   /** How a band's edge gets from one reading to the next.
 
 Three values, and the class doc argues for each: `straight` is absent and
@@ -720,6 +765,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?: (HelixAvatarGroup["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"?: (HelixAvatarGroup["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?: (HelixAvatarGroup["overflowLabel"]) | undefined;
 };
 
 export type HelixAvatarGroupVueEvents = {};
@@ -745,7 +800,9 @@ Used for the label and the initials. */
 Falls back to the slot, or to initials, if it fails. */
   src?: (HelixAvatar["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
@@ -923,6 +980,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?: (HelixBarChart["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?: (HelixBarChart["locale"]) | undefined;
   /** Which gridlines are drawn across the plot, if any.
 
 Absent draws none. `value` rules the axis the columns are *measured* on,
@@ -942,6 +1005,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?: (HelixBarChart["gridlines"]) | undefined;
+  /** The word the summary puts before each series' highest reading. */
+  "highest-label"?: (HelixBarChart["highestLabel"]) | undefined;
+  /** The word the summary puts before each series' highest reading. */
+  highestLabel?: (HelixBarChart["highestLabel"]) | undefined;
   /** The names of the series to draw as lines. The other series are drawn as
 columns.
 
@@ -973,8 +1040,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?: (HelixBarChart["orientation"]) | undefined;
   /** The names of the series measured against a second scale of their own.
 
@@ -1051,7 +1118,11 @@ The consumer's decision. */
 
 export type HelixBreadcrumbVueEvents = {};
 
-export type HelixBreadcrumbsVueProps = {};
+export type HelixBreadcrumbsVueProps = {
+  /** The landmark's name, read by screen readers. An `aria-label` on the host
+wins over it. */
+  label?: (HelixBreadcrumbs["label"]) | undefined;
+};
 
 export type HelixBreadcrumbsVueEvents = {};
 
@@ -1321,6 +1392,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?: (HelixCallout["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"?: (HelixCallout["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?: (HelixCallout["toneLabel"]) | undefined;
 };
 
 export type HelixCalloutVueEvents = {};
@@ -1973,6 +2054,9 @@ export type HelixCardVueEvents = {};
 
 /** `HelixCarousel` component event */
 export type HelixCarouselElementEvent<E = Event> = TypedEvent<HelixCarousel, E>;
+/** `helix-activate` event type */
+export type HelixCarouselHelixActivateElementEvent =
+  HelixCarouselElementEvent<HelixActivateEvent>;
 /** `helix-select` event type */
 export type HelixCarouselHelixSelectElementEvent =
   HelixCarouselElementEvent<HelixSelectEvent>;
@@ -2397,6 +2481,8 @@ case is the absent attribute, and the styles read it that way. */
 };
 
 export type HelixCarouselVueEvents = {
+  /** Fired after the slide in view changes, with the new index as a string in `detail.value`. */
+  "helix-activate": HelixCarouselHelixActivateElementEvent;
   /** 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": HelixCarouselHelixSelectElementEvent;
 };
@@ -2441,13 +2527,16 @@ has to mean a new line and nothing else. */
   submitOn?: (HelixChatComposer["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?: (HelixChatComposer["value"]) | undefined;
 };
 
 export type HelixChatComposerVueEvents = {
   /** Fired when the user sends their turn, and cancelable. */
   "helix-send": HelixChatComposerHelixSendElementEvent;
+  /** 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: HelixChatComposerElementEvent;
 };
 
 /** `HelixChatMessage` component event */
@@ -2532,6 +2621,9 @@ export type HelixChatHelixBeforePinElementEvent =
 /** `helix-history` event type */
 export type HelixChatHelixHistoryElementEvent =
   HelixChatElementEvent<HelixHistoryEvent>;
+/** `helix-pin` event type */
+export type HelixChatHelixPinElementEvent =
+  HelixChatElementEvent<HelixPinEvent>;
 /** `helix-send` event type */
 export type HelixChatHelixSendElementEvent =
   HelixChatElementEvent<HelixSendEvent>;
@@ -2619,6 +2711,8 @@ export type HelixChatVueEvents = {
   "helix-before-pin": HelixChatHelixBeforePinElementEvent;
   /** Fired when the user reaches the oldest turn while `history` is `more`. It reports the position and cannot be canceled. */
   "helix-history": HelixChatHelixHistoryElementEvent;
+  /** Fired after the transcript is pinned or unpinned, with `true` or `false` in `detail.value`. */
+  "helix-pin": HelixChatHelixPinElementEvent;
   /** 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": HelixChatHelixSendElementEvent;
 };
@@ -2637,9 +2731,7 @@ export type HelixCheckboxGroupVueProps = {
 column. */
   orientation?: (HelixCheckboxGroup["orientation"]) | undefined;
   /**  */
-  "aria-label"?: (HelixCheckboxGroup["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixCheckboxGroup["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixCheckboxGroup["feedback"]) | undefined;
@@ -2668,7 +2760,10 @@ and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   valueMissingMessage?: (HelixCheckboxGroup["valueMissingMessage"]) | undefined;
-  /** 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?: (HelixCheckboxGroup["value"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
@@ -2754,9 +2849,7 @@ stylesheets. */
   /** Whether the control starts checked. A form reset returns it to this state. */
   defaultChecked?: (HelixCheckbox["defaultChecked"]) | undefined;
   /**  */
-  "aria-label"?: (HelixCheckbox["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixCheckbox["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixCheckbox["feedback"]) | undefined;
@@ -2787,7 +2880,11 @@ the field and does not reach that one. */
   valueMissingMessage?: (HelixCheckbox["valueMissingMessage"]) | undefined;
   /** 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?: (HelixCheckbox["indeterminate"]) | undefined;
   /** The value submitted when the box is checked. */
   value?: (HelixCheckbox["value"]) | undefined;
@@ -2829,6 +2926,14 @@ export type HelixCheckboxVueEvents = {
 };
 
 export type HelixCodeBlockVueProps = {
+  /** The copy button's name and tooltip text after a copy. */
+  "copied-label"?: (HelixCodeBlock["copiedLabel"]) | undefined;
+  /** The copy button's name and tooltip text after a copy. */
+  copiedLabel?: (HelixCodeBlock["copiedLabel"]) | undefined;
+  /** The copy button's name and tooltip text before a copy. */
+  "copy-label"?: (HelixCodeBlock["copyLabel"]) | undefined;
+  /** The copy button's name and tooltip text before a copy. */
+  copyLabel?: (HelixCodeBlock["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
@@ -2898,6 +3003,9 @@ export type HelixColorInputElementEvent<E = Event> = TypedEvent<
   HelixColorInput,
   E
 >;
+/** `toggle` event type */
+export type HelixColorInputToggleElementEvent =
+  HelixColorInputElementEvent<ToggleEvent>;
 /** `helix-before-change` event type */
 export type HelixColorInputHelixBeforeChangeElementEvent =
   HelixColorInputElementEvent<HelixBeforeChangeEvent>;
@@ -2954,9 +3062,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixColorInput["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixColorInput["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixColorInput["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixColorInput["feedback"]) | undefined;
@@ -3010,6 +3116,16 @@ value spelled out. */
   noFormat?: (HelixColorInput["noFormat"]) | undefined;
   /** The text the field shows before a color is entered. */
   placeholder?: (HelixColorInput["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?: (HelixColorInput["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?: (HelixColorInput["readOnly"]) | undefined;
   /** Colors offered under the picker, as a comma-separated list. */
   swatches?: (HelixColorInput["swatches"]) | undefined;
   /** Accessible name for the control that opens the panel. */
@@ -3061,6 +3177,8 @@ Here rather than on each control. */
 };
 
 export type HelixColorInputVueEvents = {
+  /** The panel opened or closed. The event carries `newState` and `oldState`. */
+  toggle: HelixColorInputToggleElementEvent;
   /** Sent when the user finishes changing the value. */
   change: HelixColorInputElementEvent;
   /** The color is about to change. Cancelable: cancel it to keep the current color. */
@@ -3071,8 +3189,6 @@ export type HelixColorInputVueEvents = {
   "helix-before-open": HelixColorInputHelixBeforeOpenElementEvent;
   /** Fired as the value changes. */
   input: HelixColorInputElementEvent;
-  /** The panel opened or closed. The event carries `newState` and `oldState`. */
-  toggle: HelixColorInputElementEvent;
 };
 
 /** `HelixColorPicker` component event */
@@ -3117,6 +3233,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?: (HelixColorPicker["autocomplete"]) | undefined;
+  /** The message shown when the value is text that is not a color. */
+  "bad-input-message"?: (HelixColorPicker["badInputMessage"]) | undefined;
+  /** The message shown when the value is text that is not a color. */
+  badInputMessage?: (HelixColorPicker["badInputMessage"]) | undefined;
   /** What the square's vertical ramp is called.
 
 **Every word the picker speaks is a property**, so a page in another
@@ -3273,13 +3393,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?: (HelixColorPicker["required"]) | undefined;
   /** What the square's horizontal ramp is called. */
   "saturation-label"?: (HelixColorPicker["saturationLabel"]) | undefined;
@@ -3352,6 +3470,9 @@ export type HelixColorPickerVueEvents = {
 
 /** `HelixCombobox` component event */
 export type HelixComboboxElementEvent<E = Event> = TypedEvent<HelixCombobox, E>;
+/** `toggle` event type */
+export type HelixComboboxToggleElementEvent =
+  HelixComboboxElementEvent<ToggleEvent>;
 /** `helix-before-change` event type */
 export type HelixComboboxHelixBeforeChangeElementEvent =
   HelixComboboxElementEvent<HelixBeforeChangeEvent>;
@@ -3414,9 +3535,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixCombobox["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixCombobox["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixCombobox["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixCombobox["feedback"]) | undefined;
@@ -3457,7 +3576,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?: (HelixCombobox["creatable"]) | undefined;
   /** The text of the create row, shown before the typed words it adds. */
   "create-label"?: (HelixCombobox["createLabel"]) | undefined;
@@ -3500,6 +3620,16 @@ element is responsible for. */
   multiple?: (HelixCombobox["multiple"]) | undefined;
   /** Text shown while nothing has been chosen. */
   placeholder?: (HelixCombobox["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?: (HelixCombobox["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?: (HelixCombobox["readOnly"]) | undefined;
   /** The name of the control that removes one chosen option, with `{name}`
 filled in.
 
@@ -3555,6 +3685,8 @@ differently: they are one chooser to a consumer. */
 };
 
 export type HelixComboboxVueEvents = {
+  /** Fired when the panel opens or closes, with `newState` and `oldState`. */
+  toggle: HelixComboboxToggleElementEvent;
   /** Fired after the value changes. */
   change: HelixComboboxElementEvent;
   /** Fired before the chosen option changes. Cancelable: cancel it to keep the current option. */
@@ -3569,18 +3701,22 @@ export type HelixComboboxVueEvents = {
   "helix-filter": HelixComboboxHelixFilterElementEvent;
   /** Fired after the value changes. */
   input: HelixComboboxElementEvent;
-  /** Fired when the panel opens or closes, with `newState` and `oldState`. */
-  toggle: HelixComboboxElementEvent;
 };
 
 /** `HelixCommand` component event */
 export type HelixCommandElementEvent<E = Event> = TypedEvent<HelixCommand, E>;
+/** `toggle` event type */
+export type HelixCommandToggleElementEvent =
+  HelixCommandElementEvent<ToggleEvent>;
 /** `helix-before-close` event type */
 export type HelixCommandHelixBeforeCloseElementEvent =
   HelixCommandElementEvent<HelixBeforeCloseEvent>;
 /** `helix-before-open` event type */
 export type HelixCommandHelixBeforeOpenElementEvent =
   HelixCommandElementEvent<HelixBeforeOpenEvent>;
+/** `helix-filter` event type */
+export type HelixCommandHelixFilterElementEvent =
+  HelixCommandElementEvent<HelixFilterEvent>;
 /** `helix-select` event type */
 export type HelixCommandHelixSelectElementEvent =
   HelixCommandElementEvent<HelixSelectEvent>;
@@ -3615,19 +3751,30 @@ with: one key, said once. */
   hotkey?: (HelixCommand["hotkey"]) | undefined;
   /** Accessible name for the overlay, which has no visible heading. */
   label?: (HelixCommand["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?: (HelixCommand["loading"]) | undefined;
+  /** The text shown while the commands load. */
+  "loading-text"?: (HelixCommand["loadingText"]) | undefined;
+  /** The text shown while the commands load. */
+  loadingText?: (HelixCommand["loadingText"]) | undefined;
   /** The text shown in the filter field before anything is typed. */
   placeholder?: (HelixCommand["placeholder"]) | undefined;
 };
 
 export type HelixCommandVueEvents = {
+  /** The palette opened or closed. The event carries `newState` and `oldState`. */
+  toggle: HelixCommandToggleElementEvent;
   /** The palette is about to close. Cancelable: cancel it to keep it open. */
   "helix-before-close": HelixCommandHelixBeforeCloseElementEvent;
   /** The palette is about to open. Cancelable: cancel it to keep it closed. */
   "helix-before-open": HelixCommandHelixBeforeOpenElementEvent;
+  /** 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": HelixCommandHelixFilterElementEvent;
   /** A command was chosen. Cancelable: cancel it to keep the palette open. */
   "helix-select": HelixCommandHelixSelectElementEvent;
-  /** The palette opened or closed. The event carries `newState` and `oldState`. */
-  toggle: HelixCommandElementEvent;
 };
 
 /** `HelixCopyButton` component event */
@@ -3681,13 +3828,11 @@ world is called Copy. A consumer with a better word still sets it. */
   label?: (HelixCopyButton["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?: (HelixCopyButton["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>`
@@ -3846,21 +3991,36 @@ export type HelixDataTableElementEvent<E = Event> = TypedEvent<
   HelixDataTable,
   E
 >;
+/** `helix-activate` event type */
+export type HelixDataTableHelixActivateElementEvent =
+  HelixDataTableElementEvent<HelixActivateEvent>;
 /** `helix-filter` event type */
 export type HelixDataTableHelixFilterElementEvent =
   HelixDataTableElementEvent<HelixFilterEvent>;
+/** `helix-filtered` event type */
+export type HelixDataTableHelixFilteredElementEvent =
+  HelixDataTableElementEvent<HelixFilteredEvent>;
 /** `helix-navigate` event type */
 export type HelixDataTableHelixNavigateElementEvent =
   HelixDataTableElementEvent<HelixNavigateEvent>;
 /** `helix-reorder` event type */
 export type HelixDataTableHelixReorderElementEvent =
   HelixDataTableElementEvent<HelixReorderEvent>;
+/** `helix-reordered` event type */
+export type HelixDataTableHelixReorderedElementEvent =
+  HelixDataTableElementEvent<HelixReorderedEvent>;
 /** `helix-select` event type */
 export type HelixDataTableHelixSelectElementEvent =
   HelixDataTableElementEvent<HelixSelectEvent>;
+/** `helix-selected` event type */
+export type HelixDataTableHelixSelectedElementEvent =
+  HelixDataTableElementEvent<HelixSelectedEvent>;
 /** `helix-sort` event type */
 export type HelixDataTableHelixSortElementEvent =
   HelixDataTableElementEvent<HelixSortEvent>;
+/** `helix-sorted` event type */
+export type HelixDataTableHelixSortedElementEvent =
+  HelixDataTableElementEvent<HelixSortedEvent>;
 
 export type HelixDataTableVueProps = {
   /** The text shown and announced when there are no rows and none are loading. */
@@ -3925,6 +4085,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?: (HelixDataTable["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"?: (HelixDataTable["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?: (HelixDataTable["gapLabel"]) | undefined;
   /** The grid's name, read by screen readers. */
   label?: (HelixDataTable["label"]) | undefined;
   /** Where filtering, sorting, and paging happen. `client` does them in the
@@ -3937,6 +4103,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?: (HelixDataTable["mode"]) | undefined;
+  /** The built-in pagination's name for the button that moves forward a page. */
+  "next-label"?: (HelixDataTable["nextLabel"]) | undefined;
+  /** The built-in pagination's name for the button that moves forward a page. */
+  nextLabel?: (HelixDataTable["nextLabel"]) | undefined;
   /** The column order, as field names separated by spaces.
 
 A reader's move fires `helix-reorder` first, and refusing it leaves the
@@ -3951,6 +4121,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?: (HelixDataTable["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"?: (HelixDataTable["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?: (HelixDataTable["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
@@ -3974,11 +4150,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?: (HelixDataTable["paginated"]) | undefined;
+  /** The name of the built-in pagination's navigation landmark. */
+  "pagination-label"?: (HelixDataTable["paginationLabel"]) | undefined;
+  /** The name of the built-in pagination's navigation landmark. */
+  paginationLabel?: (HelixDataTable["paginationLabel"]) | undefined;
+  /** The built-in pagination's name for the button that moves back a page. */
+  "previous-label"?: (HelixDataTable["previousLabel"]) | undefined;
+  /** The built-in pagination's name for the button that moves back a page. */
+  previousLabel?: (HelixDataTable["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?: (HelixDataTable["reorderable"]) | undefined;
+  /** What screen readers hear when a search leaves one row. `{count}` is the count. */
+  "result-label"?: (HelixDataTable["resultLabel"]) | undefined;
+  /** What screen readers hear when a search leaves one row. `{count}` is the count. */
+  resultLabel?: (HelixDataTable["resultLabel"]) | undefined;
+  /** What screen readers hear when a search leaves any other number of rows.
+`{count}` is the count. */
+  "results-label"?: (HelixDataTable["resultsLabel"]) | undefined;
+  /** What screen readers hear when a search leaves any other number of rows.
+`{count}` is the count. */
+  resultsLabel?: (HelixDataTable["resultsLabel"]) | undefined;
   /** The field that identifies each row.
 
 **Needed before selection exists, not after.** Lit keys the rendered rows by
@@ -4010,6 +4204,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?: (HelixDataTable["selectable"]) | undefined;
+  /** The name of the checkbox in the heading that selects every row. */
+  "select-all-label"?: (HelixDataTable["selectAllLabel"]) | undefined;
+  /** The name of the checkbox in the heading that selects every row. */
+  selectAllLabel?: (HelixDataTable["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
@@ -4024,11 +4222,18 @@ rows are chosen. */
   /** What screen readers hear when the chosen rows change. `{count}` is how many
 rows are chosen. */
   selectedLabel?: (HelixDataTable["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"?: (HelixDataTable["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?: (HelixDataTable["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?: (HelixDataTable["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`. */
@@ -4079,16 +4284,26 @@ holds and reordering it under them is a mutation they did not ask for. */
 };
 
 export type HelixDataTableVueEvents = {
+  /** Fired after the page changes, with the new page as a string in `detail.value`. */
+  "helix-activate": HelixDataTableHelixActivateElementEvent;
   /** The search query is about to change. Cancelable: cancel it to keep the current query. */
   "helix-filter": HelixDataTableHelixFilterElementEvent;
+  /** Fired after the search query changes, with the new query. */
+  "helix-filtered": HelixDataTableHelixFilteredElementEvent;
   /** Another page was requested. Cancelable: cancel it to stay on the current page. */
   "helix-navigate": HelixDataTableHelixNavigateElementEvent;
-  /** 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": HelixDataTableHelixReorderElementEvent;
-  /** 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": HelixDataTableHelixReorderedElementEvent;
+  /** 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": HelixDataTableHelixSelectElementEvent;
+  /** Fired after the selection changes, with every selected key, separated by commas. */
+  "helix-selected": HelixDataTableHelixSelectedElementEvent;
   /** A different sort order was requested. Cancelable: cancel it to keep the current order. */
   "helix-sort": HelixDataTableHelixSortElementEvent;
+  /** Fired after the sort order changes, with the new order. */
+  "helix-sorted": HelixDataTableHelixSortedElementEvent;
 };
 
 /** `HelixDateInput` component event */
@@ -4096,6 +4311,9 @@ export type HelixDateInputElementEvent<E = Event> = TypedEvent<
   HelixDateInput,
   E
 >;
+/** `toggle` event type */
+export type HelixDateInputToggleElementEvent =
+  HelixDateInputElementEvent<ToggleEvent>;
 /** `helix-before-change` event type */
 export type HelixDateInputHelixBeforeChangeElementEvent =
   HelixDateInputElementEvent<HelixBeforeChangeEvent>;
@@ -4192,9 +4410,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixDateInput["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixDateInput["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixDateInput["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixDateInput["feedback"]) | undefined;
@@ -4229,6 +4445,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?: (HelixDateInput["autocomplete"]) | undefined;
+  /** The name of the calendar's grid of days, read by screen readers. */
+  "calendar-label"?: (HelixDateInput["calendarLabel"]) | undefined;
+  /** The name of the calendar's grid of days, read by screen readers. */
+  calendarLabel?: (HelixDateInput["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
@@ -4275,21 +4495,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?: (HelixDateInput["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"?: (HelixDateInput["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?: (HelixDateInput["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"?: (HelixDateInput["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?: (HelixDateInput["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"?: (HelixDateInput["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?: (HelixDateInput["firstDayOfWeek"]) | undefined;
   /** The language tag for the names of months and days in the calendar. */
   locale?: (HelixDateInput["locale"]) | undefined;
@@ -4310,8 +4538,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?: (HelixDateInput["months"]) | undefined;
+  /** The name of the calendar's control that moves to the next month. */
+  "next-label"?: (HelixDateInput["nextLabel"]) | undefined;
+  /** The name of the calendar's control that moves to the next month. */
+  nextLabel?: (HelixDateInput["nextLabel"]) | undefined;
   /** The text the field shows before a date is entered. */
   placeholder?: (HelixDateInput["placeholder"]) | undefined;
+  /** The name of the calendar's control that moves to the previous month. */
+  "previous-label"?: (HelixDateInput["previousLabel"]) | undefined;
+  /** The name of the calendar's control that moves to the previous month. */
+  previousLabel?: (HelixDateInput["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**,
@@ -4355,10 +4591,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?: (HelixDateInput["step"]) | undefined;
+  /** The message shown when a date is not on `step`. */
+  "step-mismatch-message"?: (HelixDateInput["stepMismatchMessage"]) | undefined;
+  /** The message shown when a date is not on `step`. */
+  stepMismatchMessage?: (HelixDateInput["stepMismatchMessage"]) | undefined;
   /** The name of the button that opens the calendar, read by screen readers. */
   "trigger-label"?: (HelixDateInput["triggerLabel"]) | undefined;
   /** The name of the button that opens the calendar, read by screen readers. */
   triggerLabel?: (HelixDateInput["triggerLabel"]) | undefined;
+  /** The message shown when `disable-dates` or `disable-days` bars a date. */
+  "unavailable-message"?: (HelixDateInput["unavailableMessage"]) | undefined;
+  /** The message shown when `disable-dates` or `disable-days` bars a date. */
+  unavailableMessage?: (HelixDateInput["unavailableMessage"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -4402,6 +4646,8 @@ reader makes in one of these. */
 };
 
 export type HelixDateInputVueEvents = {
+  /** Fired when the calendar opens or closes, with `newState` and `oldState`. */
+  toggle: HelixDateInputToggleElementEvent;
   /** Fired after the value changes. */
   change: HelixDateInputElementEvent;
   /** Fired before the date changes. Cancelable: call `preventDefault()` to keep the current date. */
@@ -4412,8 +4658,6 @@ export type HelixDateInputVueEvents = {
   "helix-before-open": HelixDateInputHelixBeforeOpenElementEvent;
   /** Fired after the value changes. */
   input: HelixDateInputElementEvent;
-  /** Fired when the calendar opens or closes, with `newState` and `oldState`. */
-  toggle: HelixDateInputElementEvent;
 };
 
 /** `HelixDatePicker` component event */
@@ -4456,17 +4700,27 @@ speaks it. Absent is the control's own sentence, in English. */
   "default-month"?: (HelixDatePicker["defaultMonth"]) | undefined;
   /** The month to open on when `month` is not set. */
   defaultMonth?: (HelixDatePicker["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"?: (HelixDatePicker["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?: (HelixDatePicker["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"?: (HelixDatePicker["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?: (HelixDatePicker["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"?: (HelixDatePicker["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?: (HelixDatePicker["firstDayOfWeek"]) | undefined;
   /** Whether the current selection fails validation. */
   invalid?: (HelixDatePicker["invalid"]) | undefined;
@@ -4509,6 +4763,18 @@ would otherwise still announce its controls in English. `attribute:`
 spelled out, since Lit lowercases a camelCase name rather than dash-casing
 it. */
   previousLabel?: (HelixDatePicker["previousLabel"]) | undefined;
+  /** The validation message for a date after `max`. `{max}` is replaced with
+`max`, written as a date in `locale`. */
+  "range-overflow-message"?: (HelixDatePicker["rangeOverflowMessage"]) | undefined;
+  /** The validation message for a date after `max`. `{max}` is replaced with
+`max`, written as a date in `locale`. */
+  rangeOverflowMessage?: (HelixDatePicker["rangeOverflowMessage"]) | undefined;
+  /** The validation message for a date before `min`. `{min}` is replaced with
+`min`, written as a date in `locale`. */
+  "range-underflow-message"?: (HelixDatePicker["rangeUnderflowMessage"]) | undefined;
+  /** The validation message for a date before `min`. `{min}` is replaced with
+`min`, written as a date in `locale`. */
+  rangeUnderflowMessage?: (HelixDatePicker["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
@@ -4547,6 +4813,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?: (HelixDatePicker["step"]) | undefined;
+  /** The validation message for a date that `step` skips. */
+  "step-mismatch-message"?: (HelixDatePicker["stepMismatchMessage"]) | undefined;
+  /** The validation message for a date that `step` skips. */
+  stepMismatchMessage?: (HelixDatePicker["stepMismatchMessage"]) | undefined;
+  /** The validation message for a date that `disable-dates` or `disable-days`
+bars. */
+  "unavailable-message"?: (HelixDatePicker["unavailableMessage"]) | undefined;
+  /** The validation message for a date that `disable-dates` or `disable-days`
+bars. */
+  unavailableMessage?: (HelixDatePicker["unavailableMessage"]) | undefined;
   /** The validation message for a required date picker with no date chosen. */
   "value-missing-message"?: (HelixDatePicker["valueMissingMessage"]) | undefined;
   /** The validation message for a required date picker with no date chosen. */
@@ -4660,6 +4936,9 @@ export type HelixDescriptionListVueEvents = {};
 
 /** `HelixDialog` component event */
 export type HelixDialogElementEvent<E = Event> = TypedEvent<HelixDialog, E>;
+/** `toggle` event type */
+export type HelixDialogToggleElementEvent =
+  HelixDialogElementEvent<ToggleEvent>;
 /** `helix-before-close` event type */
 export type HelixDialogHelixBeforeCloseElementEvent =
   HelixDialogElementEvent<HelixBeforeCloseEvent>;
@@ -4765,7 +5044,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?: (HelixDialog["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?: (HelixDialog["label"]) | undefined;
   /** Stops Escape and a press on the backdrop from closing the dialog.
 
@@ -4791,14 +5071,14 @@ survives to it and a consumer reading one back gets what they wrote. */
 };
 
 export type HelixDialogVueEvents = {
+  /** Sent when the dialog opens or closes, with `newState` and `oldState`. */
+  toggle: HelixDialogToggleElementEvent;
   /** Sent from the host after the dialog closes, because the native `close` event does not leave the shadow root. */
   close: HelixDialogElementEvent;
   /** Fired before it closes, and cancelable. */
   "helix-before-close": HelixDialogHelixBeforeCloseElementEvent;
   /** Fired before it opens, and cancelable. */
   "helix-before-open": HelixDialogHelixBeforeOpenElementEvent;
-  /** Sent when the dialog opens or closes, with `newState` and `oldState`. */
-  toggle: HelixDialogElementEvent;
 };
 
 export type HelixDividerVueProps = {
@@ -4877,6 +5157,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?: (HelixDonutChart["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?: (HelixDonutChart["locale"]) | undefined;
   /** The size of the hole in the middle of the ring.
 
 Absent is a ring with room for a total in it. `small` and `large` move the
@@ -4931,6 +5217,9 @@ export type HelixDonutChartVueEvents = {};
 
 /** `HelixDrawer` component event */
 export type HelixDrawerElementEvent<E = Event> = TypedEvent<HelixDrawer, E>;
+/** `toggle` event type */
+export type HelixDrawerToggleElementEvent =
+  HelixDrawerElementEvent<ToggleEvent>;
 /** `helix-before-close` event type */
 export type HelixDrawerHelixBeforeCloseElementEvent =
   HelixDrawerElementEvent<HelixBeforeCloseEvent>;
@@ -4994,7 +5283,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?: (HelixDrawer["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?: (HelixDrawer["label"]) | undefined;
   /** Whether the drawer blocks the page behind it.
 
@@ -5033,14 +5323,14 @@ survives to it and a consumer reading one back gets what they wrote. */
 };
 
 export type HelixDrawerVueEvents = {
+  /** Sent when the drawer opens or closes, with `newState` and `oldState`. */
+  toggle: HelixDrawerToggleElementEvent;
   /** Sent from the host after the drawer closes, because the native `close` event does not leave the shadow root. */
   close: HelixDrawerElementEvent;
   /** Fired before the panel closes, and cancelable. */
   "helix-before-close": HelixDrawerHelixBeforeCloseElementEvent;
   /** Fired before the panel opens, and cancelable. Canceling it keeps the panel closed. */
   "helix-before-open": HelixDrawerHelixBeforeOpenElementEvent;
-  /** Sent when the drawer opens or closes, with `newState` and `oldState`. */
-  toggle: HelixDrawerElementEvent;
 };
 
 /** `HelixDrilldownItem` component event */
@@ -5108,7 +5398,11 @@ say that without the component knowing what a row looks like. */
   "loading-text"?: (HelixDrilldown["loadingText"]) | undefined;
   /** The text shown and announced while the rows load. */
   loadingText?: (HelixDrilldown["loadingText"]) | undefined;
-  /** 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?: (HelixDrilldown["label"]) | undefined;
   /** The text of the back button. */
   "back-label"?: (HelixDrilldown["backLabel"]) | undefined;
@@ -5149,9 +5443,7 @@ export type HelixFileInputHelixBeforeChangeElementEvent =
 
 export type HelixFileInputVueProps = {
   /**  */
-  "aria-label"?: (HelixFileInput["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixFileInput["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixFileInput["feedback"]) | undefined;
@@ -5180,7 +5472,10 @@ and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   valueMissingMessage?: (HelixFileInput["valueMissingMessage"]) | undefined;
-  /** 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?: (HelixFileInput["accept"]) | undefined;
   /** Which camera or microphone a mobile picker should offer, if any. */
   capture?: (HelixFileInput["capture"]) | undefined;
@@ -5418,6 +5713,9 @@ export type HelixFilterInputElementEvent<E = Event> = TypedEvent<
   HelixFilterInput,
   E
 >;
+/** `toggle` event type */
+export type HelixFilterInputToggleElementEvent =
+  HelixFilterInputElementEvent<ToggleEvent>;
 /** `helix-before-change` event type */
 export type HelixFilterInputHelixBeforeChangeElementEvent =
   HelixFilterInputElementEvent<HelixBeforeChangeEvent>;
@@ -5483,9 +5781,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixFilterInput["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixFilterInput["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixFilterInput["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixFilterInput["feedback"]) | undefined;
@@ -5560,6 +5856,8 @@ Here rather than on each control. */
 };
 
 export type HelixFilterInputVueEvents = {
+  /** Fired when the suggestions panel opens or closes, with `newState` and `oldState`. */
+  toggle: HelixFilterInputToggleElementEvent;
   /** Fired from the input when the user finishes editing the text. */
   change: HelixFilterInputElementEvent;
   /** Fired as the text changes. Cancelable: call `preventDefault()` to keep the current text. */
@@ -5576,8 +5874,6 @@ export type HelixFilterInputVueEvents = {
   "helix-select": HelixFilterInputHelixSelectElementEvent;
   /** Fired when the text changes. */
   input: HelixFilterInputElementEvent;
-  /** Fired when the suggestions panel opens or closes, with `newState` and `oldState`. */
-  toggle: HelixFilterInputElementEvent;
 };
 
 export type HelixFlexVueProps = {
@@ -6024,12 +6320,19 @@ There is no `justifyContent` here for the same reason: the tracks are
 distribute. `columns`, `min` and `--grid-columns` are how a grid says how
 wide its tracks are. */
   alignItems?: (HelixGrid["alignItems"]) | undefined;
-  /** A fixed number of equal columns. */
+  /** A fixed number of equal columns.
+
+Two to six are plain CSS. Any other count is written into the shadow
+root's rule, which the server renders too. */
   columns?: (HelixGrid["columns"]) | undefined;
   /** The space between cells, as a step on the space scale. */
   gap?: (HelixGrid["gap"]) | undefined;
   /** The minimum column width. The grid fits as many columns as the width allows.
 
+A length, such as `12rem`, or `calc()`, `clamp()`, `min()`, `max()` and
+`var()` over lengths. Anything else is refused with a warning, and the grid
+lays out by `columns`.
+
 Takes precedence over `columns`: a grid that both fixes a count and reflows
 is two intentions in one element. */
   min?: (HelixGrid["min"]) | undefined;
@@ -6058,6 +6361,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?: (HelixHeatmap["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?: (HelixHeatmap["locale"]) | undefined;
   /** Shown when the table has no readings in it.
 
 Never shown while the table cannot be read at all, which is a server render
@@ -6358,6 +6667,9 @@ invoker without an id in the same tree needs. */
 
 export type HelixIconButtonVueEvents = {};
 
+/** `HelixIcon` component event */
+export type HelixIconElementEvent<E = Event> = TypedEvent<HelixIcon, E>;
+
 export type HelixIconVueProps = {
   /** The icon's name, read by screen readers. Set it for an icon that is not
 decorative. */
@@ -6393,7 +6705,10 @@ for. Set both and this wins, the value being the more specific statement. */
   icon?: (HelixIcon["icon"]) | undefined;
 };
 
-export type HelixIconVueEvents = {};
+export type HelixIconVueEvents = {
+  /** `name` matches no icon in the set, so nothing is drawn. */
+  error: HelixIconElementEvent;
+};
 
 /** `HelixImage` component event */
 export type HelixImageElementEvent<E = Event> = TypedEvent<HelixImage, E>;
@@ -6410,7 +6725,9 @@ is answering is whether this picture is a card's surface or a page's.
   /** 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?: (HelixImage["alt"]) | undefined;
   /** How the image is fetched across origins. It decides whether a canvas can
 read the image. */
@@ -6506,9 +6823,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixInput["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixInput["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixInput["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixInput["feedback"]) | undefined;
@@ -6537,6 +6852,9 @@ and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   valueMissingMessage?: (HelixInput["valueMissingMessage"]) | undefined;
+  /** Whether a phone capitalizes as the reader types: `off`, `sentences`,
+`words` or `characters`, as the platform's `autocapitalize`. */
+  autocapitalize?: (HelixInput["autocapitalize"]) | undefined;
   /** What the browser may autofill in the field, as an HTML `autocomplete`
 token.
 
@@ -6554,10 +6872,29 @@ is broken. */
   "clear-label"?: (HelixInput["clearLabel"]) | undefined;
   /** The accessible name of the clear button, which shows only an icon. */
   clearLabel?: (HelixInput["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?: (HelixInput["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?: (HelixInput["enterKeyHint"]) | undefined;
+  /** The keyboard a phone offers, as the platform's `inputmode`, such as
+`numeric` for a code typed as text. */
+  inputmode?: (HelixInput["inputMode"]) | undefined;
+  /** The keyboard a phone offers, as the platform's `inputmode`, such as
+`numeric` for a code typed as text. */
+  inputMode?: (HelixInput["inputMode"]) | undefined;
+  /** The greatest value, for `type="number"`. Number Input adds steppers and
+keys to the same bounds. */
+  max?: (HelixInput["max"]) | undefined;
   /** Most characters the value may have. */
   maxlength?: (HelixInput["maxLength"] | `${number}`) | undefined;
   /** Most characters the value may have. */
   maxLength?: (HelixInput["maxLength"]) | undefined;
+  /** The least value, for `type="number"`. */
+  min?: (HelixInput["min"]) | undefined;
   /** Fewest characters the value may have. */
   minlength?: (HelixInput["minLength"] | `${number}`) | undefined;
   /** Fewest characters the value may have. */
@@ -6609,6 +6946,9 @@ The state is `aria-pressed`, not this. */
 
 The state is `aria-pressed`, not this. */
   revealLabel?: (HelixInput["revealLabel"]) | undefined;
+  /** The step a valid value is a multiple of, counted from `min`, for
+`type="number"`. */
+  step?: (HelixInput["step"]) | undefined;
   /** The kind of text the field accepts. It sets the on-screen keyboard and the
 validation.
 
@@ -6682,11 +7022,16 @@ export type HelixKbdHelixShortcutElementEvent =
   HelixKbdElementEvent<HelixShortcutEvent>;
 
 export type HelixKbdVueProps = {
-  /** 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?: (HelixKbd["keys"]) | undefined;
   /** Where the chord is listened for. `control` listens inside the control the
 key sits in, and `document` listens on the whole page.
@@ -6800,6 +7145,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?: (HelixLegend["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?: (HelixLegend["label"]) | undefined;
 };
 
 export type HelixLegendVueEvents = {};
@@ -6809,7 +7159,8 @@ export type HelixLightboxItemVueProps = {
 
 Written by the root, which is the only thing that sees the set. */
   current?: (HelixLightboxItem["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?: (HelixLightboxItem["label"]) | undefined;
   /** The item's identifier. The root compares its `active` value against it. */
   value?: (HelixLightboxItem["value"]) | undefined;
@@ -6822,6 +7173,9 @@ export type HelixLightboxElementEvent<E = Event> = TypedEvent<HelixLightbox, E>;
 /** `helix-activate` event type */
 export type HelixLightboxHelixActivateElementEvent =
   HelixLightboxElementEvent<HelixActivateEvent>;
+/** `toggle` event type */
+export type HelixLightboxToggleElementEvent =
+  HelixLightboxElementEvent<ToggleEvent>;
 /** `helix-before-activate` event type */
 export type HelixLightboxHelixBeforeActivateElementEvent =
   HelixLightboxElementEvent<HelixBeforeActivateEvent>;
@@ -6885,15 +7239,15 @@ keep the chrome up is the consumer's to decide with this. */
   label?: (HelixLightbox["label"]) | undefined;
   /** Whether moving past the last item returns to the first. */
   loop?: (HelixLightbox["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"?: (HelixLightbox["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
@@ -6904,6 +7258,8 @@ counter in the chrome can empty this and say it themselves. */
 export type HelixLightboxVueEvents = {
   /** Fired after the shown item changes, when the element already holds the new item. */
   "helix-activate": HelixLightboxHelixActivateElementEvent;
+  /** Fired when the viewer opens or closes, with `newState` and `oldState`. */
+  toggle: HelixLightboxToggleElementEvent;
   /** Fired when the viewer closes. The component dispatches it again from the host, because the dialog's own event does not leave the shadow root. */
   close: HelixLightboxElementEvent;
   /** Fired before the shown item changes. Cancelable: cancel it to keep the current item. It is the only way to stop the change. */
@@ -6912,8 +7268,6 @@ export type HelixLightboxVueEvents = {
   "helix-before-close": HelixLightboxHelixBeforeCloseElementEvent;
   /** Fired before the viewer opens. Cancelable. */
   "helix-before-open": HelixLightboxHelixBeforeOpenElementEvent;
-  /** Fired when the viewer opens or closes, with `newState` and `oldState`. */
-  toggle: HelixLightboxElementEvent;
 };
 
 export type HelixLineChartVueProps = {
@@ -6971,6 +7325,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?: (HelixLineChart["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?: (HelixLineChart["locale"]) | undefined;
   /** Draws a wash under each line, down to the floor of the plot. The washes
 overlap and do not add up, so for parts that make a total, use
 `Area Chart`, which stacks them.
@@ -7181,9 +7541,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixListbox["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixListbox["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixListbox["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixListbox["feedback"]) | undefined;
@@ -7241,6 +7599,13 @@ own search boxes would be three copies of one field. */
   "filter-label"?: (HelixListbox["filterLabel"]) | undefined;
   /** Placeholder text for the filter field. */
   filterLabel?: (HelixListbox["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?: (HelixListbox["manual"]) | undefined;
   /** Whether more than one option can be chosen. */
   multiple?: (HelixListbox["multiple"]) | undefined;
   /** Whether the control is disabled and cannot be used.
@@ -7294,7 +7659,7 @@ export type HelixListboxVueEvents = {
 };
 
 export type HelixLoaderVueProps = {
-  /** Diameter relative to the surrounding text. */
+  /** Diameter, from the loader size tokens. */
   size?: (HelixLoader["size"]) | undefined;
   /** How the loader is drawn. Leave it unset for a spinning arc, or set `pulse`.
 
@@ -7649,6 +8014,12 @@ export type HelixMapElementEvent<E = Event> = TypedEvent<HelixMap, E>;
 /** `helix-activate` event type */
 export type HelixMapHelixActivateElementEvent =
   HelixMapElementEvent<HelixActivateEvent>;
+/** `helix-before-change` event type */
+export type HelixMapHelixBeforeChangeElementEvent =
+  HelixMapElementEvent<HelixBeforeChangeEvent>;
+/** `helix-before-toggle` event type */
+export type HelixMapHelixBeforeToggleElementEvent =
+  HelixMapElementEvent<HelixBeforeToggleEvent>;
 /** `helix-map-cluster` event type */
 export type HelixMapHelixMapClusterElementEvent =
   HelixMapElementEvent<HelixMapClusterEvent>;
@@ -7973,8 +8344,14 @@ current, and the map says it after a zoom. */
 };
 
 export type HelixMapVueEvents = {
+  /** The layers menu changed the map type, which `map-type` now holds. */
+  change: HelixMapElementEvent;
   /** 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": HelixMapHelixActivateElementEvent;
+  /** 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": HelixMapHelixBeforeChangeElementEvent;
+  /** 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": HelixMapHelixBeforeToggleElementEvent;
   /** A cluster was pressed. Sent from the marker that shows the cluster, with the names of its places. */
   "helix-map-cluster": HelixMapHelixMapClusterElementEvent;
   /** A pan button or arrow key was pressed. Move your map in response. */
@@ -8069,6 +8446,9 @@ export type HelixMapTerrainVueEvents = {
 
 /** `HelixMegamenu` component event */
 export type HelixMegamenuElementEvent<E = Event> = TypedEvent<HelixMegamenu, E>;
+/** `toggle` event type */
+export type HelixMegamenuToggleElementEvent =
+  HelixMegamenuElementEvent<ToggleEvent>;
 /** `helix-before-close` event type */
 export type HelixMegamenuHelixBeforeCloseElementEvent =
   HelixMegamenuElementEvent<HelixBeforeCloseEvent>;
@@ -8186,16 +8566,19 @@ no other family is being asked the same question. */
 };
 
 export type HelixMegamenuVueEvents = {
+  /** The panel opened or closed. Carries `newState` and `oldState`. */
+  toggle: HelixMegamenuToggleElementEvent;
   /** The panel is about to close. Cancelable. */
   "helix-before-close": HelixMegamenuHelixBeforeCloseElementEvent;
   /** The panel is about to open. Cancelable. */
   "helix-before-open": HelixMegamenuHelixBeforeOpenElementEvent;
-  /** The panel opened or closed. Carries `newState` and `oldState`. */
-  toggle: HelixMegamenuElementEvent;
 };
 
 /** `HelixMenuItem` component event */
 export type HelixMenuItemElementEvent<E = Event> = TypedEvent<HelixMenuItem, E>;
+/** `helix-before-toggle` event type */
+export type HelixMenuItemHelixBeforeToggleElementEvent =
+  HelixMenuItemElementEvent<HelixBeforeToggleEvent>;
 /** `helix-select` event type */
 export type HelixMenuItemHelixSelectElementEvent =
   HelixMenuItemElementEvent<HelixSelectEvent>;
@@ -8209,9 +8592,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?: (HelixMenuItem["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?: (HelixMenuItem["checked"]) | undefined;
   /** Whether the row is disabled, so it cannot be chosen. */
   disabled?: (HelixMenuItem["disabled"]) | undefined;
@@ -8223,11 +8612,11 @@ about who may name a file on somebody's disk rather than a gap here. */
   download?: (HelixMenuItem["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. */
@@ -8275,12 +8664,16 @@ Three levels deep, the topmost row holds the slot the middle one lives in. */
 };
 
 export type HelixMenuItemVueEvents = {
+  /** 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": HelixMenuItemHelixBeforeToggleElementEvent;
   /** The row was chosen. Cancelable: cancel it to keep the menu open. */
   "helix-select": HelixMenuItemHelixSelectElementEvent;
 };
 
 /** `HelixMenu` component event */
 export type HelixMenuElementEvent<E = Event> = TypedEvent<HelixMenu, E>;
+/** `toggle` event type */
+export type HelixMenuToggleElementEvent = HelixMenuElementEvent<ToggleEvent>;
 /** `helix-before-close` event type */
 export type HelixMenuHelixBeforeCloseElementEvent =
   HelixMenuElementEvent<HelixBeforeCloseEvent>;
@@ -8327,7 +8720,11 @@ the resolved state for stylesheets, which is what the mirror is for. */
   "back-label"?: (HelixMenu["backLabel"]) | undefined;
   /** The text of the row that returns from a submenu. */
   backLabel?: (HelixMenu["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?: (HelixMenu["label"]) | undefined;
   /** Space between the trigger and the surface, in pixels. */
   offset?: (HelixMenu["offset"]) | undefined;
@@ -8338,14 +8735,14 @@ It moves if that side does not fit. */
 };
 
 export type HelixMenuVueEvents = {
+  /** The menu opened or closed. The event carries `newState` and `oldState`. */
+  toggle: HelixMenuToggleElementEvent;
   /** The menu is about to close. Cancelable: cancel it to keep it open. */
   "helix-before-close": HelixMenuHelixBeforeCloseElementEvent;
   /** The menu is about to open. Cancelable: cancel it to keep it closed. */
   "helix-before-open": HelixMenuHelixBeforeOpenElementEvent;
   /** An item was chosen. Cancelable: cancel it to keep the menu open. */
   "helix-select": HelixMenuHelixSelectElementEvent;
-  /** The menu opened or closed. The event carries `newState` and `oldState`. */
-  toggle: HelixMenuElementEvent;
 };
 
 export type HelixMeterVueProps = {
@@ -8402,6 +8799,10 @@ Absent leaves the range unbanded. */
   high?: (HelixMeter["high"]) | undefined;
   /** Accessible name for the reading. */
   label?: (HelixMeter["label"]) | undefined;
+  /** The locale the percentage is written in, such as `fr` for `72 %`.
+
+Absent uses the runtime's own. */
+  locale?: (HelixMeter["locale"]) | undefined;
   /** Top of the low band.
 
 Absent leaves the range unbanded. */
@@ -8466,7 +8867,11 @@ fair summary of a task and a poor one of a quantity. */
 export type HelixMeterVueEvents = {};
 
 export type HelixNavigationVueProps = {
-  /** 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?: (HelixNavigation["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
@@ -8487,6 +8892,9 @@ export type HelixNotificationGroupHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixNotificationGroupHelixBeforeOpenElementEvent =
   HelixNotificationGroupElementEvent<HelixBeforeOpenEvent>;
+/** `toggle` event type */
+export type HelixNotificationGroupToggleElementEvent =
+  HelixNotificationGroupElementEvent<ToggleEvent>;
 
 export type HelixNotificationGroupVueProps = {
   /** Whether the element starts open. Ignored once `open` is written. */
@@ -8531,6 +8939,8 @@ export type HelixNotificationGroupVueEvents = {
   "helix-before-close": HelixNotificationGroupHelixBeforeCloseElementEvent;
   /** Fired before the group expands. Cancelable: cancel it to keep the group collapsed. */
   "helix-before-open": HelixNotificationGroupHelixBeforeOpenElementEvent;
+  /** The group expanded or collapsed. The event carries `newState` and `oldState`. */
+  toggle: HelixNotificationGroupToggleElementEvent;
 };
 
 /** `HelixNotification` component event */
@@ -8609,6 +9019,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?: (HelixNotification["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"?: (HelixNotification["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?: (HelixNotification["unreadLabel"]) | undefined;
 };
 
 export type HelixNotificationVueEvents = {
@@ -8686,9 +9106,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixNumberInput["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixNumberInput["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixNumberInput["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixNumberInput["feedback"]) | undefined;
@@ -8760,6 +9178,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?: (HelixNumberInput["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?: (HelixNumberInput["locale"]) | undefined;
   /** The largest value allowed.
 
 Absent has no ceiling. */
@@ -8797,8 +9222,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?: (HelixNumberInput["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?: (HelixNumberInput["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"?: (HelixNumberInput["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?: (HelixNumberInput["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"?: (HelixNumberInput["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?: (HelixNumberInput["valueText"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -8888,6 +9334,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?: (HelixObjectInspector["for"]) | undefined;
+  /** How an array of one entry counts it. `{count}` is replaced with the count. */
+  "item-label"?: (HelixObjectInspector["itemLabel"]) | undefined;
+  /** How an array of one entry counts it. `{count}` is replaced with the count. */
+  itemLabel?: (HelixObjectInspector["itemLabel"]) | undefined;
+  /** How an array of any other number of entries counts them. `{count}` is replaced with the count. */
+  "items-label"?: (HelixObjectInspector["itemsLabel"]) | undefined;
+  /** How an array of any other number of entries counts them. `{count}` is replaced with the count. */
+  itemsLabel?: (HelixObjectInspector["itemsLabel"]) | undefined;
+  /** How an object of one key counts it. `{count}` is replaced with the count. */
+  "key-label"?: (HelixObjectInspector["keyLabel"]) | undefined;
+  /** How an object of one key counts it. `{count}` is replaced with the count. */
+  keyLabel?: (HelixObjectInspector["keyLabel"]) | undefined;
+  /** How an object of any other number of keys counts them. `{count}` is replaced with the count. */
+  "keys-label"?: (HelixObjectInspector["keysLabel"]) | undefined;
+  /** How an object of any other number of keys counts them. `{count}` is replaced with the count. */
+  keysLabel?: (HelixObjectInspector["keysLabel"]) | undefined;
   /** Accessible name for the tree, and the text of the header where there is one. */
   label?: (HelixObjectInspector["label"]) | undefined;
   /** Hides the copy button.
@@ -8914,6 +9376,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?: (HelixObjectInspector["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"?: (HelixObjectInspector["treeLabel"]) | undefined;
+  /** The tree's accessible name when `label` is empty and the host names it
+with neither `aria-label` nor `aria-labelledby`. */
+  treeLabel?: (HelixObjectInspector["treeLabel"]) | undefined;
   /** Whether to draw only the rows in view.
 
 For a value of thousands of entries. Reflected, because the box it scrolls
@@ -8947,11 +9415,15 @@ export type HelixOptionHelixSelectElementEvent =
 export type HelixOptionVueProps = {
   /** 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"?: (HelixOption["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?: (HelixOption["active"]) | undefined;
   /** A second destination for the row, opened when you choose it with the
 modifier key held.
@@ -9089,6 +9561,11 @@ Not reflected: no rule selects on it, because the state is drawn rather than
 styled. A consumer writing the attribute can still select on their own
 markup. */
   state?: (HelixOrb["state"]) | undefined;
+  /** The word for each state, for a page in another language.
+
+A state left out keeps its English word, and `label` wins over both. It is
+a property with no attribute, keyed by state, such as `{ thinking: '…' }`. */
+  stateLabels?: (HelixOrb["stateLabels"]) | undefined;
 };
 
 export type HelixOrbVueEvents = {};
@@ -9142,6 +9619,9 @@ export type HelixPaginationElementEvent<E = Event> = TypedEvent<
   HelixPagination,
   E
 >;
+/** `helix-activate` event type */
+export type HelixPaginationHelixActivateElementEvent =
+  HelixPaginationElementEvent<HelixActivateEvent>;
 /** `helix-navigate` event type */
 export type HelixPaginationHelixNavigateElementEvent =
   HelixPaginationElementEvent<HelixNavigateEvent>;
@@ -9289,7 +9769,9 @@ to a reader, and takes its own. */
 };
 
 export type HelixPaginationVueEvents = {
-  /** 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": HelixPaginationHelixActivateElementEvent;
+  /** 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": HelixPaginationHelixNavigateElementEvent;
 };
 
@@ -9328,8 +9810,12 @@ Reading gives the real one; writing declares it the consumer's, and
 };
 
 export type HelixPaginationSizeVueEvents = {
+  /** Fired after the size changes. */
+  change: HelixPaginationSizeElementEvent;
   /** Fired before the size changes, and cancelable. Canceling it is the only way to stop a size change. */
   "helix-before-change": HelixPaginationSizeHelixBeforeChangeElementEvent;
+  /** Fired after the size changes, with `change`. */
+  input: HelixPaginationSizeElementEvent;
 };
 
 export type HelixPaginationSummaryVueProps = {
@@ -9386,9 +9872,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixPinInput["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixPinInput["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixPinInput["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixPinInput["feedback"]) | undefined;
@@ -9514,6 +9998,9 @@ export type HelixPinInputVueEvents = {
 
 /** `HelixPopover` component event */
 export type HelixPopoverElementEvent<E = Event> = TypedEvent<HelixPopover, E>;
+/** `toggle` event type */
+export type HelixPopoverToggleElementEvent =
+  HelixPopoverElementEvent<ToggleEvent>;
 /** `helix-before-close` event type */
 export type HelixPopoverHelixBeforeCloseElementEvent =
   HelixPopoverElementEvent<HelixBeforeCloseEvent>;
@@ -9561,12 +10048,12 @@ It moves if that side does not fit. */
 };
 
 export type HelixPopoverVueEvents = {
+  /** Fired after the panel opens or closes, with `newState` and `oldState`. */
+  toggle: HelixPopoverToggleElementEvent;
   /** Fired before it closes, and cancelable. */
   "helix-before-close": HelixPopoverHelixBeforeCloseElementEvent;
   /** Fired before it opens, and cancelable. */
   "helix-before-open": HelixPopoverHelixBeforeOpenElementEvent;
-  /** Fired after the panel opens or closes, with `newState` and `oldState`. */
-  toggle: HelixPopoverElementEvent;
 };
 
 export type HelixProgressVueProps = {
@@ -9603,8 +10090,17 @@ place in the layout when the answer arrives and it becomes determinate. */
   indeterminate?: (HelixProgress["indeterminate"]) | undefined;
   /** Accessible name for what is in progress. */
   label?: (HelixProgress["label"]) | undefined;
+  /** The locale the percentage is written in, such as `fr` for `72 %`.
+
+Absent uses the runtime's own. */
+  locale?: (HelixProgress["locale"]) | undefined;
   /** The total the work is measured against. */
   max?: (HelixProgress["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?: (HelixProgress["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
@@ -9641,7 +10137,7 @@ saying "uploading" while the bar runs. */
   showValue?: (HelixProgress["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?: (HelixProgress["value"]) | undefined;
   /** Text that describes the value when the number alone is not enough, such as
@@ -9664,6 +10160,9 @@ report progress. */
 
 export type HelixProgressVueEvents = {};
 
+/** `HelixQrCode` component event */
+export type HelixQrCodeElementEvent<E = Event> = TypedEvent<HelixQrCode, E>;
+
 export type HelixQrCodeVueProps = {
   /** The error correction level, which sets how much of the code can be lost
 and still scan.
@@ -9697,7 +10196,10 @@ which is what makes it read as dots rather than as a softened square code. */
   value?: (HelixQrCode["value"]) | undefined;
 };
 
-export type HelixQrCodeVueEvents = {};
+export type HelixQrCodeVueEvents = {
+  /** The value is too long for a code at the correction level, so no code is drawn. */
+  error: HelixQrCodeElementEvent;
+};
 
 export type HelixQuoteVueProps = {
   /** URL identifying where the quotation came from. */
@@ -9731,9 +10233,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixRadioGroup["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixRadioGroup["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixRadioGroup["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixRadioGroup["feedback"]) | undefined;
@@ -9797,6 +10297,16 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixRadioGroup["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?: (HelixRadioGroup["focusable"]) | undefined;
 };
 
 export type HelixRadioGroupVueEvents = {
@@ -9923,11 +10433,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?: (HelixRadio["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
@@ -9986,9 +10499,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixRating["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixRating["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixRating["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixRating["feedback"]) | undefined;
@@ -10060,6 +10571,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?: (HelixRating["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"?: (HelixRating["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?: (HelixRating["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,
@@ -10348,11 +10871,18 @@ gives. */
   "panel-size"?: (HelixSandbox["panelSize"] | `${number}`) | undefined;
   /** Height of the panel, in pixels. */
   panelSize?: (HelixSandbox["panelSize"]) | undefined;
-  /** The name of the divider between the panes, read by screen readers. */
+  /** The name of the divider between the panes, read by screen readers.
+
+Empty names the lead pane, "Resize source pane" or "Resize preview pane",
+since the divider's value is that pane's share. */
   "separator-label"?: (HelixSandbox["separatorLabel"]) | undefined;
-  /** The name of the divider between the panes, read by screen readers. */
+  /** The name of the divider between the panes, read by screen readers.
+
+Empty names the lead pane, "Resize source pane" or "Resize preview pane",
+since the divider's value is that pane's share. */
   separatorLabel?: (HelixSandbox["separatorLabel"]) | undefined;
-  /** Percentage of the sandbox given to the source pane. */
+  /** Percentage of the sandbox given to the lead pane: the source, unless `lead`
+is `preview`. */
   split?: (HelixSandbox["split"]) | undefined;
 };
 
@@ -10388,6 +10918,10 @@ export type HelixSandboxSourceVueProps = {
   "field-label"?: (HelixSandboxSource["fieldLabel"]) | undefined;
   /** The editable region's name, read by screen readers. */
   fieldLabel?: (HelixSandboxSource["fieldLabel"]) | undefined;
+  /** The field's description, read by screen readers while Tab indents. */
+  "keys-description"?: (HelixSandboxSource["keysDescription"]) | undefined;
+  /** The field's description, read by screen readers while Tab indents. */
+  keysDescription?: (HelixSandboxSource["keysDescription"]) | undefined;
   /** Which source this pane holds. Every `helix-before-edit` event includes it.
 
 `html` and `css` are what the sandbox root routes on; any other name is
@@ -10455,6 +10989,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?: (HelixScatterChart["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?: (HelixScatterChart["locale"]) | undefined;
   /** The word the summary uses for the strength of the relation. */
   "correlation-label"?: (HelixScatterChart["correlationLabel"]) | undefined;
   /** The word the summary uses for the strength of the relation. */
@@ -10485,6 +11025,9 @@ export type HelixScrollAreaVueEvents = {};
 
 /** `HelixSelect` component event */
 export type HelixSelectElementEvent<E = Event> = TypedEvent<HelixSelect, E>;
+/** `toggle` event type */
+export type HelixSelectToggleElementEvent =
+  HelixSelectElementEvent<ToggleEvent>;
 /** `helix-before-change` event type */
 export type HelixSelectHelixBeforeChangeElementEvent =
   HelixSelectElementEvent<HelixBeforeChangeEvent>;
@@ -10494,6 +11037,9 @@ export type HelixSelectHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixSelectHelixBeforeOpenElementEvent =
   HelixSelectElementEvent<HelixBeforeOpenEvent>;
+/** `helix-filter` event type */
+export type HelixSelectHelixFilterElementEvent =
+  HelixSelectElementEvent<HelixFilterEvent>;
 
 export type HelixSelectVueProps = {
   /** How strongly the trigger is drawn. Leave it unset for a framed field, or
@@ -10559,9 +11105,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixSelect["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixSelect["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixSelect["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixSelect["feedback"]) | undefined;
@@ -10649,6 +11193,8 @@ differently: they are one chooser to a consumer. */
 };
 
 export type HelixSelectVueEvents = {
+  /** Fired after the list opens or closes, with `newState` and `oldState`. */
+  toggle: HelixSelectToggleElementEvent;
   /** Fired after the value changes. */
   change: HelixSelectElementEvent;
   /** Relayed from the listbox when the value is about to change. Cancelable: canceling it stops the change and leaves the decision to you. */
@@ -10657,17 +11203,24 @@ export type HelixSelectVueEvents = {
   "helix-before-close": HelixSelectHelixBeforeCloseElementEvent;
   /** Fired before the list opens. Cancelable: canceling it keeps the list closed and leaves the decision to you. */
   "helix-before-open": HelixSelectHelixBeforeOpenElementEvent;
+  /** 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": HelixSelectHelixFilterElementEvent;
   /** Fired after the value changes. */
   input: HelixSelectElementEvent;
-  /** Fired after the list opens or closes, with `newState` and `oldState`. */
-  toggle: HelixSelectElementEvent;
 };
 
 export type HelixSkeletonVueProps = {
   /** The shape of the placeholder: `text`, `circle`, or a block when unset.
 
-Unset is a block, which is what most missing things are. */
+Unset is a block, which is what most missing things are. A block is the
+control height until you size it, with a height on the element or
+`--skeleton-block-size`. */
   shape?: (HelixSkeleton["shape"]) | undefined;
+  /** What is loading, read out as the placeholder's name, such as "Loading
+profile".
+
+Absent hides the placeholder from screen readers. */
+  label?: (HelixSkeleton["label"]) | undefined;
 };
 
 export type HelixSkeletonVueEvents = {};
@@ -10708,9 +11261,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixSlider["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixSlider["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixSlider["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixSlider["feedback"]) | undefined;
@@ -10804,6 +11355,12 @@ the two, since a range has no single number. */
   showValue?: (HelixSlider["showValue"]) | undefined;
   /** How far one press of an arrow key moves the thumb. */
   step?: (HelixSlider["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"?: (HelixSlider["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?: (HelixSlider["valueText"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -10945,8 +11502,8 @@ than announced without a name. */
   label?: (HelixSparkline["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
@@ -10973,10 +11530,10 @@ is markup, the same reason `curve` lives here. */
   plot?: (HelixSparkline["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?: (HelixSparkline["values"]) | undefined;
 };
 
@@ -11008,6 +11565,9 @@ export type HelixSpeedDialElementEvent<E = Event> = TypedEvent<
   HelixSpeedDial,
   E
 >;
+/** `toggle` event type */
+export type HelixSpeedDialToggleElementEvent =
+  HelixSpeedDialElementEvent<ToggleEvent>;
 /** `helix-before-close` event type */
 export type HelixSpeedDialHelixBeforeCloseElementEvent =
   HelixSpeedDialElementEvent<HelixBeforeCloseEvent>;
@@ -11049,14 +11609,14 @@ bottom of the window and there is nothing below it to fan into. */
 };
 
 export type HelixSpeedDialVueEvents = {
+  /** The dial opened or closed. The event carries `newState` and `oldState`. */
+  toggle: HelixSpeedDialToggleElementEvent;
   /** The actions are about to close. Cancelable: cancel it to keep them open. */
   "helix-before-close": HelixSpeedDialHelixBeforeCloseElementEvent;
   /** The actions are about to open. Cancelable: cancel it to keep them closed. */
   "helix-before-open": HelixSpeedDialHelixBeforeOpenElementEvent;
   /** 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": HelixSpeedDialHelixSelectElementEvent;
-  /** The dial opened or closed. The event carries `newState` and `oldState`. */
-  toggle: HelixSpeedDialElementEvent;
 };
 
 /** `HelixSplitter` component event */
@@ -11067,6 +11627,12 @@ export type HelixSplitterHelixBeforeCollapseElementEvent =
 /** `helix-before-resize` event type */
 export type HelixSplitterHelixBeforeResizeElementEvent =
   HelixSplitterElementEvent<HelixBeforeResizeEvent>;
+/** `helix-collapse` event type */
+export type HelixSplitterHelixCollapseElementEvent =
+  HelixSplitterElementEvent<HelixCollapseEvent>;
+/** `helix-resized` event type */
+export type HelixSplitterHelixResizedElementEvent =
+  HelixSplitterElementEvent<HelixResizedEvent>;
 
 export type HelixSplitterVueProps = {
   /** Whether the divider shows a grip.
@@ -11137,7 +11703,10 @@ consumer's to set. */
   "default-position"?: (HelixSplitter["defaultPosition"] | `${number}`) | undefined;
   /** Where the divider starts, when `position` is not set. */
   defaultPosition?: (HelixSplitter["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?: (HelixSplitter["label"]) | undefined;
   /** How close the divider can come to the end, in the same units as `min`. */
   max?: (HelixSplitter["max"]) | undefined;
@@ -11199,6 +11768,10 @@ export type HelixSplitterVueEvents = {
   "helix-before-collapse": HelixSplitterHelixBeforeCollapseElementEvent;
   /** 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": HelixSplitterHelixBeforeResizeElementEvent;
+  /** Fired after a pane shuts or reopens, with the side that is shut, or empty where both are open. */
+  "helix-collapse": HelixSplitterHelixCollapseElementEvent;
+  /** Fired after the divider settles somewhere new, with the new position. */
+  "helix-resized": HelixSplitterHelixResizedElementEvent;
 };
 
 export type HelixStatGroupVueProps = {
@@ -11232,6 +11805,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
@@ -11356,9 +11934,7 @@ stylesheets. */
   /** Whether the control starts checked. A form reset returns it to this state. */
   defaultChecked?: (HelixSwitch["defaultChecked"]) | undefined;
   /**  */
-  "aria-label"?: (HelixSwitch["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixSwitch["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixSwitch["feedback"]) | undefined;
@@ -11427,7 +12003,8 @@ export type HelixSwitchVueEvents = {
 };
 
 export type HelixTableCellVueProps = {
-  /** 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?: (HelixTableCell["header"]) | undefined;
 };
 
@@ -11611,6 +12188,12 @@ export type HelixTableColumnVueEvents = {
   "helix-before-resize": HelixTableColumnHelixBeforeResizeElementEvent;
 };
 
+/** `HelixTable` component event */
+export type HelixTableElementEvent<E = Event> = TypedEvent<HelixTable, E>;
+/** `helix-sort` event type */
+export type HelixTableHelixSortElementEvent =
+  HelixTableElementEvent<HelixSortEvent>;
+
 export type HelixTableVueProps = {
   /** The text shown and announced when there are no rows and none are loading. */
   "empty-text"?: (HelixTable["emptyText"]) | undefined;
@@ -11626,6 +12209,10 @@ say that without the component knowing what a row looks like. */
   "loading-text"?: (HelixTable["loadingText"]) | undefined;
   /** The text shown and announced while the rows load. */
   loadingText?: (HelixTable["loadingText"]) | undefined;
+  /** The word for an ascending sort, in `sorted-label`. */
+  "ascending-label"?: (HelixTable["ascendingLabel"]) | undefined;
+  /** The word for an ascending sort, in `sorted-label`. */
+  ascendingLabel?: (HelixTable["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
@@ -11655,11 +12242,43 @@ 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?: (HelixTable["columns"]) | undefined;
-  /** Accessible name for the table. */
+  /** The starting sort order, used until `sort` is set. */
+  "default-sort"?: (HelixTable["defaultSort"]) | undefined;
+  /** The starting sort order, used until `sort` is set. */
+  defaultSort?: (HelixTable["defaultSort"]) | undefined;
+  /** The word for a descending sort, in `sorted-label`. */
+  "descending-label"?: (HelixTable["descendingLabel"]) | undefined;
+  /** The word for a descending sort, in `sorted-label`. */
+  descendingLabel?: (HelixTable["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?: (HelixTable["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?: (HelixTable["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"?: (HelixTable["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?: (HelixTable["sortedLabel"]) | undefined;
+  /** What screen readers hear when the table stops being sorted. */
+  "unsorted-label"?: (HelixTable["unsortedLabel"]) | undefined;
+  /** What screen readers hear when the table stops being sorted. */
+  unsortedLabel?: (HelixTable["unsortedLabel"]) | undefined;
 };
 
-export type HelixTableVueEvents = {};
+export type HelixTableVueEvents = {
+  /** 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": HelixTableHelixSortElementEvent;
+};
 
 export type HelixTableRowVueProps = {};
 
@@ -11716,7 +12335,10 @@ Ignored once `active` is written. */
 
 Ignored once `active` is written. */
   defaultActive?: (HelixTabs["defaultActive"]) | undefined;
-  /** 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?: (HelixTabs["label"]) | undefined;
   /** Stops the arrow keys from selecting each tab they move to. By default,
 arrowing to a tab also selects it.
@@ -11810,9 +12432,8 @@ neither. That is the test the whole axis registry answers to. */
 already calls them. `helix component`'s `axes` holds the vocabulary.
 
 **Not all seven are statuses, and `accent` is the one worth saying out
-loud**: it 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. The four that are statuses are the four
+loud**: it is the second emphasis, the second color a theme names, and the
+brand itself until one is named. `primary` is the brand. The four that are statuses are the four
 `HelixStatusTone` names, and those are the ones that would carry a glyph
 somewhere that draws one.
 
@@ -11845,7 +12466,12 @@ export type HelixTagVueEvents = {
 export type HelixTextVueProps = {
   /** The HTML element to render.
 
-Decides the outline and the semantics. */
+Decides the outline and the semantics.
+
+**`label` gives the label ramp and labels no control.** The element is in
+this one's shadow root, which neither `for` nor a wrapped control can
+reach, so a page that writes either is warned. Name a Helix field with its
+own `label`, and a native control with `<label data-text="label">`. */
   as?: (HelixText["as"]) | undefined;
   /** Makes the text quieter: `muted`, or the quieter `subtle`.
 
@@ -11874,7 +12500,8 @@ why `muted` and `subtle` moved there. */
   tone?: (HelixText["tone"]) | undefined;
   /** The type style, which sets the size, weight, leading, and tracking.
 
-Defaults to the one that matches `as`. */
+Defaults to the one that matches `as`: `body` for `p`, `body-strong` for
+`strong`, `h5` and `h6`. A `span` or an `em` keeps the type around it. */
   variant?: (HelixText["variant"]) | undefined;
 };
 
@@ -11899,9 +12526,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixTextarea["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixTextarea["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixTextarea["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixTextarea["feedback"]) | undefined;
@@ -12056,6 +12681,9 @@ export type HelixTimeInputElementEvent<E = Event> = TypedEvent<
   HelixTimeInput,
   E
 >;
+/** `toggle` event type */
+export type HelixTimeInputToggleElementEvent =
+  HelixTimeInputElementEvent<ToggleEvent>;
 /** `helix-before-change` event type */
 export type HelixTimeInputHelixBeforeChangeElementEvent =
   HelixTimeInputElementEvent<HelixBeforeChangeEvent>;
@@ -12152,9 +12780,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixTimeInput["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixTimeInput["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixTimeInput["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixTimeInput["feedback"]) | undefined;
@@ -12188,6 +12814,16 @@ the field and does not reach that one. */
 Empty leaves the attribute off, which is the browser's default and is what
 lets autofill work at all. */
   autocomplete?: (HelixTimeInput["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"?: (HelixTimeInput["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?: (HelixTimeInput["disableTimes"]) | undefined;
   /** Language tag the times are written in.
 
 Absent uses the runtime's own. */
@@ -12261,6 +12897,10 @@ never something this element would refuse to read back. */
   "trigger-label"?: (HelixTimeInput["triggerLabel"]) | undefined;
   /** The name of the button that opens the list, read by screen readers. */
   triggerLabel?: (HelixTimeInput["triggerLabel"]) | undefined;
+  /** The message shown when `disable-times` bars a time. */
+  "unavailable-message"?: (HelixTimeInput["unavailableMessage"]) | undefined;
+  /** The message shown when `disable-times` bars a time. */
+  unavailableMessage?: (HelixTimeInput["unavailableMessage"]) | undefined;
   /** Whether the panel shows one list of times or a column for each part of the
 time.
 
@@ -12316,6 +12956,8 @@ a consumer handing over `new Date()` gets the time of day they expected. */
 };
 
 export type HelixTimeInputVueEvents = {
+  /** Fired after the list opens or closes, with `newState` and `oldState`. */
+  toggle: HelixTimeInputToggleElementEvent;
   /** Fired after the value changes. */
   change: HelixTimeInputElementEvent;
   /** Fired before the time changes. Cancelable: canceling it stops the change and leaves the decision to you. */
@@ -12326,8 +12968,6 @@ export type HelixTimeInputVueEvents = {
   "helix-before-open": HelixTimeInputHelixBeforeOpenElementEvent;
   /** Fired after the value changes. */
   input: HelixTimeInputElementEvent;
-  /** Fired after the list opens or closes, with `newState` and `oldState`. */
-  toggle: HelixTimeInputElementEvent;
 };
 
 /** `HelixTimePicker` component event */
@@ -12363,7 +13003,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?: (HelixTimePicker["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
@@ -12374,7 +13014,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"?: (HelixTimePicker["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
@@ -12385,6 +13025,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?: (HelixTimePicker["disableTimes"]) | undefined;
+  /** What the wheel of hours is called, read by screen readers. */
+  "hour-label"?: (HelixTimePicker["hourLabel"]) | undefined;
+  /** What the wheel of hours is called, read by screen readers. */
+  hourLabel?: (HelixTimePicker["hourLabel"]) | undefined;
   /** Whether the current selection fails validation.
 
 A flag rather than a message, the same split Date Picker draws. A flat
@@ -12393,16 +13037,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?: (HelixTimePicker["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?: (HelixTimePicker["label"]) | undefined;
   /** Language tag the times are written in.
 
 Absent uses the runtime's own. */
   locale?: (HelixTimePicker["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?: (HelixTimePicker["manual"]) | undefined;
   /** Latest time offered, as `HH:mm`. */
   max?: (HelixTimePicker["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"?: (HelixTimePicker["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?: (HelixTimePicker["meridiemLabel"]) | undefined;
   /** Earliest time offered, as `HH:mm`. */
   min?: (HelixTimePicker["min"]) | undefined;
+  /** What the wheel of minutes is called, read by screen readers. */
+  "minute-label"?: (HelixTimePicker["minuteLabel"]) | undefined;
+  /** What the wheel of minutes is called, read by screen readers. */
+  minuteLabel?: (HelixTimePicker["minuteLabel"]) | undefined;
   /** How many times can be held at once.
 
 Absent is one. `range` holds a start and an end with everything between
@@ -12421,6 +13083,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?: (HelixTimePicker["mode"]) | undefined;
+  /** The validation message for a time after `max`. `{max}` is replaced with
+`max`, written in `locale`. */
+  "range-overflow-message"?: (HelixTimePicker["rangeOverflowMessage"]) | undefined;
+  /** The validation message for a time after `max`. `{max}` is replaced with
+`max`, written in `locale`. */
+  rangeOverflowMessage?: (HelixTimePicker["rangeOverflowMessage"]) | undefined;
+  /** The validation message for a time before `min`. `{min}` is replaced with
+`min`, written in `locale`. */
+  "range-underflow-message"?: (HelixTimePicker["rangeUnderflowMessage"]) | undefined;
+  /** The validation message for a time before `min`. `{min}` is replaced with
+`min`, written in `locale`. */
+  rangeUnderflowMessage?: (HelixTimePicker["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
@@ -12453,6 +13127,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?: (HelixTimePicker["step"]) | undefined;
+  /** The validation message for a time that `step` skips. */
+  "step-mismatch-message"?: (HelixTimePicker["stepMismatchMessage"]) | undefined;
+  /** The validation message for a time that `step` skips. */
+  stepMismatchMessage?: (HelixTimePicker["stepMismatchMessage"]) | undefined;
+  /** The validation message for a time that `disable-times` bars. */
+  "unavailable-message"?: (HelixTimePicker["unavailableMessage"]) | undefined;
+  /** The validation message for a time that `disable-times` bars. */
+  unavailableMessage?: (HelixTimePicker["unavailableMessage"]) | undefined;
   /** The validation message for a required time picker with no time chosen. */
   "value-missing-message"?: (HelixTimePicker["valueMissingMessage"]) | undefined;
   /** The validation message for a required time picker with no time chosen. */
@@ -12687,9 +13369,7 @@ same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixToggleGroup["value"]) | undefined;
   /**  */
-  "aria-label"?: (HelixToggleGroup["namedBy"]) | undefined;
-  /**  */
-  namedBy?: (HelixToggleGroup["namedBy"]) | undefined;
+  "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixToggleGroup["feedback"]) | undefined;
@@ -12774,12 +13454,22 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixToggleGroup["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?: (HelixToggleGroup["focusable"]) | undefined;
 };
 
 export type HelixToggleGroupVueEvents = {
   /** Fired after the value changes. */
   change: HelixToggleGroupElementEvent;
-  /** 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": HelixToggleGroupHelixBeforeChangeElementEvent;
   /** 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": HelixToggleGroupHelixSelectElementEvent;
@@ -12831,13 +13521,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?: (HelixToggle["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?: (HelixToggle["focusable"]) | undefined;
 };
 
@@ -12847,7 +13539,10 @@ export type HelixToggleVueEvents = {
 };
 
 export type HelixToolbarVueProps = {
-  /** 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?: (HelixToolbar["label"]) | undefined;
   /** The direction the arrow keys move focus in. */
   orientation?: (HelixToolbar["orientation"]) | undefined;
@@ -12857,6 +13552,9 @@ export type HelixToolbarVueEvents = {};
 
 /** `HelixTooltip` component event */
 export type HelixTooltipElementEvent<E = Event> = TypedEvent<HelixTooltip, E>;
+/** `toggle` event type */
+export type HelixTooltipToggleElementEvent =
+  HelixTooltipElementEvent<ToggleEvent>;
 /** `helix-before-close` event type */
 export type HelixTooltipHelixBeforeCloseElementEvent =
   HelixTooltipElementEvent<HelixBeforeCloseEvent>;
@@ -12992,22 +13690,30 @@ at a box the bubble genuinely does not fit inside. See `within` on
 };
 
 export type HelixTooltipVueEvents = {
+  /** The bubble opened or closed. The event carries `newState` and `oldState`. */
+  toggle: HelixTooltipToggleElementEvent;
   /** The bubble is about to hide. Cancelable: cancel it to keep it shown. */
   "helix-before-close": HelixTooltipHelixBeforeCloseElementEvent;
   /** The bubble is about to show. Cancelable: cancel it to keep it hidden. */
   "helix-before-open": HelixTooltipHelixBeforeOpenElementEvent;
-  /** The bubble opened or closed. The event carries `newState` and `oldState`. */
-  toggle: HelixTooltipElementEvent;
 };
 
 /** `HelixTour` component event */
 export type HelixTourElementEvent<E = Event> = TypedEvent<HelixTour, E>;
+/** `toggle` event type */
+export type HelixTourToggleElementEvent = HelixTourElementEvent<ToggleEvent>;
+/** `helix-activate` event type */
+export type HelixTourHelixActivateElementEvent =
+  HelixTourElementEvent<HelixActivateEvent>;
 /** `helix-before-activate` event type */
 export type HelixTourHelixBeforeActivateElementEvent =
   HelixTourElementEvent<HelixBeforeActivateEvent>;
 /** `helix-before-close` event type */
 export type HelixTourHelixBeforeCloseElementEvent =
   HelixTourElementEvent<HelixBeforeCloseEvent>;
+/** `helix-before-open` event type */
+export type HelixTourHelixBeforeOpenElementEvent =
+  HelixTourElementEvent<HelixBeforeOpenEvent>;
 /** `helix-complete` event type */
 export type HelixTourHelixCompleteElementEvent =
   HelixTourElementEvent<HelixCompleteEvent>;
@@ -13016,6 +13722,23 @@ export type HelixTourHelixTourAskElementEvent =
   HelixTourElementEvent<HelixTourAskEvent>;
 
 export type HelixTourVueProps = {
+  /** Whether the element starts open. Ignored once `open` is written. */
+  "default-open"?: (HelixTour["defaultOpen"]) | undefined;
+  /** Whether the element starts open. Ignored once `open` is written. */
+  defaultOpen?: (HelixTour["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?: (HelixTour["open"]) | undefined;
   /** Label for the control that goes back, passed to every stop. */
   "back-label"?: (HelixTour["backLabel"]) | undefined;
   /** Label for the control that goes back, passed to every stop. */
@@ -13045,8 +13768,6 @@ The shape is `Carousel`'s, which is the nearest thing in the library: a
   "next-label"?: (HelixTour["nextLabel"]) | undefined;
   /** Label for the control that goes on. */
   nextLabel?: (HelixTour["nextLabel"]) | undefined;
-  /** Whether the tour is running. */
-  open?: (HelixTour["open"]) | undefined;
   /** Label for the control that leaves the tour. */
   "skip-label"?: (HelixTour["skipLabel"]) | undefined;
   /** Label for the control that leaves the tour. */
@@ -13058,10 +13779,16 @@ The shape is `Carousel`'s, which is the nearest thing in the library: a
 };
 
 export type HelixTourVueEvents = {
+  /** Sent when the tour starts or ends, with `newState` and `oldState`. */
+  toggle: HelixTourToggleElementEvent;
+  /** Fired after the current stop changes, with the new index. */
+  "helix-activate": HelixTourHelixActivateElementEvent;
   /** Fired before the current stop changes, with the new index. Cancelable: call `preventDefault()` to stay on the current stop. */
   "helix-before-activate": HelixTourHelixBeforeActivateElementEvent;
   /** Fired before the user ends the tour early. Cancelable: call `preventDefault()` to keep the tour open. */
   "helix-before-close": HelixTourHelixBeforeCloseElementEvent;
+  /** Fired before `requestOpen(true)` starts the tour. Cancelable: call `preventDefault()` to keep it closed. */
+  "helix-before-open": HelixTourHelixBeforeOpenElementEvent;
   /** Fired when the last stop is finished. */
   "helix-complete": HelixTourHelixCompleteElementEvent;
   /** Fired when a stop's control is pressed to move the tour. The stop sends it, and the tour handles it. */
@@ -13119,6 +13846,9 @@ export type HelixTreeItemElementEvent<E = Event> = TypedEvent<HelixTreeItem, E>;
 /** `helix-select` event type */
 export type HelixTreeItemHelixSelectElementEvent =
   HelixTreeItemElementEvent<HelixSelectEvent>;
+/** `toggle` event type */
+export type HelixTreeItemToggleElementEvent =
+  HelixTreeItemElementEvent<ToggleEvent>;
 /** `helix-before-close` event type */
 export type HelixTreeItemHelixBeforeCloseElementEvent =
   HelixTreeItemElementEvent<HelixBeforeCloseEvent>;
@@ -13198,12 +13928,12 @@ hydrates. */
 export type HelixTreeItemVueEvents = {
   /** Fired when the item is chosen, and cancelable. Canceling it changes nothing. */
   "helix-select": HelixTreeItemHelixSelectElementEvent;
+  /** Sent when the branch opens or closes, with `newState` and `oldState`. */
+  toggle: HelixTreeItemToggleElementEvent;
   /** Fired before a branch closes, and cancelable. */
   "helix-before-close": HelixTreeItemHelixBeforeCloseElementEvent;
   /** Fired before a branch opens, and cancelable. */
   "helix-before-open": HelixTreeItemHelixBeforeOpenElementEvent;
-  /** Sent when the branch opens or closes, with `newState` and `oldState`. */
-  toggle: HelixTreeItemElementEvent;
 };
 
 /** `HelixTree` component event */
@@ -13294,7 +14024,10 @@ Ignored once `active` is written. */
 
 Ignored once `active` is written. */
   defaultActive?: (HelixTree["defaultActive"]) | undefined;
-  /** 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?: (HelixTree["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.
@@ -13343,6 +14076,10 @@ export type HelixTreeVueEvents = {
 };
 
 export type HelixTrendVueProps = {
+  /** The word read out after the direction when the move is an improvement. */
+  "better-label"?: (HelixTrend["betterLabel"]) | undefined;
+  /** The word read out after the direction when the move is an improvement. */
+  betterLabel?: (HelixTrend["betterLabel"]) | undefined;
   /** Which way the measurement moved.
 
 Absent is neutral, so a trend with nothing to report draws a bar rather
@@ -13352,6 +14089,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?: (HelixTrend["direction"]) | undefined;
+  /** The word read out for a move down. */
+  "down-label"?: (HelixTrend["downLabel"]) | undefined;
+  /** The word read out for a move down. */
+  downLabel?: (HelixTrend["downLabel"]) | undefined;
   /** Which direction counts as an improvement for this metric.
 
 Absent states the movement without judging it, which is the honest default:
@@ -13359,6 +14100,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?: (HelixTrend["good"]) | undefined;
+  /** The word read out for no move, or for a direction that is not one of the
+three. */
+  "unchanged-label"?: (HelixTrend["unchangedLabel"]) | undefined;
+  /** The word read out for no move, or for a direction that is not one of the
+three. */
+  unchangedLabel?: (HelixTrend["unchangedLabel"]) | undefined;
+  /** The word read out for a move up. */
+  "up-label"?: (HelixTrend["upLabel"]) | undefined;
+  /** The word read out for a move up. */
+  upLabel?: (HelixTrend["upLabel"]) | undefined;
+  /** The word read out after the direction when the move is a setback. */
+  "worse-label"?: (HelixTrend["worseLabel"]) | undefined;
+  /** The word read out after the direction when the move is a setback. */
+  worseLabel?: (HelixTrend["worseLabel"]) | undefined;
 };
 
 export type HelixTrendVueEvents = {};
@@ -13869,7 +14624,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?: (HelixVirtualList["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?: (HelixVirtualList["label"]) | undefined;
   /** Places rows by their measured height. Without it, every row is placed by
 `estimate`.
@@ -13935,6 +14693,8 @@ export type CustomCssProperties = {
   "--avatar-size"?: (string) | undefined;
   /** The fill of the indicator. */
   "--badge-background-color"?: (string) | undefined;
+  /** The color of the count, to pair with a fill set through `--badge-background-color`. */
+  "--badge-color"?: (string) | undefined;
   /** Pulls the mark in from the corner, along both axes. */
   "--badge-offset"?: (string) | undefined;
   /** The color of the ring between the indicator and what is behind it. */
@@ -14191,6 +14951,12 @@ export type CustomCssProperties = {
   "--command-list-size"?: (string) | undefined;
   /** How wide the palette is. Defaults to `40rem`. */
   "--command-size"?: (string) | undefined;
+  /** Fill behind the button, in every state. */
+  "--icon-button-background-color"?: (string) | undefined;
+  /** Fill behind the button under the pointer. Without it, `--icon-button-background-color` also applies on hover. */
+  "--icon-button-background-color-hover"?: (string) | undefined;
+  /** Icon color. */
+  "--icon-button-foreground-color"?: (string) | undefined;
   /** Corner radius of the control, which a group flattens through `--button-radius-start` and `--button-radius-end`. */
   "--icon-button-radius"?: (string) | undefined;
   /** Shadow of a raised icon button. */
@@ -14469,7 +15235,7 @@ export type CustomCssProperties = {
   "--listbox-max-block-size"?: (string) | undefined;
   /** Color of the moving arc. */
   "--loader-color"?: (string) | undefined;
-  /** Diameter. Defaults to 1.5em. */
+  /** Diameter. Defaults to the size token that `size` picks, which is 1.5rem at the default density. */
   "--loader-size"?: (string) | undefined;
   /** Color of the circle behind the arc. */
   "--loader-track-color"?: (string) | undefined;
@@ -14551,13 +15317,13 @@ export type CustomCssProperties = {
   "--menu-background-color"?: (string) | undefined;
   /** Color of the panel's edge. */
   "--menu-border-color"?: (string) | undefined;
-  /** Width of the panel's edge. Defaults to `--helix-border-floating`, which is `0`, so the panel stands out by its shadow unless a theme sets a border. `--helix-border-floating`, which is `0`, so the panel is told apart by its lift unless a theme says otherwise. */
+  /** Width of the panel's edge. Defaults to `--helix-border-floating`, which is `0`, so the panel stands out by its shadow unless a theme sets a border. */
   "--menu-border-width"?: (string) | undefined;
   /** The tallest the menu grows before it scrolls. */
   "--menu-max-block-size"?: (string) | undefined;
   /** The narrowest the menu gets. */
   "--menu-min-inline-size"?: (string) | undefined;
-  /** Shadow under the panel. Defaults to `--helix-shadow-floating`, so the panel keeps a shadow over any content below it. floating surface sits over content nobody can predict, so it keeps a lift by default. */
+  /** Shadow under the panel. Defaults to `--helix-shadow-floating`, so the panel keeps a shadow over any content below it. */
   "--menu-shadow"?: (string) | undefined;
   /** The fill color. Overrides the band's tone. */
   "--meter-color"?: (string) | undefined;
@@ -14683,9 +15449,9 @@ export type CustomCssProperties = {
   "--progress-track-color"?: (string) | undefined;
   /** The value as a fraction of the range, 0 to 1. Pinned to 1 while indeterminate. */
   "--progress-fraction"?: (string) | undefined;
-  /** The fill behind the modules, including the quiet zone. */
+  /** The fill behind the modules, including the quiet zone and the logo's box. */
   "--qr-code-background-color"?: (string) | undefined;
-  /** Color of the dark modules. Defaults to the page's text color. */
+  /** Color of the dark modules. Defaults to the dark media ink, which is the same in both color schemes so the code scans. */
   "--qr-code-color"?: (string) | undefined;
   /** Color of the three corner squares. Defaults to the color of the modules. */
   "--qr-code-finder-color"?: (string) | undefined;
@@ -14795,6 +15561,8 @@ export type CustomCssProperties = {
   "--select-shadow"?: (string) | undefined;
   /** Maximum height of the panel. */
   "--select-surface-max-block-size"?: (string) | undefined;
+  /** The height of the block shape, which is the shape when `shape` is unset. Defaults to the control height. */
+  "--skeleton-block-size"?: (string) | undefined;
   /** The diameter of the circle shape. */
   "--skeleton-size"?: (string) | undefined;
   /** The border color of the link while it is shown. */
@@ -14901,6 +15669,24 @@ export type CustomCssProperties = {
   "--table-columns"?: (string) | undefined;
   /** The column track list the table works out from its columns. The component writes it inline on the element that reads it, so setting it has no effect. Set `columns` to change the tracks. */
   "--table-template"?: (string) | undefined;
+  /** The space between the tab row and the panel's content. */
+  "--tabs-panel-padding-block-start"?: (string) | undefined;
+  /** The space between tabs. */
+  "--tabs-gap"?: (string) | undefined;
+  /** The fill of the mark on the current tab: the bar under `underlined`, and the pill otherwise. */
+  "--tabs-indicator-color"?: (string) | undefined;
+  /** The height of the bar under `underlined`. */
+  "--tabs-indicator-thickness"?: (string) | undefined;
+  /** The color of the rule under the row in `underlined`. */
+  "--tabs-rule-color"?: (string) | undefined;
+  /** The height of a tab. `segmented` sizes its tabs to the track and does not read it. */
+  "--tabs-tab-block-size"?: (string) | undefined;
+  /** The label color of a tab that is not current. */
+  "--tabs-tab-color"?: (string) | undefined;
+  /** The space either side of the label. */
+  "--tabs-tab-padding-inline"?: (string) | undefined;
+  /** The label color of the current tab. */
+  "--tabs-tab-selected-color"?: (string) | undefined;
   /** The fill behind the tag. */
   "--tag-background-color"?: (string) | undefined;
   /** The color of the tag's edge. */
@@ -15053,7 +15839,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixAccordionVueProps,
     HelixAccordionVueEvents
   >;
-  /** Full width and flat. The tone is a tinted fill and a hairline along the bottom edge, with no border on the other sides, so the announcement is a band across the top of the page. */
+  /** Full width and flat. The tone is a tinted fill with no border, so the announcement is a band across the top of the page. 'separation="outlined"' adds a hairline along the bottom edge. */
   "helix-announcement": DefineCustomElement<
     HelixAnnouncement,
     HelixAnnouncementVueProps,
@@ -15083,7 +15869,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixAvatarGroupVueProps,
     HelixAvatarGroupVueEvents
   >;
-  /** The font size of the initials is set in 'em' against the avatar's own dimension, so the initials scale with every size, including a size you set through '--avatar-size'. */
+  /** The font size of the initials is a share of the avatar's own size, so the initials scale with every size, including a size you set through '--avatar-size'. */
   "helix-avatar": DefineCustomElement<
     HelixAvatar,
     HelixAvatarVueProps,
@@ -15449,7 +16235,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixListboxVueProps,
     HelixListboxVueEvents
   >;
-  /** Sized in 'em', so it matches the text beside it. The color is 'currentColor', so it matches the text color around it, including inside a primary button. */
+  /** Sized from the loader size tokens, so a loader is the same size wherever it is placed and follows the density region it sits in. Set '--loader-size: 1em' to match the text beside it, as inside a button. The color is 'currentColor', so it matches the text color around it, including inside a primary button. */
   "helix-loader": DefineCustomElement<
     HelixLoader,
     HelixLoaderVueProps,
@@ -15593,7 +16379,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixOptionVueProps,
     HelixOptionVueEvents
   >;
-  /** A cloud of dots drawn to a canvas, with one shape per state:  - 'connecting' and 'thinking': the same leaning sash, differing in how   agitated it is. - 'waiting' and 'done': the same settled ball at different tempos. - 'fetching': a globe with a light moving around it. - 'listening': a closed sphere with a ripple crossing it. - 'working': a ring.  Every state is the same banded grid with different parameters. Changing state interpolates the parameters, so every frame in between is a complete shape. A small change gets less time than a large one, such as a sash becoming a ring. The outline changes first, so the light starts orbiting only after the shape is round.  The cloud does not rotate, and all movement happens inside it. The exception is the light, which travels because a ring of evenly spaced dots looks the same when rotated, so a turning state needs something fixed passing over it.  Colors come from '--orb-color' and '--orb-ground'. Each dot's color is mixed toward the ground color by its depth, so depth holds when the theme changes.  The animation stops when the orb is off screen or in a background tab. With 'prefers-reduced-motion', it draws one still frame.  The orb is styled only and has behavior, which the tier split does not otherwise allow. The behavior is drawing dots to a canvas, so there is no structure to restyle and nothing for a headless element to hold. */
+  /** A cloud of dots drawn to a canvas, with one shape per state:  - 'connecting' and 'thinking': the same leaning sash, differing in how   agitated it is. - 'waiting' and 'done': the same settled ball at different tempos. - 'fetching': a globe with a light moving around it. - 'listening': a closed sphere with a ripple crossing it. - 'working': a ring.  Every state is the same banded grid with different parameters. Changing state interpolates the parameters, so every frame in between is a complete shape. A small change gets less time than a large one, such as a sash becoming a ring. The outline changes first, so the light starts orbiting only after the shape is round.  The cloud does not rotate, and all movement happens inside it. The exception is the light, which travels because a ring of evenly spaced dots looks the same when rotated, so a turning state needs something fixed passing over it.  Colors come from '--orb-color' and '--orb-ground'. Each dot's color is mixed toward the ground color by its depth, so depth holds when the theme changes.  The animation stops when the orb is off screen or in a background tab. With 'prefers-reduced-motion', it draws one still frame.  The orb is styled only and has behavior, which the tier split does not otherwise allow. Its role, name and busy state follow 'state', and the rest is drawing dots to a canvas, so there is no structure to restyle. For a drawing of your own, the headless 'Loader' holds the same busy progress bar and its name. */
   "helix-orb": DefineCustomElement<
     HelixOrb,
     HelixOrbVueProps,
@@ -15683,7 +16469,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixSandboxVueProps,
     HelixSandboxVueEvents
   >;
-  /** A real '<textarea>', so undo, selection, spellcheck suppression, mobile keyboards, and screen reader support come from the platform.  Tab inserts two spaces, so you can indent code. To move focus out of the field, press Escape and then Tab. */
+  /** A real '<textarea>', so undo, selection, spellcheck suppression, mobile keyboards, and screen reader support come from the platform.  Tab inserts two spaces, so you can indent code. To move focus out of the field, press Escape and then Tab. Shift+Tab moves focus back as it does anywhere else. The field's description says so to a screen reader. */
   "helix-sandbox-source": DefineCustomElement<
     HelixSandboxSource,
     HelixSandboxSourceVueProps,
@@ -15695,7 +16481,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixSandboxStatusBarVueProps,
     HelixSandboxStatusBarVueEvents
   >;
-  /** The sandbox receives 'helix-console' events from the preview and passes them to the terminal. The preview is a separate document, so messages cross 'postMessage' and arrive as text.  **Repeats collapse.** Consecutive identical lines show as one line with a count, so an example with a render loop does not fill the panel with the same warning. Only consecutive repeats collapse, so the order of messages is kept.  The panel has 'role="log"', the role for an append-only stream. Screen readers announce new output without reading the whole panel again. */
+  /** The sandbox receives 'helix-console' events from the preview and passes them to the terminal. The preview is a separate document, so messages cross 'postMessage' and arrive as text.  **Repeats collapse.** Consecutive identical lines show as one line with a count, so an example with a render loop does not fill the panel with the same warning. Only consecutive repeats collapse, so the order of messages is kept.  The panel has 'role="log"', the role for an append-only stream. Screen readers announce new output without reading the whole panel again. A line's level is read before it, except a plain 'log', so an error does not sound like any other line. */
   "helix-sandbox-terminal": DefineCustomElement<
     HelixSandboxTerminal,
     HelixSandboxTerminalVueProps,
@@ -15886,7 +16672,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixToastItemVueProps,
     HelixToastItemVueEvents
   >;
-  /** Fixed to the window. The region spans a whole edge, so it ignores the pointer and only the messages receive clicks. Content beside a message stays clickable.  **Place the region at the root of your application.** 'position: fixed' positions against the viewport only while no ancestor has 'transform', 'filter', 'perspective', or 'contain'. Any of these makes that ancestor the containing block, and an ancestor with 'overflow: hidden' still clips the region. The other floating surfaces in Helix use the top layer for the same reason. */
+  /** Fixed to the window, in the top layer. The region spans a whole edge, so it ignores the pointer and only the messages receive clicks. Content beside a message stays clickable.  Because the stack is in the top layer, an ancestor with 'transform', 'filter', 'contain', or 'overflow: hidden' does not move or clip it, and a message that arrives while a modal dialog is open shows above the dialog. */
   "helix-toast": DefineCustomElement<
     HelixToast,
     HelixToastVueProps,