@fusion.dev/helix 0.154.0 → 0.156.0

package/types/vue.d.ts

@@ -168,6 +168,7 @@ import type {
   HelixReadingChangeEvent,
   HelixReadingPressEvent,
   HelixAuraFallbackEvent,
+  HelixSelectEvent,
   HelixBeforeChangeEvent,
   HelixPressEvent,
   HelixBeforeMoveEvent,
@@ -182,7 +183,6 @@ import type {
   HelixReconnectEvent,
   HelixRelabelEvent,
   HelixRemoveEvent,
-  HelixSelectEvent,
   HelixActivateEvent,
   HelixSendEvent,
   HelixTypingEvent,
@@ -1532,6 +1532,15 @@ element's language. Leave the marks out of the text. */
 
 export type HelixBlockquoteVueEvents = {};
 
+/** `HelixBreadcrumb` component event */
+export type HelixBreadcrumbElementEvent<E = Event> = TypedEvent<
+  HelixBreadcrumb,
+  E
+>;
+/** `helix-select` event type */
+export type HelixBreadcrumbHelixSelectElementEvent =
+  HelixBreadcrumbElementEvent<HelixSelectEvent>;
+
 export type HelixBreadcrumbVueProps = {
   /** Marks this item as the page you are on. */
   current?: (HelixBreadcrumb["current"]) | undefined;
@@ -1561,7 +1570,10 @@ The consumer's decision. */
   target?: (HelixBreadcrumb["target"]) | undefined;
 };
 
-export type HelixBreadcrumbVueEvents = {};
+export type HelixBreadcrumbVueEvents = {
+  /** A plain press on the crumb's link, with its `href` as the value, before the browser follows it. Cancelable: cancel it to keep the browser from following, as a client-side router does. */
+  "helix-select": HelixBreadcrumbHelixSelectElementEvent;
+};
 
 export type HelixBreadcrumbsVueProps = {
   /** How the two halves of a split crumb are told apart. A split crumb is one
@@ -2485,13 +2497,22 @@ units. */
 card and `{width}` and `{height}` for its new size, in the document's
 units. */
   resizedLabel?: (HelixCanvas["resizedLabel"]) | undefined;
+  /** What a screen reader calls the board in place of its role, after its
+name: "Release plan, canvas". Said only where the board has a name of its
+own, since the fallback name is the same word. Empty leaves the role. */
+  "role-label"?: (HelixCanvas["roleLabel"]) | undefined;
+  /** What a screen reader calls the board in place of its role, after its
+name: "Release plan, canvas". Said only where the board has a name of its
+own, since the fallback name is the same word. Empty leaves the role. */
+  roleLabel?: (HelixCanvas["roleLabel"]) | undefined;
   /** The names of the selected cards and connections, comma separated. Empty
 when nothing is selected.
 
 **Comma separated, the way `Listbox` writes a multiple value**, so a page
 reads one selection the same way wherever it comes from. A click, or a key
-that lands on one, selects it alone; Shift, Command or Control with a click
-adds or takes one away, and so does Space; Command or Control with A
+that lands on one, selects it alone; Command or Control with an arrow key
+moves without selecting; Shift, Command or Control with a click adds or
+takes one away, and so does Space; Command or Control with A
 selects everything; Shift and a drag across the empty board selects the
 cards the box touches. A click on the empty board, or Escape, selects
 nothing. Dragging, Shift with an arrow, and Delete act on the whole
@@ -3390,6 +3411,16 @@ say that without the component knowing what a row looks like. */
   "loading-text"?: (HelixChat["loadingText"]) | undefined;
   /** The text shown and announced while the rows load. */
   loadingText?: (HelixChat["loadingText"]) | undefined;
+  /** What a screen reader hears when a turn arrives. `{author}` is who wrote
+it, as its name says it, and `{text}` its words. A turn with no author a
+reader can be told, a turn by `them` with no `author-label`, says its
+words alone. */
+  "arrival-label"?: (HelixChat["arrivalLabel"]) | undefined;
+  /** What a screen reader hears when a turn arrives. `{author}` is who wrote
+it, as its name says it, and `{text}` its words. A turn with no author a
+reader can be told, a turn by `them` with no `author-label`, says its
+words alone. */
+  arrivalLabel?: (HelixChat["arrivalLabel"]) | undefined;
   /** Declarations for the turns from `turns` by each author, keyed by `author`,
 as JSON in the attribute: `{"ada": "--chat-message-background-color: …"}`.
 
@@ -3540,8 +3571,36 @@ export type HelixCheckboxGroupVueProps = {
   /** The direction the checkboxes run. Set `horizontal` for a row. Unset is a
 column. */
   orientation?: (HelixCheckboxGroup["orientation"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixCheckboxGroup["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixCheckboxGroup["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixCheckboxGroup["feedback"]) | undefined;
@@ -3702,8 +3761,36 @@ was, and the control says `aria-readonly`. A script can still set
 The attribute is `readonly`, which is the platform's spelling for the
 text fields. */
   readOnly?: (HelixCheckbox["readOnly"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixCheckbox["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixCheckbox["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixCheckbox["feedback"]) | undefined;
@@ -4019,8 +4106,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixColorInput["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixColorInput["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixColorInput["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixColorInput["feedback"]) | undefined;
@@ -4082,7 +4197,8 @@ Passed to the panel, whose square, hue ramp and presets say the color's
 name, and read by the swatch in `swatch`, which says it before the value.
 Color Picker lists the keys. */
   colorWords?: (HelixColorInput["colorWords"]) | undefined;
-  /** The syntax the value is written in: `hex`, `rgb`, or `hsl`.
+  /** The syntax the value is written in: `hex`, `rgb`, `hsl`, `oklch`, or
+`hsb`, as Color Picker's `format`.
 
 **Undefaulted, because it reflects.** The two together stamp an attribute
 onto every host anybody renders, including the ones nobody configured: the
@@ -4263,8 +4379,9 @@ language hears its own rather than English between its own labels. */
   brightnessLabel?: (HelixColorPicker["brightnessLabel"]) | undefined;
   /** Whether the picker shows a number field for each channel of the color, as
 React Aria's ColorField does with `channel`: red, green and blue for hex
-and rgb, hue, saturation and lightness for hsl, and the opacity with
-`alpha`.
+and rgb, hue, saturation and lightness for hsl, hue, saturation and
+brightness for hsb, lightness, chroma and hue for oklch, and the opacity
+with `alpha`.
 
 For a reader who has the numbers from a brand guide, and for a keyboard,
 where typing 128 is quicker than holding an arrow key. The fields follow
@@ -4272,13 +4389,20 @@ the syntax the format toggle sets. */
   "channel-fields"?: (HelixColorPicker["channelFields"]) | undefined;
   /** Whether the picker shows a number field for each channel of the color, as
 React Aria's ColorField does with `channel`: red, green and blue for hex
-and rgb, hue, saturation and lightness for hsl, and the opacity with
-`alpha`.
+and rgb, hue, saturation and lightness for hsl, hue, saturation and
+brightness for hsb, lightness, chroma and hue for oklch, and the opacity
+with `alpha`.
 
 For a reader who has the numbers from a brand guide, and for a keyboard,
 where typing 128 is quicker than holding an arrow key. The fields follow
 the syntax the format toggle sets. */
   channelFields?: (HelixColorPicker["channelFields"]) | undefined;
+  /** What the chroma channel's field is called, in `channel-fields` with
+oklch. */
+  "chroma-label"?: (HelixColorPicker["chromaLabel"]) | undefined;
+  /** What the chroma channel's field is called, in `channel-fields` with
+oklch. */
+  chromaLabel?: (HelixColorPicker["chromaLabel"]) | undefined;
   /** The words a color's name is spoken in, as JSON keyed by their English,
 such as `{"red": "rot", "vibrant": "kräftiges"}`.
 
@@ -4319,10 +4443,16 @@ the color. */
   "eyedropper-label"?: (HelixColorPicker["eyedropperLabel"]) | undefined;
   /** What the eyedropper is called. */
   eyedropperLabel?: (HelixColorPicker["eyedropperLabel"]) | undefined;
-  /** The syntax the value is written in: `hex`, `rgb`, or `hsl`.
+  /** The syntax the value is written in: `hex`, `rgb`, `hsl`, `oklch`, or
+`hsb`.
 
 Only what is written. Everything is read whatever this says, so a picker on
-`hex` still takes an `rgb()` handed to it and stores the hex for it. */
+`hex` still takes an `rgb()` or an `oklch()` handed to it and stores the
+hex for it. `oklch` writes the sRGB color the picker holds, such as
+`oklch(62.8% 0.258 29.2)`; a color outside sRGB that is handed in is
+clipped to it. `hsb` writes the picker's own model, `hsb(0, 100%, 100%)`,
+as React Aria's and Zag's color strings do. It is not CSS, so the toggle
+walks the other four. */
   format?: (HelixColorPicker["format"]) | undefined;
   /** What the syntax toggle is called, with `{format}` filled in. */
   "format-label"?: (HelixColorPicker["formatLabel"]) | undefined;
@@ -4332,15 +4462,21 @@ Only what is written. Everything is read whatever this says, so a picker on
   "green-label"?: (HelixColorPicker["greenLabel"]) | undefined;
   /** What the green channel's field is called, in `channel-fields`. */
   greenLabel?: (HelixColorPicker["greenLabel"]) | undefined;
+  /** Help under the picker, such as what the color is used for. The `hint`
+slot takes richer content. */
+  hint?: (HelixColorPicker["hint"]) | undefined;
   /** What the hue channel is called. */
   "hue-label"?: (HelixColorPicker["hueLabel"]) | undefined;
   /** What the hue channel is called. */
   hueLabel?: (HelixColorPicker["hueLabel"]) | undefined;
+  /** The name above the picker, such as "Brand color". The picker is then a
+group with this name. The `label` slot takes richer content. */
+  label?: (HelixColorPicker["label"]) | undefined;
   /** What the lightness channel's field is called, in `channel-fields` with
-hsl. */
+hsl and oklch. */
   "lightness-label"?: (HelixColorPicker["lightnessLabel"]) | undefined;
   /** What the lightness channel's field is called, in `channel-fields` with
-hsl. */
+hsl and oklch. */
   lightnessLabel?: (HelixColorPicker["lightnessLabel"]) | undefined;
   /** Hides the eyedropper. Without it, the eyedropper appears in browsers that
 support one. */
@@ -4637,8 +4773,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixCombobox["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixCombobox["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixCombobox["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixCombobox["feedback"]) | undefined;
@@ -4741,6 +4905,22 @@ delay sends one request for a word instead of one per letter. The arrow
 keys, Enter and Escape narrow at once on what was typed. `0` narrows on
 every keystroke. See Listbox's `filter-delay`. */
   filterDelay?: (HelixCombobox["filterDelay"]) | undefined;
+  /** What the form receives for each chosen option: `key`, its `value`, or
+`text`, its words, as React Aria's ComboBox `formValue` offers.
+
+`text` is for a server that wants what the reader saw, such as a city's
+name. A value no option carries, typed with `allows-custom-value` or made
+with `creatable`, is sent as it is either way. Absent is `key`, and the
+host carries no attribute for it. */
+  "form-value"?: (HelixCombobox["formValue"]) | undefined;
+  /** What the form receives for each chosen option: `key`, its `value`, or
+`text`, its words, as React Aria's ComboBox `formValue` offers.
+
+`text` is for a server that wants what the reader saw, such as a city's
+name. A value no option carries, typed with `allows-custom-value` or made
+with `creatable`, is sent as it is either way. Absent is `key`, and the
+host carries no attribute for it. */
+  formValue?: (HelixCombobox["formValue"]) | undefined;
   /** The list's name, read by screen readers. The list has no visible name. */
   "list-label"?: (HelixCombobox["listLabel"]) | undefined;
   /** The list's name, read by screen readers. The list has no visible name. */
@@ -4970,6 +5150,13 @@ Empty turns it off, for a consumer who opens the palette from a button or
 from their own shortcut handler. There is no list of defaults to fight
 with: one key, said once. */
   hotkey?: (HelixCommand["hotkey"]) | undefined;
+  /** Draws the palette in the page, where it stands, with no dialog: a search
+over a list of commands, as React Aria's Autocomplete is drawn.
+
+The list is always shown, and `hotkey` puts focus in its filter field.
+Choosing a command says `helix-select` and leaves the list where it is,
+and `open`, `toggle` and the dialog's parts do nothing. */
+  inline?: (HelixCommand["inline"]) | undefined;
   /** Accessible name for the overlay, which has no visible heading. */
   label?: (HelixCommand["label"]) | undefined;
   /** What the list says when its commands could not be loaded, such as after a
@@ -4997,6 +5184,15 @@ some. Absent, `empty-text` shows. See Listbox's `no-results-text`. */
   /** The text shown when typing hides every one of the commands, where there are
 some. Absent, `empty-text` shows. See Listbox's `no-results-text`. */
   noResultsText?: (HelixCommand["noResultsText"]) | undefined;
+  /** The page of commands shown, by name: empty for the commands you write
+with no `slot`, or a name for the commands slotted as `page:` and the
+name, such as `slot="page:theme"`.
+
+An option with `opens` set to a name goes to that page when it is chosen,
+in place of running, and Backspace in an empty filter goes back to the
+page before. Closing the palette goes back to the first page. Set it to
+open the palette on a page of your choosing. */
+  page?: (HelixCommand["page"]) | undefined;
   /** The text shown in the filter field before anything is typed. */
   placeholder?: (HelixCommand["placeholder"]) | undefined;
   /** What a screen reader hears when typing leaves one command, where
@@ -5015,6 +5211,15 @@ how many are left, written in the locale, and each language writes the
 forms it has: `{count, plural, one {# polecenie} few {# polecenia} many
 {# poleceń} other {# polecenia}}`. */
   resultsLabel?: (HelixCommand["resultsLabel"]) | undefined;
+  /** The commands as data, for a palette too long to draw whole: each a value,
+which is also its words, or a record with a `value`, a `label` and
+`disabled`. Handed to the list, which draws only the commands in sight and
+reads no children while it is set. See Listbox's `items`.
+
+Choosing one says `helix-select` with its value, as a child option does.
+A command that is a link, or that has an `alternate`, is an option you
+write as a child. */
+  items?: (HelixCommand["items"]) | undefined;
 };
 
 export type HelixCommandVueEvents = {
@@ -5305,6 +5510,22 @@ is set. */
   "dropped-label"?: (HelixDataTable["droppedLabel"]) | undefined;
   /** What screen readers hear when a row is dropped, with `reorderable-rows`. */
   droppedLabel?: (HelixDataTable["droppedLabel"]) | undefined;
+  /** The text shown and announced when the rows could not load, such as "The
+files did not load". Set it when a fetch fails, and clear it once you try
+again. Empty, the default, shows nothing.
+
+While it is set, a line after the rows shows it, or your own content in the
+`error` slot, in place of the empty and loading lines, and the live region
+says it. */
+  "error-text"?: (HelixDataTable["errorText"]) | undefined;
+  /** The text shown and announced when the rows could not load, such as "The
+files did not load". Set it when a fetch fails, and clear it once you try
+again. Empty, the default, shows nothing.
+
+While it is set, a line after the rows shows it, or your own content in the
+`error` slot, in place of the empty and loading lines, and the live region
+says it. */
+  errorText?: (HelixDataTable["errorText"]) | undefined;
   /** The estimated height of a row before it is drawn, in pixels.
 
 Only read while `windowed`, and a starting guess rather than a claim: a
@@ -5770,8 +5991,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixDateInput["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixDateInput["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixDateInput["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixDateInput["feedback"]) | undefined;
@@ -6137,15 +6386,22 @@ speaks it. Unset is the sentence registered for the page's language, then
 the English. `{mode}` is `single`, `range` or `multiple`, so each can have
 its own sentence. */
   badInputMessage?: (HelixDatePicker["badInputMessage"]) | undefined;
-  /** The calendar the heading, the days, and the months are written in:
-`gregory`, `buddhist`, `japanese`, `roc`, or `iso8601`, the five whose
-months are the Gregorian months.
-
-Absent is the locale's own where it is one of the five, such as
-`buddhist` for `th-TH` or `japanese` for `ja-JP-u-ca-japanese`, and
-`gregory` for every other, such as `persian` for `fa-IR`, so the heading
-names the Gregorian month the grid shows. The value is `YYYY-MM-DD` in
-every calendar. */
+  /** The calendar the heading, the days, and the months are written in.
+
+`gregory`, `buddhist`, `japanese`, `roc`, and `iso8601` are the five
+whose months are the Gregorian months. Absent is the locale's own where
+it is one of the five, such as `buddhist` for `th-TH` or `japanese` for
+`ja-JP-u-ca-japanese`, and `gregory` for every other, such as `persian`
+for `fa-IR`.
+
+`persian`, `hebrew`, `islamic-umalqura`, `islamic-civil`, `ethiopic`,
+`coptic`, and `indian` draw a calendar with months of its own, as React
+Aria's calendars do: each grid is one of that calendar's months, the
+Hebrew leap month and Ethiopia's five-day thirteenth month included, and
+Previous, Next and the page keys move by those months. `month` and
+`helix-navigate` then name a month by its first day, `YYYY-MM-DD`. The
+heading stays text, as the months and years views are drawn in Gregorian
+months only. The value is `YYYY-MM-DD` in every calendar. */
   calendar?: (HelixDatePicker["calendar"]) | undefined;
   /** The month to open on when `month` is not set. */
   "default-month"?: (HelixDatePicker["defaultMonth"]) | undefined;
@@ -6204,8 +6460,9 @@ its days. */
   min?: (HelixDatePicker["min"]) | undefined;
   /** How many dates can be held at once. */
   mode?: (HelixDatePicker["mode"]) | undefined;
-  /** The month shown, as `YYYY-MM`. When it is not set, it follows `value`,
-then the current month.
+  /** The month shown, as `YYYY-MM`, or as its first day, `YYYY-MM-DD`, under a
+`calendar` with months of its own. When it is not set, it follows
+`value`, then the current month.
 
 Separate from `value` on purpose, so paging selects nothing and a consumer
 can drive the view. Reading gives the month on show; writing sets it, and
@@ -6307,6 +6564,22 @@ date including the one already chosen. */
   "step-mismatch-message"?: (HelixDatePicker["stepMismatchMessage"]) | undefined;
   /** The validation message for a date that `step` skips. */
   stepMismatchMessage?: (HelixDatePicker["stepMismatchMessage"]) | undefined;
+  /** The time zone today is read in, such as `America/New_York`, as React
+Aria's `today(timeZone)` reads it. Empty is the reader's own.
+
+Dates are plain `YYYY-MM-DD` and carry no zone, so this moves only today:
+the day marked `aria-current` and `day-today`, and the month a picker
+with no value opens on. A desk in Tokyo booking for an office in New York
+sets `America/New_York`, and today is the office's. */
+  "time-zone"?: (HelixDatePicker["timeZone"]) | undefined;
+  /** The time zone today is read in, such as `America/New_York`, as React
+Aria's `today(timeZone)` reads it. Empty is the reader's own.
+
+Dates are plain `YYYY-MM-DD` and carry no zone, so this moves only today:
+the day marked `aria-current` and `day-today`, and the month a picker
+with no value opens on. A desk in Tokyo booking for an office in New York
+sets `America/New_York`, and today is the office's. */
+  timeZone?: (HelixDatePicker["timeZone"]) | undefined;
   /** The validation message for a date that `disable-dates` or `disable-days`
 bars. */
   "unavailable-message"?: (HelixDatePicker["unavailableMessage"]) | undefined;
@@ -7128,8 +7401,36 @@ export type HelixFileInputHelixRejectElementEvent =
   HelixFileInputElementEvent<HelixRejectEvent>;
 
 export type HelixFileInputVueProps = {
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixFileInput["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixFileInput["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixFileInput["feedback"]) | undefined;
@@ -7543,8 +7844,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixFilterInput["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixFilterInput["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixFilterInput["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixFilterInput["feedback"]) | undefined;
@@ -8090,6 +8419,12 @@ written in the locale, and each language writes the forms it has. */
   /** How many links from the selected note to show, for its local graph. Unset
 shows every note. The list holds what the drawing shows. */
   depth?: (HelixGraph["depth"]) | undefined;
+  /** What the panel shows when the list holds no notes: the graph has none, or
+a search or the legend hid them all. A slotted `empty` replaces it. */
+  "empty-label"?: (HelixGraph["emptyLabel"]) | undefined;
+  /** What the panel shows when the list holds no notes: the graph has none, or
+a search or the legend hid them all. A slotted `empty` replaces it. */
+  emptyLabel?: (HelixGraph["emptyLabel"]) | undefined;
   /** The graph's name where `label` is empty and the host has no
 `aria-label`. */
   "fallback-label"?: (HelixGraph["fallbackLabel"]) | undefined;
@@ -8146,6 +8481,14 @@ such as at the top of a page, where the drawing takes the whole frame. */
   "notes-label"?: (HelixGraph["notesLabel"]) | undefined;
   /** The list's name, read by screen readers, and the name of the button that opens it with `no-panel`. */
   notesLabel?: (HelixGraph["notesLabel"]) | undefined;
+  /** What a screen reader calls the graph in place of its role, after its
+name: "Research notes, graph". Said only where the graph has a name of its
+own, since the fallback name is the same word. Empty leaves the role. */
+  "role-label"?: (HelixGraph["roleLabel"]) | undefined;
+  /** What a screen reader calls the graph in place of its role, after its
+name: "Research notes, graph". Said only where the graph has a name of its
+own, since the fallback name is the same word. Empty leaves the role. */
+  roleLabel?: (HelixGraph["roleLabel"]) | undefined;
   /** The search field's name. */
   "search-label"?: (HelixGraph["searchLabel"]) | undefined;
   /** The search field's name. */
@@ -8959,8 +9302,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixInput["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixInput["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixInput["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixInput["feedback"]) | undefined;
@@ -9897,6 +10268,9 @@ export type HelixListHelixBeforeChangeElementEvent =
 /** `helix-before-reorder` event type */
 export type HelixListHelixBeforeReorderElementEvent =
   HelixListElementEvent<HelixBeforeReorderEvent>;
+/** `helix-load-more` event type */
+export type HelixListHelixLoadMoreElementEvent =
+  HelixListElementEvent<HelixLoadMoreEvent>;
 /** `helix-reorder` event type */
 export type HelixListHelixReorderElementEvent =
   HelixListElementEvent<HelixReorderEvent>;
@@ -9929,6 +10303,12 @@ refused, in a `reorderable` list. */
   "dropped-label"?: (HelixList["droppedLabel"]) | undefined;
   /** What screen readers hear when a row is dropped, in a `reorderable` list. */
   droppedLabel?: (HelixList["droppedLabel"]) | undefined;
+  /** The text of the row shown while the list has no rows, where the `empty`
+slot is empty. Empty, the default, shows no row. */
+  "empty-label"?: (HelixList["emptyLabel"]) | undefined;
+  /** The text of the row shown while the list has no rows, where the `empty`
+slot is empty. Empty, the default, shows no row. */
+  emptyLabel?: (HelixList["emptyLabel"]) | undefined;
   /** The kind of list, which follows from the content.
 
 On the headless tier because it is meaning rather than decoration, the same
@@ -9952,6 +10332,19 @@ has to survive with the stylesheet turned off.
   kind?: (HelixList["kind"]) | undefined;
   /** The list's name, read by screen readers. */
   label?: (HelixList["label"]) | undefined;
+  /** Marks the list as busy fetching more rows, and draws a row after the last
+that says so. The list asks for no more while it is set. */
+  loading?: (HelixList["loading"]) | undefined;
+  /** The text of the row drawn while `loading` is set, where the `loading` slot is empty. */
+  "loading-label"?: (HelixList["loadingLabel"]) | undefined;
+  /** The text of the row drawn while `loading` is set, where the `loading` slot is empty. */
+  loadingLabel?: (HelixList["loadingLabel"]) | undefined;
+  /** Sends `helix-load-more` once the end of the list comes within a screen of
+view, so you can add the next rows as a reader nears them. */
+  "load-more"?: (HelixList["loadMore"]) | undefined;
+  /** Sends `helix-load-more` once the end of the list comes within a screen of
+view, so you can add the next rows as a reader nears them. */
+  loadMore?: (HelixList["loadMore"]) | undefined;
   /** What screen readers hear each time an arrow key moves a held row, in a
 `reorderable` list. `{name}` is the row's words, `{position}` the place it
 would go, counting from 1, and `{count}` the number of rows. */
@@ -10007,7 +10400,7 @@ consumer would have written on an `<ol>`.
 `type` is only `list-style-type`. `start` and `reversed` move the count
 itself. */
   type?: (HelixList["type"]) | undefined;
-  /** The selected rows' values, separated by commas, in a list that selects.
+  /** The selected rows' values, separated by commas with no spaces, such as `a,c`, in a list that selects.
 
 Set it to start with rows selected. A row's value is its `value`, or its
 words where it has none. */
@@ -10023,6 +10416,8 @@ export type HelixListVueEvents = {
   "helix-before-change": HelixListHelixBeforeChangeElementEvent;
   /** Fired when a row is dropped at a new place, in a `reorderable` list, with every row's value in the new order. Cancelable: cancel it to keep the row where it is. */
   "helix-before-reorder": HelixListHelixBeforeReorderElementEvent;
+  /** Fired, in a list with `load-more`, when the end of the list comes within a screen of view, once for each number of rows. */
+  "helix-load-more": HelixListHelixLoadMoreElementEvent;
   /** Fired after `helix-before-reorder` when nobody canceled it. Move your rows to the order in `keys`. Cancelable: cancel it to say the move did not happen. */
   "helix-reorder": HelixListHelixReorderElementEvent;
 };
@@ -10075,8 +10470,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixListbox["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixListbox["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixListbox["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixListbox["feedback"]) | undefined;
@@ -10945,6 +11368,14 @@ the standard, themed map. The layers menu chooses it. */
 `connectMap` keeps it current, and the 3D button is pressed while it is
 above `0`. */
   pitch?: (HelixMap["pitch"]) | undefined;
+  /** What a screen reader calls the map in place of its role, after its
+name: "Edinburgh, map". Said only where the map has a name of its
+own, since the fallback name is the same word. Empty leaves the role. */
+  "role-label"?: (HelixMap["roleLabel"]) | undefined;
+  /** What a screen reader calls the map in place of its role, after its
+name: "Edinburgh, map". Said only where the map has a name of its
+own, since the fallback name is the same word. Empty leaves the role. */
+  roleLabel?: (HelixMap["roleLabel"]) | undefined;
   /** The rotate left button's label. */
   "rotate-left-label"?: (HelixMap["rotateLeftLabel"]) | undefined;
   /** The rotate left button's label. */
@@ -11904,8 +12335,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixNumberInput["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixNumberInput["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixNumberInput["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixNumberInput["feedback"]) | undefined;
@@ -12034,6 +12493,20 @@ filled in, written in the locale. */
   readonly?: (HelixNumberInput["readOnly"]) | undefined;
   /** Prevents editing. The value is still submitted with the form. */
   readOnly?: (HelixNumberInput["readOnly"]) | undefined;
+  /** The words screen readers announce for the field's role, set as its
+`aria-roledescription`. Translate it with the rest of your text, or empty
+it to leave the role as `spinbutton`.
+
+Never written on iOS and iPadOS, where a role description stops VoiceOver
+saying that the field is required. */
+  "role-label"?: (HelixNumberInput["roleLabel"]) | undefined;
+  /** The words screen readers announce for the field's role, set as its
+`aria-roledescription`. Translate it with the rest of your text, or empty
+it to leave the role as `spinbutton`.
+
+Never written on iOS and iPadOS, where a role description stops VoiceOver
+saying that the field is required. */
+  roleLabel?: (HelixNumberInput["roleLabel"]) | undefined;
   /** Makes the label a grip that changes the value when it is dragged.
 
 The label is what is dragged, so this adds no chrome at all. Still opt-in,
@@ -12291,6 +12764,14 @@ needs a height, which is a stylesheet rule reading this attribute. */
 Writing opens exactly these and closes every other, keeping the active row
 where it stays visible. A property, never an attribute. */
   expanded?: (HelixObjectInspector["expanded"]) | undefined;
+  /** Draws an entry's value your way, given the value and its entry. Set it as
+a property.
+
+It returns what Lit renders: a template from `html`, a string, or a DOM
+node. `undefined` draws the value as the inspector does, so a function can
+draw some entries and leave the rest, such as only the strings under
+`/links`. */
+  renderValue?: (HelixObjectInspector["renderValue"]) | undefined;
   /** The value to show, when your code already holds it as an object.
 
 Takes precedence over `for`. Anything JSON can say is drawn; anything else
@@ -12426,6 +12907,15 @@ simply the accessible name.
 `<option label>` does: written the platform's way, a select listed a row of
 nothing for every choice. */
   label?: (HelixOption["label"]) | undefined;
+  /** The page of commands this option opens, by name, where choosing it would
+otherwise run it.
+
+Declared here and acted on by whatever owns the list, as `alternate` is.
+`Command` is the only owner that reads it: choosing the option shows the
+commands slotted as `page:` and the name, such as `slot="page:theme"`,
+and Backspace in an empty filter goes back. Empty is an option that opens
+nothing, which is nearly every option. */
+  opens?: (HelixOption["opens"]) | undefined;
   /** The link's `rel`. Set it whenever you set `target="_blank"`. */
   rel?: (HelixOption["rel"]) | undefined;
   /** Whether this choice is currently chosen.
@@ -12900,8 +13390,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixPinInput["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixPinInput["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixPinInput["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixPinInput["feedback"]) | undefined;
@@ -13375,8 +13893,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixRadioGroup["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixRadioGroup["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixRadioGroup["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixRadioGroup["feedback"]) | undefined;
@@ -13671,8 +14217,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixRating["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixRating["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixRating["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixRating["feedback"]) | undefined;
@@ -13924,9 +14498,13 @@ Not reflected, for `direction`'s reason: the placement is applied by the
 document inside the frame, against its own root, so no rule on this side
 could read it. */
   layout?: (HelixSandboxPreview["layout"]) | undefined;
+  /** A script to run as a module after the markup, on every render of new
+source. A sandbox writes its `js` pane here. */
+  script?: (HelixSandboxPreview["script"]) | undefined;
   /** Markup to render. */
   source?: (HelixSandboxPreview["source"]) | undefined;
-  /** The document the frame loads. It provides the styles and the elements. */
+  /** The document the frame loads. It provides the styles and the elements.
+Empty loads the built-in document, which defines no element. */
   src?: (HelixSandboxPreview["src"]) | undefined;
   /** Stylesheet applied inside the frame, alongside the markup. */
   styles?: (HelixSandboxPreview["styles"]) | undefined;
@@ -14537,8 +15115,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixSelect["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixSelect["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixSelect["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixSelect["feedback"]) | undefined;
@@ -14666,6 +15272,18 @@ the stop moves on the trigger inside the shadow root, as Button's does.
 No attribute, because it is coordination between elements rather than
 anything a consumer sets. */
   focusable?: (HelixSelect["focusable"]) | undefined;
+  /** The options as data, for a list too long to draw whole: each a value,
+which is also its words, or a record with a `value`, a `label` and
+`disabled`. Passed to the list, which draws only the options in sight,
+as Listbox's `items` does. Set, the options you write as children are
+not read.
+
+The trigger shows the chosen options' labels, the letters and the Left
+and Right keys on the closed trigger choose over the whole set, and a
+chosen value whose option leaves `items` drops out of `value`.
+`value-content` is not called for `items`. Import the Option family as
+well, whose elements are drawn. */
+  items?: (HelixSelect["items"]) | undefined;
   /** What the trigger shows for the chosen options: a function given them, in
 the order they appear, that returns text, an element or a Lit template.
 
@@ -14774,8 +15392,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixSlider["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixSlider["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixSlider["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixSlider["feedback"]) | undefined;
@@ -14892,9 +15538,11 @@ between its thumbs and ignores it. */
   origin?: (HelixSlider["origin"]) | undefined;
   /** Adds a second thumb, so the value is a pair.
 
-The pair is one string, `"10,50"`, which is what a form submits and what
-`MixinControllerValue` already holds. `valueAsNumber` reads the lower of
-the two, since a range has no single number. */
+The pair is one string, `"10,50"`, which is what `value` and
+`MixinControllerValue` hold. A form receives two entries under the name,
+`price=10&price=50`, as React Aria's two thumbs send theirs.
+`valueAsNumber` reads the lower of the two, since a range has no single
+number. */
   range?: (HelixSlider["range"]) | undefined;
   /** How the readout joins a range's two values, with `{start}` and `{end}`
 filled in. Write it in the page's language, such as `{start} bis {end}`. */
@@ -14902,12 +15550,34 @@ filled in. Write it in the page's language, such as `{start} bis {end}`. */
   /** How the readout joins a range's two values, with `{start}` and `{end}`
 filled in. Write it in the page's language, such as `{start} bis {end}`. */
   rangeText?: (HelixSlider["rangeText"]) | undefined;
+  /** Whether a reader can see and focus the value and cannot change it. A
+read-only slider still submits its value.
+
+React Aria's `isReadOnly`. Each thumb stays a tab stop and says
+`aria-readonly`. The arrow keys, the page keys, Home, End, and a drag
+leave the value where it is. A script can still set `value`. */
+  readonly?: (HelixSlider["readOnly"]) | undefined;
+  /** Whether a reader can see and focus the value and cannot change it. A
+read-only slider still submits its value.
+
+React Aria's `isReadOnly`. Each thumb stays a tab stop and says
+`aria-readonly`. The arrow keys, the page keys, Home, End, and a drag
+leave the value where it is. A script can still set `value`. */
+  readOnly?: (HelixSlider["readOnly"]) | undefined;
   /** Shows the chosen value beside the track. */
   "show-value"?: (HelixSlider["showValue"]) | undefined;
   /** Shows the chosen value beside the track. */
   showValue?: (HelixSlider["showValue"]) | undefined;
   /** How far one press of an arrow key moves the thumb. */
   step?: (HelixSlider["step"]) | undefined;
+  /** The name of a thumb between a range's first and last, read after the
+slider's label, with `{index}` filled in: its place, counted from 1. The
+first is `minimum-label` and the last `maximum-label`. */
+  "thumb-label"?: (HelixSlider["thumbLabel"]) | undefined;
+  /** The name of a thumb between a range's first and last, read after the
+slider's label, with `{index}` filled in: its place, counted from 1. The
+first is `minimum-label` and the last `maximum-label`. */
+  thumbLabel?: (HelixSlider["thumbLabel"]) | undefined;
   /** Whether each thumb shows its value in a bubble beside it, as Web
 Awesome's `with-tooltip`. The styled slider shows the bubbles while the
 slider is under the pointer or holds focus. They repeat what each thumb
@@ -15166,10 +15836,20 @@ export type HelixSpeedDialItemHelixSelectElementEvent =
 export type HelixSpeedDialItemVueProps = {
   /** Whether the action is disabled, so it cannot be chosen. */
   disabled?: (HelixSpeedDialItem["disabled"]) | undefined;
+  /** Whether the link downloads the file when the action is chosen. Only
+meaningful beside an `href`, and only for a file served from the page's
+origin. */
+  download?: (HelixSpeedDialItem["download"]) | undefined;
+  /** The URL the action links to. Setting it draws the action as a link. */
+  href?: (HelixSpeedDialItem["href"]) | undefined;
+  /** The link's `rel`. Set it whenever you set `target="_blank"`. */
+  rel?: (HelixSpeedDialItem["rel"]) | undefined;
   /** The action's keyboard shortcut as a chord, such as `mod+s`, carried as
 `aria-keyshortcuts` and drawn after the name. `mod` is Command on an Apple
 keyboard and Control elsewhere. Showing a shortcut does not bind it. */
   shortcut?: (HelixSpeedDialItem["shortcut"]) | undefined;
+  /** Where the link opens, such as `_blank` for a new tab. */
+  target?: (HelixSpeedDialItem["target"]) | undefined;
   /** The action's value, sent in `helix-select` when the action is chosen. */
   value?: (HelixSpeedDialItem["value"]) | undefined;
 };
@@ -15240,13 +15920,17 @@ you described or labeled it yourself. */
   longPressLabel?: (HelixSpeedDial["longPressLabel"]) | undefined;
   /** Space between the trigger and the actions, in pixels. */
   offset?: (HelixSpeedDial["offset"]) | undefined;
-  /** What opens the dial. `click` opens it on a press of the trigger. Under
-`long-press`, a press is the trigger's own action, and the dial opens on a
-press held for half a second, or on Alt+Down or Alt+Up. */
+  /** What opens the dial. `click` opens it on a press of the trigger. `hover`
+also opens it while a mouse rests on the trigger, and closes it once the
+mouse has left. Under `long-press`, a press is the trigger's own action,
+and the dial opens on a press held for half a second, or on Alt+Down or
+Alt+Up. */
   "open-on"?: (HelixSpeedDial["openOn"]) | undefined;
-  /** What opens the dial. `click` opens it on a press of the trigger. Under
-`long-press`, a press is the trigger's own action, and the dial opens on a
-press held for half a second, or on Alt+Down or Alt+Up. */
+  /** What opens the dial. `click` opens it on a press of the trigger. `hover`
+also opens it while a mouse rests on the trigger, and closes it once the
+mouse has left. Under `long-press`, a press is the trigger's own action,
+and the dial opens on a press held for half a second, or on Alt+Down or
+Alt+Up. */
   openOn?: (HelixSpeedDial["openOn"]) | undefined;
   /** The direction the actions open in. They move to another side if that side
 does not fit.
@@ -15539,6 +16223,16 @@ Ignored once `active` is written. */
 
 Ignored once `active` is written. */
   defaultActive?: (HelixSteps["defaultActive"]) | undefined;
+  /** Whether the arrow keys move focus between the stages' names, along the
+way the steps run. Off by default, so the arrows keep scrolling the page. */
+  arrows?: (HelixSteps["arrows"]) | undefined;
+  /** What marks a stage `complete`.
+
+Absent, you do: each step's `complete` is yours, because a reader who
+steps back has finished more stages than the one they are on. `passed`
+marks every stage before the one a reader moves to, and leaves the marks
+when they go back. */
+  completion?: (HelixSteps["completion"]) | undefined;
   /** The sequence's name, read by screen readers.
 
 A list of stages is a landmark a reader arrives at out of order, so it
@@ -15682,8 +16376,36 @@ was, and the control says `aria-readonly`. A script can still set
 The attribute is `readonly`, which is the platform's spelling for the
 text fields. */
   readOnly?: (HelixSwitch["readOnly"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixSwitch["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixSwitch["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixSwitch["feedback"]) | undefined;
@@ -16059,6 +16781,22 @@ is set. */
   "dropped-label"?: (HelixTable["droppedLabel"]) | undefined;
   /** What screen readers hear when a held row is dropped, in a `reorderable` table. */
   droppedLabel?: (HelixTable["droppedLabel"]) | undefined;
+  /** The text shown and announced when the rows could not load. Set it when a
+fetch fails, and clear it once you try again. Empty, the default, shows
+nothing.
+
+While it is set, a line after the rows shows it, or your own content in the
+`error` slot, in place of the empty and loading lines, and the live region
+says it. */
+  "error-text"?: (HelixTable["errorText"]) | undefined;
+  /** The text shown and announced when the rows could not load. Set it when a
+fetch fails, and clear it once you try again. Empty, the default, shows
+nothing.
+
+While it is set, a line after the rows shows it, or your own content in the
+`error` slot, in place of the empty and loading lines, and the live region
+says it. */
+  errorText?: (HelixTable["errorText"]) | undefined;
   /** The table's name where neither `label` nor an `aria-label` or
 `aria-labelledby` on the host gives it one. */
   "fallback-label"?: (HelixTable["fallbackLabel"]) | undefined;
@@ -16262,6 +17000,12 @@ panels and tells a screen reader the list is vertical.
 
 Optional, so the resting row writes no attribute onto the host. */
   orientation?: (HelixTabs["orientation"]) | undefined;
+  /** Whether a strip with more tabs than fit shows a button at each end it can
+scroll toward. */
+  "scroll-controls"?: (HelixTabs["scrollControls"]) | undefined;
+  /** Whether a strip with more tabs than fit shows a button at each end it can
+scroll toward. */
+  scrollControls?: (HelixTabs["scrollControls"]) | undefined;
   /** How the row of tabs is drawn.
 
 Unset is a raised pill on the selected tab with nothing behind the row,
@@ -16298,11 +17042,38 @@ export type HelixTabsVueEvents = {
 
 /** `HelixTab` component event */
 export type HelixTabElementEvent<E = Event> = TypedEvent<HelixTab, E>;
+/** `helix-dismiss` event type */
+export type HelixTabHelixDismissElementEvent =
+  HelixTabElementEvent<HelixDismissEvent>;
 /** `helix-select` event type */
 export type HelixTabHelixSelectElementEvent =
   HelixTabElementEvent<HelixSelectEvent>;
 
 export type HelixTabVueProps = {
+  /** Whether the element shows a control that dismisses it. */
+  dismissible?: (HelixTab["dismissible"]) | undefined;
+  /** The dismiss control's label, read by screen readers.
+
+`attribute` is spelled out because Lit lowercases a property name to
+derive one rather than dash-casing it, so this would otherwise be
+reachable only as `dismisslabel`, which nobody would guess and no linter
+would catch.
+
+A word property: register it for a locale under the host's key. A family
+that names the control otherwise, such as Tag's `Remove {label}`,
+declares its own English with `@words` above the override. */
+  "dismiss-label"?: (HelixTab["dismissLabel"]) | undefined;
+  /** The dismiss control's label, read by screen readers.
+
+`attribute` is spelled out because Lit lowercases a property name to
+derive one rather than dash-casing it, so this would otherwise be
+reachable only as `dismisslabel`, which nobody would guess and no linter
+would catch.
+
+A word property: register it for a locale under the host's key. A family
+that names the control otherwise, such as Tag's `Remove {label}`,
+declares its own English with `@words` above the override. */
+  dismissLabel?: (HelixTab["dismissLabel"]) | undefined;
   /** Whether the item is disabled and cannot be chosen. */
   disabled?: (HelixTab["disabled"]) | undefined;
   /** Whether the item is selected.
@@ -16324,6 +17095,8 @@ of tabs that are pages of a site. */
 };
 
 export type HelixTabVueEvents = {
+  /** A `dismissible` tab was asked to close. The tab does not remove itself, so remove it and its panel in response. Cancelable. */
+  "helix-dismiss": HelixTabHelixDismissElementEvent;
   /** Fired when the tab is chosen. Cancelable: canceling it stops the change and leaves the decision to you. */
   "helix-select": HelixTabHelixSelectElementEvent;
 };
@@ -16338,6 +17111,14 @@ export type HelixTagGroupHelixDismissElementEvent =
   HelixTagGroupElementEvent<HelixDismissEvent>;
 
 export type HelixTagGroupVueProps = {
+  /** Keeps at least one tag selected once one is, as React Aria's
+`disallowEmptySelection`: a press or a key that would leave none selected
+is refused. Removing the last selected tag still takes it out of `value`. */
+  "disallow-empty-selection"?: (HelixTagGroup["disallowEmptySelection"]) | undefined;
+  /** Keeps at least one tag selected once one is, as React Aria's
+`disallowEmptySelection`: a press or a key that would leave none selected
+is refused. Removing the last selected tag still takes it out of `value`. */
+  disallowEmptySelection?: (HelixTagGroup["disallowEmptySelection"]) | undefined;
   /** The words the group shows and says once its last tag is removed, where
 nothing is in the `empty` slot. */
   "empty-label"?: (HelixTagGroup["emptyLabel"]) | undefined;
@@ -16347,6 +17128,20 @@ nothing is in the `empty` slot. */
   /** The name of the set, such as "Filters", which a screen reader announces
 before its tags. */
   label?: (HelixTagGroup["label"]) | undefined;
+  /** What a press, Space, or a move does to the tags already selected.
+`toggle`, the default, keeps them: a press adds or takes out the tag, and
+the arrow keys move focus alone. `replace` selects the tag alone, as a
+file list does, and the arrow keys carry the selection with focus.
+Control or Command with a press or Space adds or takes out one tag in
+`multiple`, and with an arrow moves focus without selecting. */
+  "selection-behavior"?: (HelixTagGroup["selectionBehavior"]) | undefined;
+  /** What a press, Space, or a move does to the tags already selected.
+`toggle`, the default, keeps them: a press adds or takes out the tag, and
+the arrow keys move focus alone. `replace` selects the tag alone, as a
+file list does, and the arrow keys carry the selection with focus.
+Control or Command with a press or Space adds or takes out one tag in
+`multiple`, and with an arrow moves focus without selecting. */
+  selectionBehavior?: (HelixTagGroup["selectionBehavior"]) | undefined;
   /** How many tags a reader can select: `single`, `multiple`, or none.
 
 Absent selects nothing, and the tags carry no selected state at all. */
@@ -16575,8 +17370,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixTextarea["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixTextarea["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixTextarea["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixTextarea["feedback"]) | undefined;
@@ -16891,8 +17714,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixTimeInput["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixTimeInput["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixTimeInput["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixTimeInput["feedback"]) | undefined;
@@ -17180,6 +18031,19 @@ 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 list says when no time falls between `min` and `max`.
+
+The fallback of the `empty` slot. */
+  "empty-text"?: (HelixTimePicker["emptyText"]) | undefined;
+  /** What the list says when no time falls between `min` and `max`.
+
+The fallback of the `empty` slot. */
+  emptyText?: (HelixTimePicker["emptyText"]) | undefined;
+  /** Help under the times, such as the hours a shop is open, read by screen
+readers as the list's description. A message in `feedback` replaces it.
+
+The fallback of the `hint` slot. */
+  hint?: (HelixTimePicker["hint"]) | undefined;
   /** The clock the times are written on: `h12` for twelve hours with a
 meridiem, `h23` for twenty-four.
 
@@ -17206,7 +18070,8 @@ English, "Stunde" in German. */
   hourLabel?: (HelixTimePicker["hourLabel"]) | undefined;
   /** 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. */
+An `aria-label` or `aria-labelledby` on the host names the list instead,
+and so does a label slotted into `label`, which is also drawn above it. */
   label?: (HelixTimePicker["label"]) | undefined;
   /** Language tag the times and the wheels' names are written in.
 
@@ -17432,6 +18297,11 @@ Whatever `<time>` accepts, which is a date, a time, both, a duration or a
 week. Unset, the label is written as it was given and nothing claims to
 know what instant it names. */
   datetime?: (HelixTimelineItem["datetime"]) | undefined;
+  /** Writes the time as how long ago it was, or how long until it, from
+`datetime`, where the `time` slot is empty: `long` ("3 hours ago"),
+`short` ("3 hr. ago") or `narrow` ("3h ago"). Set with no value, it is
+`long`. The words move on as they go stale. */
+  relative?: (HelixTimelineItem["relative"]) | undefined;
   /** The kind of event. It sets the color of the mark and nothing else. */
   tone?: (HelixTimelineItem["tone"]) | undefined;
 };
@@ -17607,8 +18477,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixToggleGroup["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixToggleGroup["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixToggleGroup["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixToggleGroup["feedback"]) | undefined;
@@ -18394,6 +19292,18 @@ refused, in a `reorderable` tree. */
 An `aria-label` or `aria-labelledby` on the host names the tree too, and
 wins over this. */
   label?: (HelixTree["label"]) | undefined;
+  /** What screen readers hear when an item moves into another branch, in a
+`reorderable` tree. `{name}` is the item's words, `{parent}` the words of
+the branch it moved into, or the tree's `label` for the top level,
+`{position}` its place there, counting from 1, and `{count}` the number of
+items there. */
+  "moved-into-label"?: (HelixTree["movedIntoLabel"]) | undefined;
+  /** What screen readers hear when an item moves into another branch, in a
+`reorderable` tree. `{name}` is the item's words, `{parent}` the words of
+the branch it moved into, or the tree's `label` for the top level,
+`{position}` its place there, counting from 1, and `{count}` the number of
+items there. */
+  movedIntoLabel?: (HelixTree["movedIntoLabel"]) | undefined;
   /** What screen readers hear each time an item moves, in a `reorderable`
 tree. `{name}` is the item's words, `{position}` its place among its
 siblings, counting from 1, and `{count}` the number of siblings. */
@@ -18673,6 +19583,20 @@ Ignored once `active` is written. */
   defaultActive?: (HelixVideoPlaylist["defaultActive"]) | undefined;
   /** The list's name, read by screen readers. */
   label?: (HelixVideoPlaylist["label"]) | undefined;
+  /** What the live region says when the playlist moves to another entry.
+`{title}` is the entry's name.
+
+**A move a reader did not make is said.** At the end of a clip the
+playlist starts the next one, and the only other trace of that is the
+`aria-current` on a button the reader is not on. */
+  "playing-label"?: (HelixVideoPlaylist["playingLabel"]) | undefined;
+  /** What the live region says when the playlist moves to another entry.
+`{title}` is the entry's name.
+
+**A move a reader did not make is said.** At the end of a clip the
+playlist starts the next one, and the only other trace of that is the
+`aria-current` on a button the reader is not on. */
+  playingLabel?: (HelixVideoPlaylist["playingLabel"]) | undefined;
   /** What happens when an entry ends with no next one to go to. `one` plays the
 same entry again, and `all` goes from the last entry back to the first.
 Absent, the playlist stops on the last entry and sends `helix-end`.
@@ -18744,6 +19668,10 @@ permitted is the browser's policy, and what follows a refused autoplay is a
 paused player showing its start control, which is the correct thing to be
 looking at. */
   autoplay?: (HelixVideo["autoplay"]) | undefined;
+  /** What the live region says when `c` turns captions off. */
+  "captions-hidden-label"?: (HelixVideo["captionsHiddenLabel"]) | undefined;
+  /** What the live region says when `c` turns captions off. */
+  captionsHiddenLabel?: (HelixVideo["captionsHiddenLabel"]) | undefined;
   /** The name of the captions control when the video has one track. The control
 turns that track on and off.
 
@@ -18764,6 +19692,10 @@ tracks. */
   /** The name of the row that turns captions off, when the video has several
 tracks. */
   captionsOffLabel?: (HelixVideo["captionsOffLabel"]) | undefined;
+  /** What the live region says when `c` turns captions on. */
+  "captions-shown-label"?: (HelixVideo["captionsShownLabel"]) | undefined;
+  /** What the live region says when `c` turns captions on. */
+  captionsShownLabel?: (HelixVideo["captionsShownLabel"]) | undefined;
   /** Whether the browser draws its native controls. When set, this element draws
 no controls of its own.
 
@@ -18940,6 +19872,10 @@ writes the current entry's name here. */
   "more-label"?: (HelixVideo["moreLabel"]) | undefined;
   /** What the button that opens `overflow-controls` is called. */
   moreLabel?: (HelixVideo["moreLabel"]) | undefined;
+  /** What the live region says when a key mutes the video. */
+  "muted-label"?: (HelixVideo["mutedLabel"]) | undefined;
+  /** What the live region says when a key mutes the video. */
+  mutedLabel?: (HelixVideo["mutedLabel"]) | undefined;
   /** The name of the mute control. The control shows as pressed while the video
 is muted. */
   "mute-label"?: (HelixVideo["muteLabel"]) | undefined;
@@ -18982,6 +19918,10 @@ So the consumer says where the fold is, which they can, having already
 named the controls in order. A name in both lists is drawn once, on the
 bar: two of the same control is worse than either placement. */
   overflowControls?: (HelixVideo["overflowControls"]) | undefined;
+  /** What the live region says when a key pauses the video. */
+  "paused-label"?: (HelixVideo["pausedLabel"]) | undefined;
+  /** What the live region says when a key pauses the video. */
+  pausedLabel?: (HelixVideo["pausedLabel"]) | undefined;
   /** The name of the play control while pressing it would pause the video. */
   "pause-label"?: (HelixVideo["pauseLabel"]) | undefined;
   /** The name of the play control while pressing it would pause the video. */
@@ -19004,6 +19944,10 @@ this is what a screen reader calls it on arriving. */
   /** The name of the player when `label` is not set. The player is a group, and
 this is what a screen reader calls it on arriving. */
   playerLabel?: (HelixVideo["playerLabel"]) | undefined;
+  /** What the live region says when a key plays the video. */
+  "playing-label"?: (HelixVideo["playingLabel"]) | undefined;
+  /** What the live region says when a key plays the video. */
+  playingLabel?: (HelixVideo["playingLabel"]) | undefined;
   /** The name of the play control while pressing it would start the video. */
   "play-label"?: (HelixVideo["playLabel"]) | undefined;
   /** The name of the play control while pressing it would start the video. */
@@ -19102,6 +20046,16 @@ negation. */
   /** How the scrubber reads out where the video is, with `{position}` and
 `{duration}` filled in. */
   timeLabel?: (HelixVideo["timeLabel"]) | undefined;
+  /** What the live region says when a key unmutes the video. */
+  "unmuted-label"?: (HelixVideo["unmutedLabel"]) | undefined;
+  /** What the live region says when a key unmutes the video. */
+  unmutedLabel?: (HelixVideo["unmutedLabel"]) | undefined;
+  /** What the live region says when a key changes the volume. `{percent}` is the
+volume from 0 to 100, written in the locale. */
+  "volume-changed-label"?: (HelixVideo["volumeChangedLabel"]) | undefined;
+  /** What the live region says when a key changes the volume. `{percent}` is the
+volume from 0 to 100, written in the locale. */
+  volumeChangedLabel?: (HelixVideo["volumeChangedLabel"]) | undefined;
   /** What the volume slider is called. */
   "volume-label"?: (HelixVideo["volumeLabel"]) | undefined;
   /** What the volume slider is called. */
@@ -19585,6 +20539,8 @@ export type CustomCssProperties = {
   "--canvas-selected-color"?: (string) | undefined;
   /** The background of the pan and zoom buttons. `Map` uses the same property. */
   "--viewport-control-background-color"?: (string) | undefined;
+  /** The board's zoom, which the board writes: 1 at the document's own size, 0.5 at half. The cards inherit it, so a card's stylesheet can draw less when the board is far out, such as a border that stays one pixel wide at `calc(1px / var(--canvas-zoom))`. */
+  "--canvas-zoom"?: (string) | undefined;
   /** How the regions pack when the card is stretched taller than its content. `start` by default, so the slack is at the bottom; `space-between` puts a footer on the floor. */
   "--card-align"?: (string) | undefined;
   /** Filter applied behind a `frosted` or `glass` card. Follows the theme's material policy; set it to override the strength on one card. */
@@ -19859,6 +20815,8 @@ export type CustomCssProperties = {
   "--data-table-drop-indicator-color"?: (string) | undefined;
   /** The thickness of the line where a moved row would land. */
   "--data-table-drop-indicator-size"?: (string) | undefined;
+  /** The color of the words in the line shown while `error-text` is set. */
+  "--data-table-error-color"?: (string) | undefined;
   /** The space between the grid and the footer below it. */
   "--data-table-footer-gap"?: (string) | undefined;
   /** The space between the pieces of the footer, such as a summary and the pagination. */
@@ -20411,8 +21369,16 @@ export type CustomCssProperties = {
   "--list-drag-preview-radius"?: (string) | undefined;
   /** The shadow that raises the copy of a row a pointer drags over the page. */
   "--list-drag-preview-shadow"?: (string) | undefined;
+  /** The color of the text in the row shown while the list has no rows. */
+  "--list-empty-color"?: (string) | undefined;
+  /** The space around the text in the row shown while the list has no rows. */
+  "--list-empty-padding"?: (string) | undefined;
   /** The space between rows. */
   "--list-gap"?: (string) | undefined;
+  /** The color of the text in the row drawn while `loading` is set. */
+  "--list-loading-color"?: (string) | undefined;
+  /** The space around the text in the row drawn while `loading` is set. */
+  "--list-loading-padding"?: (string) | undefined;
   /** The space that the markers of ordered and unordered lists sit in. */
   "--list-marker-gutter"?: (string) | undefined;
   /** The width of the rail's track. */
@@ -20725,7 +21691,7 @@ export type CustomCssProperties = {
   "--number-input-stepper-color"?: (string) | undefined;
   /** Icon color of a stepper button under the pointer. */
   "--number-input-stepper-color-hover"?: (string) | undefined;
-  /** Width and height of the stepper icons. */
+  /** Width and height of the stepper icons, drawn or slotted. */
   "--number-input-stepper-icon-size"?: (string) | undefined;
   /** Width of each stepper button. */
   "--number-input-stepper-size"?: (string) | undefined;
@@ -21105,6 +22071,8 @@ export type CustomCssProperties = {
   "--slider-marker-color"?: (string) | undefined;
   /** The color of the thumb. */
   "--slider-thumb-color"?: (string) | undefined;
+  /** The color of content in the `thumb` and `thumb-end` slots, drawn on the thumb. */
+  "--slider-thumb-content-color"?: (string) | undefined;
   /** The thumb's size along the track. It follows `--slider-thumb-size` unless you set it, and setting one of the two makes the thumb an oval. */
   "--slider-thumb-length"?: (string) | undefined;
   /** The thumb's corner radius. It is fully round by default, so a thumb with two different dimensions is a capsule unless you change it. */
@@ -21123,7 +22091,7 @@ export type CustomCssProperties = {
   "--slider-track-image"?: (string) | undefined;
   /** The thickness of the track. It matches the progress bar's size by default. */
   "--slider-track-size"?: (string) | undefined;
-  /** Where a bubble's thumb is, as a fraction of the track, 0 to 1. Set on each `tooltip` part. */
+  /** Where a bubble's or a thumb box's thumb is, as a fraction of the track, 0 to 1. Set on each `tooltip` and `thumb` part. */
   "--slider-at"?: (string) | undefined;
   /** The value as a fraction of the range, 0 to 1. */
   "--slider-fraction"?: (string) | undefined;
@@ -21289,6 +22257,8 @@ export type CustomCssProperties = {
   "--table-drag-preview-radius"?: (string) | undefined;
   /** The shadow that raises the copy of a row a pointer drags over the page. */
   "--table-drag-preview-shadow"?: (string) | undefined;
+  /** The color of the words in the line shown while `error-text` is set. */
+  "--table-error-color"?: (string) | undefined;
   /** The color of the words in the `heading` slot. */
   "--table-title-color"?: (string) | undefined;
   /** The space between the `heading` slot and the grid. */
@@ -21325,12 +22295,16 @@ export type CustomCssProperties = {
   "--tabs-indicator-thickness"?: (string) | undefined;
   /** The color of the rule under the row in `underlined`. */
   "--tabs-rule-color"?: (string) | undefined;
+  /** The fill behind the scroll buttons, over the tabs that pass under them. */
+  "--tabs-scroll-background-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;
   /** How faint a disabled tab is drawn. */
   "--tabs-tab-disabled-opacity"?: (string) | undefined;
+  /** The color of the mark that closes a `dismissible` tab. */
+  "--tabs-tab-dismiss-color"?: (string) | undefined;
   /** The size of a tab's label. */
   "--tabs-tab-font-size"?: (string) | undefined;
   /** The weight of a tab's label. */
@@ -21425,12 +22399,20 @@ export type CustomCssProperties = {
   "--time-picker-wheel-mask"?: (string) | undefined;
   /** The color of the heading. */
   "--timeline-group-heading-color"?: (string) | undefined;
+  /** Space between the rail and the time and what happened. */
+  "--timeline-column-gap"?: (string) | undefined;
+  /** The color of the mark on an entry with no `tone`. A `tone` colors the mark itself. */
+  "--timeline-marker-color"?: (string) | undefined;
   /** How round the mark is. Zero is a square, and half its size is a disc. */
   "--timeline-marker-radius"?: (string) | undefined;
   /** Edge length of the mark. */
   "--timeline-marker-size"?: (string) | undefined;
+  /** The color of the line. */
+  "--timeline-rail-color"?: (string) | undefined;
   /** Width of the line. */
   "--timeline-rail-size"?: (string) | undefined;
+  /** The color of the time. */
+  "--timeline-time-color"?: (string) | undefined;
   /** Space between one entry and the next. */
   "--timeline-gap"?: (string) | undefined;
   /** The panel's color. Follows `--helix-color-surface-overlay`. */
@@ -21701,6 +22683,8 @@ export type CustomCssProperties = {
   "--virtual-list-scrollbar-track-color"?: (string) | undefined;
   /** The fill behind a chosen row, in a list with `selection-mode`. */
   "--virtual-list-selected-background-color"?: (string) | undefined;
+  /** The color of the text in a chosen row, in a list with `selection-mode`. Inherited by default. */
+  "--virtual-list-selected-color"?: (string) | undefined;
 };
 
 // Vue SFC template type-checking (GlobalComponents) for non-Vue custom elements.
@@ -22349,13 +23333,13 @@ export interface WcToolkitVueGlobalComponents {
     HelixRatingVueProps,
     HelixRatingVueEvents
   >;
-  /** A sandboxed '<iframe>' that loads 'src', a document you provide. That document imports what the examples need, listens for a render message, and writes the markup into itself.  **Examples render in a frame**, so an example's styles and scripts do not affect the page around the sandbox, and 'position: fixed' stays inside the pane. The frame starts empty, with its own stylesheets and its own custom element registry, so 'src' must load the styles and components the examples use.  **The source is untrusted, and the frame keeps it isolated.** The frame uses 'sandbox="allow-scripts"' and never 'allow-same-origin'. Together, the two let a document on the same origin remove its own sandbox, which is the same as having none.  **A preview says where it is.** It is ':state(loading)' from the moment it has a 'src' until that document can take the example, and again through 'reload()'. It is ':state(failed)' once the example throws an error it does not catch, until the next source is sent, which a frame on 'servePreview' reports. A page draws its own spinner or message from either, such as a sibling shown by 'helix-sandbox-preview:state(failed) + .message'. */
+  /** A sandboxed '<iframe>' that loads 'src', a document you provide. That document imports what the examples need, listens for a render message, and writes the markup into itself.  **Without 'src', the frame loads a built-in document**, so a sandbox renders with nothing to host. It runs HTML, CSS, and scripts, and reports the console, uncaught errors, its height, and presses as a frame on 'servePreview' does. It defines no element, so an example that uses Helix components needs a 'src' that imports them.  **Examples render in a frame**, so an example's styles and scripts do not affect the page around the sandbox, and 'position: fixed' stays inside the pane. The frame starts empty, with its own stylesheets and its own custom element registry, so 'src' must load the styles and components the examples use.  **The source is untrusted, and the frame keeps it isolated.** The frame uses 'sandbox="allow-scripts"' and never 'allow-same-origin'. Together, the two let a document on the same origin remove its own sandbox, which is the same as having none.  **A preview says where it is.** It is ':state(loading)' from the moment it has a 'src' until that document can take the example, and again through 'reload()'. It is ':state(failed)' once the example throws an error it does not catch, until the next source is sent, which a frame on 'servePreview' reports. A page draws its own spinner or message from either, such as a sibling shown by 'helix-sandbox-preview:state(failed) + .message'. */
   "helix-sandbox-preview": DefineCustomElement<
     HelixSandboxPreview,
     HelixSandboxPreviewVueProps,
     HelixSandboxPreviewVueEvents
   >;
-  /** A source pane dispatches 'helix-before-edit', which bubbles, and the sandbox passes the value to the preview slotted into it. The source pane and the preview do not reference each other, so you can replace either one or use it alone.  The event carries the pane's 'name', so one sandbox can hold several panes. 'html' sets the preview's markup and 'css' sets its stylesheet. The sandbox ignores a pane with any other name, so that pane can show content without changing the preview.  **The dividers are two nested 'helix-splitter' elements**, which handle the pointer, the keyboard, and the corner. The inner splitter holds the panes and the outer one holds the panel, so the panel spans the full width.  On a focused divider, the arrow keys move it, and 'Home' and 'End' move it to its ends. 'Enter' on the panes divider shuts the lead pane, and pressed again it opens the pane where it was. 'Enter' on the panel divider shuts the panel to 'panel-collapsed-size', and pressed again it opens the panel to its last height. */
+  /** A source pane dispatches 'helix-before-edit', which bubbles, and the sandbox passes the value to the preview slotted into it. The source pane and the preview do not reference each other, so you can replace either one or use it alone.  The event carries the pane's 'name', so one sandbox can hold several panes. 'html' sets the preview's markup, 'css' sets its stylesheet, and 'js' sets a script that runs as a module after the markup. The sandbox ignores a pane with any other name, so that pane can show content without changing the preview.  **The dividers are two nested 'helix-splitter' elements**, which handle the pointer, the keyboard, and the corner. The inner splitter holds the panes and the outer one holds the panel, so the panel spans the full width.  On a focused divider, the arrow keys move it, and 'Home' and 'End' move it to its ends. 'Enter' on the panes divider shuts the lead pane, and pressed again it opens the pane where it was. 'Enter' on the panel divider shuts the panel to 'panel-collapsed-size', and pressed again it opens the panel to its last height. */
   "helix-sandbox": DefineCustomElement<
     HelixSandbox,
     HelixSandboxVueProps,
@@ -22529,7 +23513,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixTagGroupVueProps,
     HelixTagGroupVueEvents
   >;
-  /** Seven tones. The fill is a tint of the status color made with 'color-mix', so when a theme changes its status colors, the tints change with them. */
+  /** Seven tones. The fill is a tint of the status color made with 'color-mix', so when a theme changes its status colors, the tints change with them.  A tag takes its height from the region it is in, as the controls beside it do: 'data-density="sm"', 'md', or 'lg' on the tag or on any element around it sets '--helix-size-tag' to the small, resting, or large step, so a row of tags and buttons stays one height. 'shape="pill"' rounds its ends. */
   "helix-tag": DefineCustomElement<
     HelixTag,
     HelixTagVueProps,
@@ -22571,7 +23555,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixTimelineItemVueProps,
     HelixTimelineItemVueEvents
   >;
-  /** Sets the direction time runs in and the spacing between events. Each entry draws its own mark and line.  'layout' and 'orientation' move where the entries are drawn, and never the order they are read in, which is the order you write them in:  - Unset, the line runs down the start edge, with each time over what   happened. - 'layout="opposite"' runs the line down the middle, with each time on the   start side and what happened on the end side. - 'layout="alternate"' runs the line down the middle, with the first entry on   the end side, the second on the start side, and so on. - 'orientation="horizontal"' runs the line across the top, with the entries   side by side in the order they are read, and the time over what happened   under each mark. Use it for a few entries, since they share the width. */
+  /** Sets the direction time runs in and the spacing between events. Each entry draws its own mark and line.  'layout' and 'orientation' move where the entries are drawn, and never the order they are read in, which is the order you write them in:  - Unset, the line runs down the start edge, with each time over what   happened. - 'layout="opposite"' runs the line down the middle, with each time on the   start side and what happened on the end side. - 'layout="alternate"' runs the line down the middle, with the first entry on   the end side, the second on the start side, and so on. - 'orientation="horizontal"' runs the line across the top, with the entries   side by side in the order they are read, and the time over what happened   under each mark. Use it for a few entries, since they share the width.  An entry's custom properties, such as '--timeline-rail-color' and '--timeline-marker-size', inherit, so setting them on the timeline changes every entry in it. */
   "helix-timeline": DefineCustomElement<
     HelixTimeline,
     HelixTimelineVueProps,