@fusion.dev/helix 0.143.0 → 0.145.0

package/types/vue.d.ts

@@ -82,6 +82,7 @@ import type {
   HelixMegamenu,
   HelixMenuItem,
   HelixMenu,
+  HelixMenuSection,
   HelixMeter,
   HelixNavigation,
   HelixNotificationGroup,
@@ -132,11 +133,13 @@ import type {
   HelixTabPanel,
   HelixTabs,
   HelixTab,
+  HelixTagGroup,
   HelixTag,
   HelixText,
   HelixTextarea,
   HelixTimeInput,
   HelixTimePicker,
+  HelixTimelineGroup,
   HelixTimelineItem,
   HelixTimeline,
   HelixToastItem,
@@ -160,6 +163,7 @@ import type {
   HelixBeforeOpenEvent,
   HelixDismissEvent,
   HelixScrolledEvent,
+  HelixAuraFallbackEvent,
   HelixBeforeMoveEvent,
   HelixBeforeReconnectEvent,
   HelixBeforeRelabelEvent,
@@ -175,6 +179,7 @@ import type {
   HelixSelectEvent,
   HelixActivateEvent,
   HelixSendEvent,
+  HelixTypingEvent,
   HelixBeforePinEvent,
   HelixHistoryEvent,
   HelixPinEvent,
@@ -185,13 +190,17 @@ import type {
   HelixSampleStartEvent,
   HelixCreateEvent,
   HelixFilterEvent,
+  HelixCopyErrorEvent,
+  HelixExpandEvent,
   HelixFilteredEvent,
+  HelixLoadMoreEvent,
   HelixNavigateEvent,
   HelixReorderEvent,
   HelixReorderedEvent,
   HelixSelectedEvent,
   HelixSortEvent,
   HelixSortedEvent,
+  HelixRejectEvent,
   HelixFacetEvent,
   HelixBeforeActivateEvent,
   HelixGraphFilterEvent,
@@ -202,7 +211,9 @@ import type {
   HelixGraphSignalEvent,
   HelixGraphZoomEvent,
   HelixResizeEvent,
+  HelixClearEvent,
   HelixShortcutEvent,
+  HelixActionEvent,
   HelixMapPartChangeEvent,
   HelixMapClusterEvent,
   HelixMapPanEvent,
@@ -210,6 +221,7 @@ import type {
   HelixMapRotateEvent,
   HelixMapTiltEvent,
   HelixMapZoomEvent,
+  HelixToggleEvent,
   HelixReadEvent,
   HelixCompleteEvent,
   HelixConsoleEvent,
@@ -217,13 +229,19 @@ import type {
   HelixBeforePanelResizeEvent,
   HelixBeforeSplitEvent,
   HelixCaretEvent,
+  HelixEditEvent,
+  HelixPanelResizeEvent,
+  HelixSplitEvent,
   HelixBeforeCollapseEvent,
   HelixBeforeResizeEvent,
   HelixCollapseEvent,
   HelixResizedEvent,
   HelixTourAskEvent,
+  HelixLoadEvent,
+  HelixEndEvent,
   HelixNextEvent,
   HelixPreviousEvent,
+  HelixRangeChangeEvent,
 } from "@fusion.dev/helix";
 import type { HTMLAttributes, PublicProps, EmitFn, EmitsToProps } from "vue";
 
@@ -328,6 +346,22 @@ too. */
 Unset takes the accordion's `heading-level`, and 3 where that is unset
 too. */
   headingLevel?: (HelixAccordionItem["headingLevel"]) | undefined;
+  /** Whether find in page searches the section while it is closed, and opens it
+on a match.
+
+Off by default. A closed section is then `hidden="until-found"`, which
+hides through `content-visibility`, so a stylesheet that animates the
+section closed shows an empty box for the length of that animation. The
+accordion's own `hidden-until-found` turns it on for every section. */
+  "hidden-until-found"?: (HelixAccordionItem["hiddenUntilFound"]) | undefined;
+  /** Whether find in page searches the section while it is closed, and opens it
+on a match.
+
+Off by default. A closed section is then `hidden="until-found"`, which
+hides through `content-visibility`, so a stylesheet that animates the
+section closed shows an empty box for the length of that animation. The
+accordion's own `hidden-until-found` turns it on for every section. */
+  hiddenUntilFound?: (HelixAccordionItem["hiddenUntilFound"]) | undefined;
   /** A group name. Opening an item closes the other items with the same name,
 as `<details name>` does.
 
@@ -388,6 +422,14 @@ Unset is 3. An item's own `heading-level` wins over this. */
 
 Unset is 3. An item's own `heading-level` wins over this. */
   headingLevel?: (HelixAccordion["headingLevel"]) | undefined;
+  /** Whether find in page searches every closed section, and opens the one it
+matches in. Each item's own `hidden-until-found` turns it on for that item
+alone. */
+  "hidden-until-found"?: (HelixAccordion["hiddenUntilFound"]) | undefined;
+  /** Whether find in page searches every closed section, and opens the one it
+matches in. Each item's own `hidden-until-found` turns it on for that item
+alone. */
+  hiddenUntilFound?: (HelixAccordion["hiddenUntilFound"]) | undefined;
   /** How many sections may be open at once.
 
 Absent is `multiple`, so nothing closes unexpectedly and the default costs
@@ -447,6 +489,12 @@ derive one rather than dash-casing it, so this would otherwise be
 reachable only as `dismisslabel`, which nobody would guess and no linter
 would catch. */
   dismissLabel?: (HelixAnnouncement["dismissLabel"]) | undefined;
+  /** How long the announcement stays, in milliseconds, before it sends
+`helix-dismiss`. When it is not set, it stays until it is dismissed.
+
+Read once when the announcement is first rendered, as `Toast` reads its
+own. The clock stops while the pointer or focus is on the announcement. */
+  duration?: (HelixAnnouncement["duration"]) | undefined;
   /** The band's color.
 
 Paint only: unlike `Callout`, no value here draws a mark, changes the label,
@@ -471,7 +519,7 @@ axes, which is the test the registry answers to. */
 };
 
 export type HelixAnnouncementVueEvents = {
-  /** The dismiss button was pressed. The announcement does not remove itself, so remove it in response. Cancelable. */
+  /** The dismiss button was pressed, or `duration` ran out. The announcement does not remove itself, so remove it in response. Cancelable. */
   "helix-dismiss": HelixAnnouncementHelixDismissElementEvent;
 };
 
@@ -634,6 +682,12 @@ fills the height and the bands are shares of it. */
 
 export type HelixAreaChartVueEvents = {};
 
+/** `HelixAura` component event */
+export type HelixAuraElementEvent<E = Event> = TypedEvent<HelixAura, E>;
+/** `helix-aura-fallback` event type */
+export type HelixAuraHelixAuraFallbackElementEvent =
+  HelixAuraElementEvent<HelixAuraFallbackEvent>;
+
 export type HelixAuraVueProps = {
   /** How soft the falloff is, `0` tight and `1` diffuse. */
   bloom?: (HelixAura["bloom"]) | undefined;
@@ -743,7 +797,10 @@ states. */
   variant?: (HelixAura["variant"]) | undefined;
 };
 
-export type HelixAuraVueEvents = {};
+export type HelixAuraVueEvents = {
+  /** Fired each time the aura stops drawing its shader and shows its gradient, with the reason. */
+  "helix-aura-fallback": HelixAuraHelixAuraFallbackElementEvent;
+};
 
 export type HelixAvatarGroupVueProps = {
   /** Accessible name for the set, such as "Reviewers". */
@@ -791,6 +848,24 @@ for it is the one the registry already has. */
   shape?: (HelixAvatar["shape"]) | undefined;
   /** Edge length of the avatar. */
   size?: (HelixAvatar["size"]) | undefined;
+  /** How long, in milliseconds, a picture may take before the initials stand
+in for it while it loads.
+
+Absent keeps the picture's place empty until it arrives or fails. Set,
+the initials show once the wait is over and the picture
+replaces them when it arrives, so a slow connection shows who it is
+without a cached picture flashing initials first. Radix's `delayMs` is the
+same idea. */
+  "fallback-delay"?: (HelixAvatar["fallbackDelay"] | `${number}`) | undefined;
+  /** How long, in milliseconds, a picture may take before the initials stand
+in for it while it loads.
+
+Absent keeps the picture's place empty until it arrives or fails. Set,
+the initials show once the wait is over and the picture
+replaces them when it arrives, so a slow connection shows who it is
+without a cached picture flashing initials first. Radix's `delayMs` is the
+same idea. */
+  fallbackDelay?: (HelixAvatar["fallbackDelay"]) | undefined;
   /** Name of the person or entity.
 
 Used for the label and the initials. */
@@ -820,6 +895,13 @@ export type HelixAvatarVueEvents = {
 };
 
 export type HelixBadgeVueProps = {
+  /** Where the mark sits: a corner, `top-start`, `bottom-end` or `bottom-start`,
+or `inline`, in the line after the content.
+
+Absent is the top end, the corner a count is looked for in. `inline` is
+for a badge inside a control, where its count is read as part of the
+control's name. */
+  placement?: (HelixBadge["placement"]) | undefined;
   /** What the mark means. The stylesheet picks the fill from it.
 
 **`Tag`'s vocabulary, because a badge is the same kind of thing.** Both are
@@ -1122,6 +1204,12 @@ export type HelixBreadcrumbsVueProps = {
   /** The landmark's name, read by screen readers. An `aria-label` on the host
 wins over it. */
   label?: (HelixBreadcrumbs["label"]) | undefined;
+  /** The trail as data, drawn as crumbs before any you slot. The last item is the
+current page.
+
+React Aria's `items`. A property only: a trail is built by script, and an
+attribute would put the whole path into the markup twice. */
+  items?: (HelixBreadcrumbs["items"]) | undefined;
 };
 
 export type HelixBreadcrumbsVueEvents = {};
@@ -1285,6 +1373,22 @@ Lives here rather than only on `IconButton` so the two share one render.
 An icon-only button without it is a control a screen reader announces as
 "button" and nothing else. */
   label?: (HelixButton["label"]) | undefined;
+  /** Whether the action the button started is still running.
+
+A pending button keeps focus and stays in the tab order, and refuses every
+press: a click, Enter and Space, and Enter in a field of its form. The
+click does not reach your listeners. The inner control carries
+`aria-busy` and `aria-disabled`, and when the button becomes pending while
+it has focus, a reader hears `pending-label`. The styled button draws a
+turning ring over its words.
+
+`disabled` takes the button out of reach. Use `pending` for the wait after
+a press, so focus stays where the reader left it. */
+  pending?: (HelixButton["pending"]) | undefined;
+  /** What a reader hears when the button becomes pending while it has focus. */
+  "pending-label"?: (HelixButton["pendingLabel"]) | undefined;
+  /** What a reader hears when the button becomes pending while it has focus. */
+  pendingLabel?: (HelixButton["pendingLabel"]) | undefined;
   /** What activating the button does to its form. */
   type?: (HelixButton["type"]) | undefined;
   /** The value this button submits under its own `name`, as a native submit
@@ -1384,7 +1488,40 @@ invoker without an id in the same tree needs. */
 
 export type HelixButtonVueEvents = {};
 
+/** `HelixCallout` component event */
+export type HelixCalloutElementEvent<E = Event> = TypedEvent<HelixCallout, E>;
+/** `helix-dismiss` event type */
+export type HelixCalloutHelixDismissElementEvent =
+  HelixCalloutElementEvent<HelixDismissEvent>;
+
 export type HelixCalloutVueProps = {
+  /** Where the callout's box ends, whatever its tone.
+
+Absent, or `filled`, is the tint with the bar, the resting look.
+`outlined` draws the tone at the edge with no fill, and `plain` keeps only
+the bar and the mark, for an aside in running prose. The bar stays in
+every one, being what says the tone where the hue is not seen.
+
+Web Awesome calls this `appearance`. It is `separation` here, as on
+`Announcement` and `Card`, since a box's edge and its meaning are two
+choices. */
+  separation?: (HelixCallout["separation"]) | undefined;
+  /** Whether the element shows a control that dismisses it. */
+  dismissible?: (HelixCallout["dismissible"]) | undefined;
+  /** The dismiss control's label, read by screen readers.
+
+`attribute` is spelled out because Lit lowercases a property name to
+derive one rather than dash-casing it, so this would otherwise be
+reachable only as `dismisslabel`, which nobody would guess and no linter
+would catch. */
+  "dismiss-label"?: (HelixCallout["dismissLabel"]) | undefined;
+  /** The dismiss control's label, read by screen readers.
+
+`attribute` is spelled out because Lit lowercases a property name to
+derive one rather than dash-casing it, so this would otherwise be
+reachable only as `dismisslabel`, which nobody would guess and no linter
+would catch. */
+  dismissLabel?: (HelixCallout["dismissLabel"]) | undefined;
   /** What kind of attention the passage needs.
 
 `tone` is the axis for what a thing means, and this is a subset of it: a
@@ -1404,7 +1541,10 @@ Absent is the English for the tone: "Error", "Information", "Note",
   toneLabel?: (HelixCallout["toneLabel"]) | undefined;
 };
 
-export type HelixCalloutVueEvents = {};
+export type HelixCalloutVueEvents = {
+  /** The dismiss button was pressed. The callout does not remove itself, so remove it in response. Cancelable. */
+  "helix-dismiss": HelixCalloutHelixDismissElementEvent;
+};
 
 export type HelixCanvasEdgeVueProps = {
   /** The name of the card the connection starts from. */
@@ -2048,6 +2188,10 @@ twice what this says once.
 Reflected and undefaulted, so a card that has not asked reads as a card
 with no attribute on it and the stylesheet only describes the departure. */
   mediaPlacement?: (HelixCard["mediaPlacement"]) | undefined;
+  /**  */
+  "aria-labelledby"?: unknown;
+  /**  */
+  "aria-label"?: unknown;
 };
 
 export type HelixCardVueEvents = {};
@@ -2319,6 +2463,18 @@ read out in English. */
   label?: (HelixCarousel["label"]) | undefined;
   /** Whether moving past either end wraps to the other. */
   loop?: (HelixCarousel["loop"]) | undefined;
+  /** Whether a mouse can drag the track from slide to slide.
+
+Off unless asked for, because a press on a slide is then the start of a
+drag, and text in a slide can no longer be selected with the mouse. A drag
+of a few pixels or less is still a press. */
+  "mouse-drag"?: (HelixCarousel["mouseDrag"]) | undefined;
+  /** Whether a mouse can drag the track from slide to slide.
+
+Off unless asked for, because a press on a slide is then the start of a
+drag, and text in a slide can no longer be selected with the mouse. A drag
+of a few pixels or less is still a press. */
+  mouseDrag?: (HelixCarousel["mouseDrag"]) | undefined;
   /** The name of the control that moves to the next slide. */
   "next-label"?: (HelixCarousel["nextLabel"]) | undefined;
   /** The name of the control that moves to the next slide. */
@@ -2460,6 +2616,14 @@ case is the absent attribute, and the styles read it that way. */
   "previous-label"?: (HelixCarousel["previousLabel"]) | undefined;
   /** The name of the control that moves to the previous slide. */
   previousLabel?: (HelixCarousel["previousLabel"]) | undefined;
+  /** The word screen readers announce in place of the carousel's role, set as
+`aria-roledescription`. Translate it with the rest of your text, or empty
+it to leave the role as `group`. */
+  "role-label"?: (HelixCarousel["roleLabel"]) | undefined;
+  /** The word screen readers announce in place of the carousel's role, set as
+`aria-roledescription`. Translate it with the rest of your text, or empty
+it to leave the role as `group`. */
+  roleLabel?: (HelixCarousel["roleLabel"]) | undefined;
   /** The name of each slide, with `{index}` and `{count}` filled in. */
   "slide-label"?: (HelixCarousel["slideLabel"]) | undefined;
   /** The name of each slide, with `{index}` and `{count}` filled in. */
@@ -2495,10 +2659,11 @@ export type HelixChatComposerElementEvent<E = Event> = TypedEvent<
 /** `helix-send` event type */
 export type HelixChatComposerHelixSendElementEvent =
   HelixChatComposerElementEvent<HelixSendEvent>;
+/** `helix-typing` event type */
+export type HelixChatComposerHelixTypingElementEvent =
+  HelixChatComposerElementEvent<HelixTypingEvent>;
 
 export type HelixChatComposerVueProps = {
-  /** Whether the composer blocks input, such as while a turn is being sent. */
-  disabled?: (HelixChatComposer["disabled"]) | undefined;
   /** The field's name, read by screen readers. */
   label?: (HelixChatComposer["label"]) | undefined;
   /** Placeholder text shown in an empty field. */
@@ -2525,16 +2690,50 @@ button only.
 `button` is what a composer holding several paragraphs wants, where Enter
 has to mean a new line and nothing else. */
   submitOn?: (HelixChatComposer["submitOn"]) | undefined;
+  /** How long after the last keystroke the user still counts as typing, in
+milliseconds. */
+  "typing-timeout"?: (HelixChatComposer["typingTimeout"] | `${number}`) | undefined;
+  /** How long after the last keystroke the user still counts as typing, in
+milliseconds. */
+  typingTimeout?: (HelixChatComposer["typingTimeout"]) | undefined;
   /** The text the user has written.
 
 It follows typing, so reading it gives the draft. Set it to seed a draft or
 to replace the one in the field, and set it to `''` to clear it. */
   value?: (HelixChatComposer["value"]) | undefined;
+  /** Whether the control is disabled and cannot be used.
+
+Reflected, because the styled tier selects on it, and mirrored to
+`aria-disabled` rather than removing the element from the accessibility
+tree, so a screen reader can still announce that the control exists.
+
+The mirror itself is in `willUpdate` below, here rather than in each
+control, because here is where `disabled` is. */
+  disabled?: (HelixChatComposer["disabled"]) | undefined;
+  /** The name the control's value is submitted under.
+
+**Reflected, and it is the exception to "reflect only what CSS selects
+on".** The platform builds a form's entry list from the `name` *content
+attribute*, not from the property, so a control named through the property
+submitted under no name at all and was silently dropped. Measured: two
+inputs in one form, one named by attribute and one by property, and the
+form carried a single entry.
+
+Safe for a React consumer, which is what the rule is protecting: React
+renders a custom element's props as attributes on the server, so the name
+is already in the markup being hydrated and reflecting it writes what is
+there. It is only a change to the markup when a consumer assigns it
+imperatively later, and nothing is hydrating by then.
+
+Here rather than on each control. */
+  name?: (HelixChatComposer["name"]) | undefined;
 };
 
 export type HelixChatComposerVueEvents = {
   /** Fired when the user sends their turn, and cancelable. */
   "helix-send": HelixChatComposerHelixSendElementEvent;
+  /** The user started or stopped writing, with `typing` saying which, as the composer's `typing` does. */
+  "helix-typing": HelixChatComposerHelixTypingElementEvent;
   /** The user changed the text. Read it from `value`, for a typing indicator or a saved draft. Sent on the composer and does not bubble. */
   input: HelixChatComposerElementEvent;
 };
@@ -2579,6 +2778,18 @@ participants is the ordinary case for anything worth building this for.
 `me` and `them` are the conventional values and the stylesheet knows them;
 anything else is a name the consumer styles. */
   author?: (HelixChatMessage["author"]) | undefined;
+  /** The author's name, as a screen reader says it at the start of the turn,
+such as "Support" or "Ada Lovelace".
+
+Empty reads "You" for `me`, the `author` itself where it is a name, and
+nothing for `them`. */
+  "author-label"?: (HelixChatMessage["authorLabel"]) | undefined;
+  /** The author's name, as a screen reader says it at the start of the turn,
+such as "Support" or "Ada Lovelace".
+
+Empty reads "You" for `me`, the `author` itself where it is a name, and
+nothing for `them`. */
+  authorLabel?: (HelixChatMessage["authorLabel"]) | undefined;
   /** Label for a message that did not send. */
   "failed-label"?: (HelixChatMessage["failedLabel"]) | undefined;
   /** Label for a message that did not send. */
@@ -2670,6 +2881,18 @@ only the consumer knows whether the server has anything older. */
   historyText?: (HelixChat["historyText"]) | undefined;
   /** The conversation's name, read by screen readers. */
   label?: (HelixChat["label"]) | undefined;
+  /** The word a screen reader says for `me` when it names a turn. */
+  "me-label"?: (HelixChat["meLabel"]) | undefined;
+  /** The word a screen reader says for `me` when it names a turn. */
+  meLabel?: (HelixChat["meLabel"]) | undefined;
+  /** The name a screen reader gives a turn with both an author and a time.
+`{author}` is who wrote it and `{time}` is when, as the turn shows it. A
+turn with only one of the two is named by that one. */
+  "message-label"?: (HelixChat["messageLabel"]) | undefined;
+  /** The name a screen reader gives a turn with both an author and a time.
+`{author}` is who wrote it and `{time}` is when, as the turn shows it. A
+turn with only one of the two is named by that one. */
+  messageLabel?: (HelixChat["messageLabel"]) | undefined;
   /** Whether the transcript follows new turns to the bottom.
 
 The reader's scrolling asks first: `helix-before-pin` is cancelable, so a
@@ -2760,10 +2983,19 @@ and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   valueMissingMessage?: (HelixCheckboxGroup["valueMissingMessage"]) | undefined;
+  /** Whether a box above the set checks or unchecks every enabled box. */
+  "select-all"?: (HelixCheckboxGroup["selectAll"]) | undefined;
+  /** Whether a box above the set checks or unchecks every enabled box. */
+  selectAll?: (HelixCheckboxGroup["selectAll"]) | undefined;
+  /** The words beside the box `select-all` draws. */
+  "select-all-label"?: (HelixCheckboxGroup["selectAllLabel"]) | undefined;
+  /** The words beside the box `select-all` draws. */
+  selectAllLabel?: (HelixCheckboxGroup["selectAllLabel"]) | undefined;
   /** The checked values, comma separated.
 
 Read from the boxes once they are known, so a box a script ticks directly
-is in it at once. Written, it is pushed onto the boxes. */
+is in it at once. Written, it is pushed onto the boxes. A box whose value
+holds a comma cannot be named here: use `values`. */
   value?: (HelixCheckboxGroup["value"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
@@ -2791,6 +3023,11 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixCheckboxGroup["name"]) | undefined;
+  /** The checked values, as a list, in the order the boxes are written.
+
+The same set as `value`, and the one to use where a value may hold a
+comma. Written, it checks exactly those boxes and unchecks the rest. */
+  values?: (HelixCheckboxGroup["values"]) | undefined;
 };
 
 export type HelixCheckboxGroupVueEvents = {
@@ -2848,6 +3085,28 @@ stylesheets. */
   "default-checked"?: (HelixCheckbox["defaultChecked"]) | undefined;
   /** Whether the control starts checked. A form reset returns it to this state. */
   defaultChecked?: (HelixCheckbox["defaultChecked"]) | undefined;
+  /** Whether a reader can see and focus the control and cannot change it. A
+read-only control still submits its value.
+
+React Aria's `isReadOnly`. A native checkbox has no read-only state, so
+the press is refused at the inner control, which keeps its box as it
+was, and the control says `aria-readonly`. A script can still set
+`checked`, as it can set the value of a read-only text field.
+
+The attribute is `readonly`, which is the platform's spelling for the
+text fields. */
+  readonly?: (HelixCheckbox["readOnly"]) | undefined;
+  /** Whether a reader can see and focus the control and cannot change it. A
+read-only control still submits its value.
+
+React Aria's `isReadOnly`. A native checkbox has no read-only state, so
+the press is refused at the inner control, which keeps its box as it
+was, and the control says `aria-readonly`. A script can still set
+`checked`, as it can set the value of a read-only text field.
+
+The attribute is `readonly`, which is the platform's spelling for the
+text fields. */
+  readOnly?: (HelixCheckbox["readOnly"]) | undefined;
   /**  */
   "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
@@ -2926,13 +3185,28 @@ export type HelixCheckboxVueEvents = {
 };
 
 export type HelixCodeBlockVueProps = {
+  /** Whether long lines wrap.
+
+Off by default, so long lines scroll, because a line break can be
+significant in code and a wrapped line reads as two. For prose-like code, such as a long command or
+a log line, a wrap reads better than a scroll. Line numbers keep the lines
+unwrapped, since a wrapped line would take one number and several rows. */
+  wrap?: (HelixCodeBlock["wrap"]) | undefined;
   /** The copy button's name and tooltip text after a copy. */
   "copied-label"?: (HelixCodeBlock["copiedLabel"]) | undefined;
   /** The copy button's name and tooltip text after a copy. */
   copiedLabel?: (HelixCodeBlock["copiedLabel"]) | undefined;
-  /** The copy button's name and tooltip text before a copy. */
+  /** The copy button's name and tooltip text before a copy.
+
+Where the block has a name, the button says it too, such as "Copy code,
+app.ts", so each copy button on a page with several blocks is told apart.
+In a diff, that is each file's own name. */
   "copy-label"?: (HelixCodeBlock["copyLabel"]) | undefined;
-  /** The copy button's name and tooltip text before a copy. */
+  /** The copy button's name and tooltip text before a copy.
+
+Where the block has a name, the button says it too, such as "Copy code,
+app.ts", so each copy button on a page with several blocks is told apart.
+In a diff, that is each file's own name. */
   copyLabel?: (HelixCodeBlock["copyLabel"]) | undefined;
   /** Whether the content is a unified diff, drawn as the lines it changed.
 
@@ -2944,6 +3218,20 @@ Reflected, because the stylesheet paints a diff differently from code, and
 In a diff, each file is named from the patch, and this names a patch that
 carries no name of its own. */
   label?: (HelixCodeBlock["label"]) | undefined;
+  /** Whether the lines are numbered in a gutter beside the code.
+
+The numbers are hidden from the accessibility tree and are not part of a
+copy, which takes the code alone. Reflected, because the stylesheet lays
+the gutter out beside the code. A diff numbers its lines from its hunks
+whether or not this is set. */
+  "line-numbers"?: (HelixCodeBlock["lineNumbers"]) | undefined;
+  /** Whether the lines are numbered in a gutter beside the code.
+
+The numbers are hidden from the accessibility tree and are not part of a
+copy, which takes the code alone. Reflected, because the stylesheet lays
+the gutter out beside the code. A diff numbers its lines from its hunks
+whether or not this is set. */
+  lineNumbers?: (HelixCodeBlock["lineNumbers"]) | undefined;
   /** Whether to leave the copy button off.
 
 Negative, which is not a style choice. A boolean attribute is true whenever
@@ -2990,6 +3278,17 @@ Absent is unified, each removal above its replacement, which fits any
 width. `split` sets the old version beside the new one. Optional rather
 than defaulted, so the host carries no attribute the consumer did not write. */
   variant?: (HelixCodeBlock["variant"]) | undefined;
+  /** Turns the code into highlighted markup, which the block draws in place of
+the plain text.
+
+Called with the code as written and returning HTML, such as the output of
+Shiki's `codeToHtml` or Prism's `highlight`. **The markup is drawn as
+given**, so it has to escape the code it was handed, which those
+highlighters do. Bind the language in the function you pass. The code
+stays in the slot, so the copy button copies it as written and a reader
+without the script still has it. Not called on a server, which has no code
+to read, nor for a diff. */
+  highlight?: (HelixCodeBlock["highlight"]) | undefined;
 };
 
 export type HelixCodeBlockVueEvents = {};
@@ -3100,6 +3399,26 @@ point.** The field holds a color, so a browser offering to fill it with a
 saved address is competing for the same keystrokes as the picker. A
 consumer who wants autofill can still ask. */
   autocomplete?: (HelixColorInput["autocomplete"]) | undefined;
+  /** Whether the panel shows a number field for each channel of the color.
+Passed to the panel; see Color Picker's `channel-fields`. */
+  "channel-fields"?: (HelixColorInput["channelFields"]) | undefined;
+  /** Whether the panel shows a number field for each channel of the color.
+Passed to the panel; see Color Picker's `channel-fields`. */
+  channelFields?: (HelixColorInput["channelFields"]) | undefined;
+  /** The words a color's name is spoken in, as JSON keyed by their English,
+such as `{"red": "rot", "vibrant": "kräftiges"}`.
+
+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. */
+  "color-words"?: (HelixColorInput["colorWords"]) | undefined;
+  /** The words a color's name is spoken in, as JSON keyed by their English,
+such as `{"red": "rot", "vibrant": "kräftiges"}`.
+
+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`.
 
 **Undefaulted, because it reflects.** The two together stamp an attribute
@@ -3237,6 +3556,10 @@ ramps. A consumer who wants autofill can still ask. */
   "bad-input-message"?: (HelixColorPicker["badInputMessage"]) | undefined;
   /** The message shown when the value is text that is not a color. */
   badInputMessage?: (HelixColorPicker["badInputMessage"]) | undefined;
+  /** What the blue channel's field is called, in `channel-fields`. */
+  "blue-label"?: (HelixColorPicker["blueLabel"]) | undefined;
+  /** What the blue channel's field is called, in `channel-fields`. */
+  blueLabel?: (HelixColorPicker["blueLabel"]) | undefined;
   /** What the square's vertical ramp is called.
 
 **Every word the picker speaks is a property**, so a page in another
@@ -3247,6 +3570,50 @@ language hears its own rather than English between its own labels. */
 **Every word the picker speaks is a property**, so a page in another
 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`.
+
+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. */
+  "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`.
+
+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;
+  /** The words a color's name is spoken in, as JSON keyed by their English,
+such as `{"red": "rot", "vibrant": "kräftiges"}`.
+
+**A color is named the way React Aria names one**, as "vibrant red" or
+"dark grayish blue", and the keys are the ones `@react-stately/color`
+translates, so a table a page already has for it can be handed over whole.
+`colorName` and `transparentColorName` are the two sentences that put the
+words together. A word left out is spoken in English.
+
+The name follows the numbers on the square, follows the number on the hue
+ramp, and names each preset, so a reader who cannot see the color hears
+which one it is. */
+  "color-words"?: (HelixColorPicker["colorWords"]) | undefined;
+  /** The words a color's name is spoken in, as JSON keyed by their English,
+such as `{"red": "rot", "vibrant": "kräftiges"}`.
+
+**A color is named the way React Aria names one**, as "vibrant red" or
+"dark grayish blue", and the keys are the ones `@react-stately/color`
+translates, so a table a page already has for it can be handed over whole.
+`colorName` and `transparentColorName` are the two sentences that put the
+words together. A word left out is spoken in English.
+
+The name follows the numbers on the square, follows the number on the hue
+ramp, and names each preset, so a reader who cannot see the color hears
+which one it is. */
+  colorWords?: (HelixColorPicker["colorWords"]) | undefined;
   /** The text the sample shows for a moment after it copies the value. */
   "copied-label"?: (HelixColorPicker["copiedLabel"]) | undefined;
   /** The text the sample shows for a moment after it copies the value. */
@@ -3270,6 +3637,10 @@ Only what is written. Everything is read whatever this says, so a picker on
   "format-label"?: (HelixColorPicker["formatLabel"]) | undefined;
   /** What the syntax toggle is called, with `{format}` filled in. */
   formatLabel?: (HelixColorPicker["formatLabel"]) | undefined;
+  /** What the green channel's field is called, in `channel-fields`. */
+  "green-label"?: (HelixColorPicker["greenLabel"]) | undefined;
+  /** What the green channel's field is called, in `channel-fields`. */
+  greenLabel?: (HelixColorPicker["greenLabel"]) | undefined;
   /** What the hue channel is called. */
   "hue-label"?: (HelixColorPicker["hueLabel"]) | undefined;
   /** What the hue channel is called. */
@@ -3282,6 +3653,12 @@ the label, the hint and the feedback, and a second message inside the panel
 would be the same error said twice. What is left for the picker is the one
 thing the field cannot draw from outside, the mark on the answer itself. */
   invalid?: (HelixColorPicker["invalid"]) | undefined;
+  /** What the lightness channel's field is called, in `channel-fields` with
+hsl. */
+  "lightness-label"?: (HelixColorPicker["lightnessLabel"]) | undefined;
+  /** What the lightness channel's field is called, in `channel-fields` with
+hsl. */
+  lightnessLabel?: (HelixColorPicker["lightnessLabel"]) | undefined;
   /** Hides the eyedropper. Without it, the eyedropper appears in browsers that
 support one. */
   "no-eyedropper"?: (HelixColorPicker["noEyedropper"]) | undefined;
@@ -3378,6 +3755,10 @@ letting it move would show `rgb` over a hex it is no longer allowed to
 restate. The eyedropper clears the screen and runs a system sampler, so
 letting it open would take a color from the reader and drop it. */
   readOnly?: (HelixColorPicker["readOnly"]) | undefined;
+  /** What the red channel's field is called, in `channel-fields`. */
+  "red-label"?: (HelixColorPicker["redLabel"]) | undefined;
+  /** What the red channel's field is called, in `channel-fields`. */
+  redLabel?: (HelixColorPicker["redLabel"]) | undefined;
   /** Requires a color before the form can submit.
 
 **A color is exactly as requirable as a date**, which is the comparison
@@ -3564,6 +3945,24 @@ and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   valueMissingMessage?: (HelixCombobox["valueMissingMessage"]) | undefined;
+  /** Whether text that names no option is taken as the value, as React Aria's
+`allowsCustomValue`.
+
+For a field where the list is a help and not the whole of the answer, a
+city or a job title. What was typed becomes the value when the reader
+leaves the field or presses Enter with nothing highlighted, and text that
+names an option takes that option. Unlike `creatable`, no event asks
+first and no option is expected to be added: the value is the text. */
+  "allows-custom-value"?: (HelixCombobox["allowsCustomValue"]) | undefined;
+  /** Whether text that names no option is taken as the value, as React Aria's
+`allowsCustomValue`.
+
+For a field where the list is a help and not the whole of the answer, a
+city or a job title. What was typed becomes the value when the reader
+leaves the field or presses Enter with nothing highlighted, and text that
+names an option takes that option. Unlike `creatable`, no event asks
+first and no option is expected to be added: the value is the text. */
+  allowsCustomValue?: (HelixCombobox["allowsCustomValue"]) | undefined;
   /** What the browser may autofill in the text field, as a platform token.
 
 **Defaults to `off`, which is not the platform's default and is the
@@ -3642,6 +4041,20 @@ filled in.
 **The name goes in**, so a row of them is heard as which one each
 removes rather than as "Remove" said once per chosen option. */
   removeLabel?: (HelixCombobox["removeLabel"]) | undefined;
+  /** What a screen reader hears when typing leaves one option. `{count}` is
+the count. */
+  "result-label"?: (HelixCombobox["resultLabel"]) | undefined;
+  /** What a screen reader hears when typing leaves one option. `{count}` is
+the count. */
+  resultLabel?: (HelixCombobox["resultLabel"]) | undefined;
+  /** What a screen reader hears when typing leaves any other number of
+options. `{count}` is the count, and `Intl.PluralRules` picks between the
+two. */
+  "results-label"?: (HelixCombobox["resultsLabel"]) | undefined;
+  /** What a screen reader hears when typing leaves any other number of
+options. `{count}` is the count, and `Intl.PluralRules` picks between the
+two. */
+  resultsLabel?: (HelixCombobox["resultsLabel"]) | undefined;
   /** Whether the field completes the word as the user types.
 
 `suggest` rather than `autocomplete`, which is a real HTML attribute this
@@ -3743,6 +4156,14 @@ the resolved state for stylesheets, which is what the mirror is for. */
   "empty-text"?: (HelixCommand["emptyText"]) | undefined;
   /** The text shown when the filter matches no commands. */
   emptyText?: (HelixCommand["emptyText"]) | undefined;
+  /** How long typing rests before the commands are filtered, in milliseconds,
+so a palette filtered on a server sends one `helix-filter` for a word.
+`0` filters on every keystroke. See Listbox's `filter-delay`. */
+  "filter-delay"?: (HelixCommand["filterDelay"] | `${number}`) | undefined;
+  /** How long typing rests before the commands are filtered, in milliseconds,
+so a palette filtered on a server sends one `helix-filter` for a word.
+`0` filters on every keystroke. See Listbox's `filter-delay`. */
+  filterDelay?: (HelixCommand["filterDelay"]) | undefined;
   /** The key that opens the palette, written as `mod+k`, `shift+p`, or `k`.
 
 Empty turns it off, for a consumer who opens the palette from a button or
@@ -3762,6 +4183,20 @@ Passed to the list, which shows `loading-text` and tells screen readers. */
   loadingText?: (HelixCommand["loadingText"]) | 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. `{count}` is
+the count. */
+  "result-label"?: (HelixCommand["resultLabel"]) | undefined;
+  /** What a screen reader hears when typing leaves one command. `{count}` is
+the count. */
+  resultLabel?: (HelixCommand["resultLabel"]) | undefined;
+  /** What a screen reader hears when typing leaves any other number of
+commands. `{count}` is the count, and `Intl.PluralRules` picks between the
+two. */
+  "results-label"?: (HelixCommand["resultsLabel"]) | undefined;
+  /** What a screen reader hears when typing leaves any other number of
+commands. `{count}` is the count, and `Intl.PluralRules` picks between the
+two. */
+  resultsLabel?: (HelixCommand["resultsLabel"]) | undefined;
 };
 
 export type HelixCommandVueEvents = {
@@ -3773,7 +4208,7 @@ export type HelixCommandVueEvents = {
   "helix-before-open": HelixCommandHelixBeforeOpenElementEvent;
   /** Fired as the user types, with the text the list is filtered by. Cancelable: cancel it to leave the list unfiltered and filter the commands yourself, for example on a server while `loading` is set. */
   "helix-filter": HelixCommandHelixFilterElementEvent;
-  /** A command was chosen. Cancelable: cancel it to keep the palette open. */
+  /** A command was chosen, with its `href` where the option is a link. Cancelable: cancel it to keep the palette open, and to keep the browser from following the link. */
   "helix-select": HelixCommandHelixSelectElementEvent;
 };
 
@@ -3785,6 +4220,9 @@ export type HelixCopyButtonElementEvent<E = Event> = TypedEvent<
 /** `helix-copy` event type */
 export type HelixCopyButtonHelixCopyElementEvent =
   HelixCopyButtonElementEvent<HelixCopyEvent>;
+/** `helix-copy-error` event type */
+export type HelixCopyButtonHelixCopyErrorElementEvent =
+  HelixCopyButtonElementEvent<HelixCopyErrorEvent>;
 
 export type HelixCopyButtonVueProps = {
   /** How much fill the control is drawn with.
@@ -3820,6 +4258,17 @@ dash-casing it, and `copiedlabel` is not what anyone would type. */
 `attribute` written out, because Lit lowercases a property name rather than
 dash-casing it, and `copiedlabel` is not what anyone would type. */
   copiedLabel?: (HelixCopyButton["copiedLabel"]) | undefined;
+  /** The button's name and tooltip text after a press that put nothing on the
+clipboard. */
+  "error-label"?: (HelixCopyButton["errorLabel"]) | undefined;
+  /** The button's name and tooltip text after a press that put nothing on the
+clipboard. */
+  errorLabel?: (HelixCopyButton["errorLabel"]) | undefined;
+  /** The element to copy from, by its id: `key` for its text, `key[value]` for
+an attribute, and `key.value` for a property. Read at the press, and used
+in place of `value`. An element that is not there copies nothing, which is
+a failed copy. */
+  from?: (HelixCopyButton["from"]) | undefined;
   /** The button's name and tooltip text before a copy.
 
 Defaulted rather than left empty. An icon-only control must be named, and
@@ -3833,74 +4282,22 @@ whatever its `type`. Declared here so its own page says what it holds. */
   value?: (HelixCopyButton["value"]) | undefined;
   /**  */
   "aria-label"?: unknown;
-  /** What to send when the button is activated, and what to send it to.
-
-The platform's invoker attributes, forwarded onto the inner `<button>`
-rather than left on the host: only a real button is recognized as an
-invoker, so `commandfor` written on a custom element resolves nothing and
-the trigger silently does nothing at all. A wrapper has to hand them down,
-the same way `label` becomes `aria-label` in there.
-
-```html
-<helix-headless-button commandfor="confirm" command="--show">Delete…</helix-headless-button>
-```
-
-`commandFor` spells its attribute out, because Lit lowercases a property
-name to derive one rather than dash-casing it, and what a consumer writes
-is the platform's `commandfor`. */
-  command?: (HelixCopyButton["command"]) | undefined;
-  /** The id of the element the command is sent to. */
-  commandfor?: (HelixCopyButton["commandFor"]) | undefined;
-  /** The id of the element the command is sent to. */
-  commandFor?: (HelixCopyButton["commandFor"]) | undefined;
-  /** Where this button's submission goes, overriding the form's own.
-
-**The five `form*` overrides work by writing the form and putting it back**,
-which is the only mechanism available and is closer to the platform than it
-sounds. `requestSubmit(submitter)` is how a native submitter carries these,
-and it refuses ours twice over: the inner `<button>` is `type="button"` so
-it is not a submit button, and it sits in this shadow root so its form owner
-is not the consumer's form. Both throw. So the submission is started with no
-submitter and the overrides are applied to the form for the duration of it.
-
-The whole submit algorithm runs synchronously inside `requestSubmit()`, so
-the window is one call and a `finally` closes it whether or not a listener
-refused. What a `submit` handler observes during that window is the form a
-native submitter would have given it, which is the point. */
-  formaction?: (HelixCopyButton["formAction"]) | undefined;
-  /** Where this button's submission goes, overriding the form's own.
-
-**The five `form*` overrides work by writing the form and putting it back**,
-which is the only mechanism available and is closer to the platform than it
-sounds. `requestSubmit(submitter)` is how a native submitter carries these,
-and it refuses ours twice over: the inner `<button>` is `type="button"` so
-it is not a submit button, and it sits in this shadow root so its form owner
-is not the consumer's form. Both throw. So the submission is started with no
-submitter and the overrides are applied to the form for the duration of it.
-
-The whole submit algorithm runs synchronously inside `requestSubmit()`, so
-the window is one call and a `finally` closes it whether or not a listener
-refused. What a `submit` handler observes during that window is the form a
-native submitter would have given it, which is the point. */
-  formAction?: (HelixCopyButton["formAction"]) | undefined;
-  /** How the submission is encoded, overriding the form's own. */
-  formenctype?: (HelixCopyButton["formEnctype"]) | undefined;
-  /** How the submission is encoded, overriding the form's own. */
-  formEnctype?: (HelixCopyButton["formEnctype"]) | undefined;
-  /** Which HTTP method the submission uses, overriding the form's own. */
-  formmethod?: (HelixCopyButton["formMethod"]) | undefined;
-  /** Which HTTP method the submission uses, overriding the form's own. */
-  formMethod?: (HelixCopyButton["formMethod"]) | undefined;
-  /** Whether this submission skips the form's validation. */
-  formnovalidate?: (HelixCopyButton["formNoValidate"]) | undefined;
-  /** Whether this submission skips the form's validation. */
-  formNoValidate?: (HelixCopyButton["formNoValidate"]) | undefined;
-  /** Which browsing context the response lands in, overriding the form's own. */
-  formtarget?: (HelixCopyButton["formTarget"]) | undefined;
-  /** Which browsing context the response lands in, overriding the form's own. */
-  formTarget?: (HelixCopyButton["formTarget"]) | undefined;
-  /** What activating the button does to its form. */
-  type?: (HelixCopyButton["type"]) | undefined;
+  /** Whether the action the button started is still running.
+
+A pending button keeps focus and stays in the tab order, and refuses every
+press: a click, Enter and Space, and Enter in a field of its form. The
+click does not reach your listeners. The inner control carries
+`aria-busy` and `aria-disabled`, and when the button becomes pending while
+it has focus, a reader hears `pending-label`. The styled button draws a
+turning ring over its words.
+
+`disabled` takes the button out of reach. Use `pending` for the wait after
+a press, so focus stays where the reader left it. */
+  pending?: (HelixCopyButton["pending"]) | undefined;
+  /** What a reader hears when the button becomes pending while it has focus. */
+  "pending-label"?: (HelixCopyButton["pendingLabel"]) | undefined;
+  /** What a reader hears when the button becomes pending while it has focus. */
+  pendingLabel?: (HelixCopyButton["pendingLabel"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -3927,31 +4324,6 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixCopyButton["name"]) | undefined;
-  /** Whether this button is a disclosure trigger, and whether its panel is open.
-
-**Set by whatever owns the panel, and a property rather than an attribute
-for the reason `Menu` already states about its items**: an attribute
-written onto a consumer's element after it upgrades is a hydration mismatch
-waiting to happen. Measured 28 Aug 2026 against React 19.2.8, server markup
-hydrated with the definitions loaded either side of `hydrateRoot`:
-`Megamenu` and `SpeedDial` wrote `aria-expanded` onto the slotted trigger
-and React reported "some attributes of the server rendered HTML didn't
-match the client properties. This won't be patched up" in both orders;
-`Popover` and `Menu`, which write nothing, were clean in both.
-
-**A property crosses that gap because React never looks at one.** It diffs
-the attributes it rendered, and this one is `attribute: false`, so the state
-travels to the inner `<button>` and lands inside a shadow root React does
-not own and cannot compare. The consumer's own element is left exactly as
-they served it and the reader is still told what the control does.
-
-`undefined` renders nothing at all, so a button that is not a trigger
-carries no `aria-expanded`: the resting state is the attribute's absence,
-which is the rule every reflected property here follows.
-
-A consumer who wants to say this statically writes `aria-expanded` on the
-host instead, which `AriaForwardController` carries to the same place. */
-  expanded?: (HelixCopyButton["expanded"]) | undefined;
   /** Whether the button holds its group's tab stop.
 
 A toolbar keeps one tab stop across its children, and the obvious way to do
@@ -3963,14 +4335,6 @@ and the stop lands on the inner control inside the shadow root.
 No attribute, because it is coordination between elements rather than
 anything a consumer sets. */
   focusable?: (HelixCopyButton["focusable"]) | undefined;
-  /** What kind of panel this button opens, where it opens one: `menu` for a
-`Menu`.
-
-Set by the component that owns the panel, as a property for the reason
-`expanded` gives above. It is what makes a reader say the button opens a
-menu. Read from Chromium's tree, a Menu's trigger was a plain button that
-reported collapsed and expanded and no popup. */
-  popup?: (HelixCopyButton["popup"]) | undefined;
   /** The element this button's command is sent to, resolved.
 
 The platform's own accessor, because the resolution is otherwise kept
@@ -3984,6 +4348,8 @@ invoker without an id in the same tree needs. */
 export type HelixCopyButtonVueEvents = {
   /** Fired after the clipboard write succeeds. */
   "helix-copy": HelixCopyButtonHelixCopyElementEvent;
+  /** Fired when a press put nothing on the clipboard: the browser did not allow the write, or there was nothing to copy. */
+  "helix-copy-error": HelixCopyButtonHelixCopyErrorElementEvent;
 };
 
 /** `HelixDataTable` component event */
@@ -3994,12 +4360,18 @@ export type HelixDataTableElementEvent<E = Event> = TypedEvent<
 /** `helix-activate` event type */
 export type HelixDataTableHelixActivateElementEvent =
   HelixDataTableElementEvent<HelixActivateEvent>;
+/** `helix-expand` event type */
+export type HelixDataTableHelixExpandElementEvent =
+  HelixDataTableElementEvent<HelixExpandEvent>;
 /** `helix-filter` event type */
 export type HelixDataTableHelixFilterElementEvent =
   HelixDataTableElementEvent<HelixFilterEvent>;
 /** `helix-filtered` event type */
 export type HelixDataTableHelixFilteredElementEvent =
   HelixDataTableElementEvent<HelixFilteredEvent>;
+/** `helix-load-more` event type */
+export type HelixDataTableHelixLoadMoreElementEvent =
+  HelixDataTableElementEvent<HelixLoadMoreEvent>;
 /** `helix-navigate` event type */
 export type HelixDataTableHelixNavigateElementEvent =
   HelixDataTableElementEvent<HelixNavigateEvent>;
@@ -4041,6 +4413,24 @@ say that without the component knowing what a row looks like. */
   "ascending-label"?: (HelixDataTable["ascendingLabel"]) | undefined;
   /** The word for an ascending sort, in `sorted-label`. */
   ascendingLabel?: (HelixDataTable["ascendingLabel"]) | undefined;
+  /** The field that holds a row's child rows, as an array. Set it, and `row-key`,
+and the grid becomes a tree grid.
+
+Reflected, because the styled tier indents a tree grid's row headers by
+it. No default, so a table that sets none writes nothing onto its host. */
+  "child-field"?: (HelixDataTable["childField"]) | undefined;
+  /** The field that holds a row's child rows, as an array. Set it, and `row-key`,
+and the grid becomes a tree grid.
+
+Reflected, because the styled tier indents a tree grid's row headers by
+it. No default, so a table that sets none writes nothing onto its host. */
+  childField?: (HelixDataTable["childField"]) | undefined;
+  /** The keys of the rows open at the start, separated by commas. Used until
+`expanded` is set. */
+  "default-expanded"?: (HelixDataTable["defaultExpanded"]) | undefined;
+  /** The keys of the rows open at the start, separated by commas. Used until
+`expanded` is set. */
+  defaultExpanded?: (HelixDataTable["defaultExpanded"]) | undefined;
   /** The starting search query, used until `filter` is set. */
   "default-filter"?: (HelixDataTable["defaultFilter"]) | undefined;
   /** The starting search query, used until `filter` is set. */
@@ -4079,6 +4469,9 @@ replaces this with what each row came to as it draws. It still has to be
 close, because it is what the scrollbar is built from before anything has
 been measured. */
   estimate?: (HelixDataTable["estimate"]) | undefined;
+  /** The keys of the open rows in a tree grid, separated by commas, the shape of
+`selected`. A reader's press writes it and then sends `helix-expand`. */
+  expanded?: (HelixDataTable["expanded"]) | undefined;
   /** The search query. A row is shown when the query matches any of its columns.
 
 One query rather than a predicate per column, which is what a reader means
@@ -4093,6 +4486,22 @@ replaced with the page it jumps to. */
   gapLabel?: (HelixDataTable["gapLabel"]) | undefined;
   /** The grid's name, read by screen readers. */
   label?: (HelixDataTable["label"]) | undefined;
+  /** Draws a row after the last one with a button that asks for more rows.
+
+The button sends `helix-load-more`, and a `windowed` table sends it by
+itself once a reader scrolls within one screen of the end. Turn it off
+when there are no more rows to load. */
+  "load-more"?: (HelixDataTable["loadMore"]) | undefined;
+  /** Draws a row after the last one with a button that asks for more rows.
+
+The button sends `helix-load-more`, and a `windowed` table sends it by
+itself once a reader scrolls within one screen of the end. Turn it off
+when there are no more rows to load. */
+  loadMore?: (HelixDataTable["loadMore"]) | undefined;
+  /** The words on the button in the `more` row. */
+  "load-more-label"?: (HelixDataTable["loadMoreLabel"]) | undefined;
+  /** The words on the button in the `more` row. */
+  loadMoreLabel?: (HelixDataTable["loadMoreLabel"]) | undefined;
   /** Where filtering, sorting, and paging happen. `client` does them in the
 table, and `server` leaves them to your code.
 
@@ -4286,10 +4695,14 @@ holds and reordering it under them is a mutation they did not ask for. */
 export type HelixDataTableVueEvents = {
   /** Fired after the page changes, with the new page as a string in `detail.value`. */
   "helix-activate": HelixDataTableHelixActivateElementEvent;
+  /** Fired after a row opens or closes, with every open row's key, separated by commas, which `expanded` also holds. */
+  "helix-expand": HelixDataTableHelixExpandElementEvent;
   /** The search query is about to change. Cancelable: cancel it to keep the current query. */
   "helix-filter": HelixDataTableHelixFilterElementEvent;
   /** Fired after the search query changes, with the new query. */
   "helix-filtered": HelixDataTableHelixFilteredElementEvent;
+  /** Fired when a reader asks for more rows, by the `load-more` row's button or by scrolling a `windowed` table near its end. */
+  "helix-load-more": HelixDataTableHelixLoadMoreElementEvent;
   /** Another page was requested. Cancelable: cancel it to stay on the current page. */
   "helix-navigate": HelixDataTableHelixNavigateElementEvent;
   /** The columns are about to move. The event carries every field in the new order. Cancelable: cancel it to keep the current order. */
@@ -4325,6 +4738,20 @@ export type HelixDateInputHelixBeforeOpenElementEvent =
   HelixDateInputElementEvent<HelixBeforeOpenEvent>;
 
 export type HelixDateInputVueProps = {
+  /** What a screen reader hears for a segment with nothing in it, which a
+sighted reader sees as dashes. */
+  "empty-segment-label"?: (HelixDateInput["emptySegmentLabel"]) | undefined;
+  /** What a screen reader hears for a segment with nothing in it, which a
+sighted reader sees as dashes. */
+  emptySegmentLabel?: (HelixDateInput["emptySegmentLabel"]) | undefined;
+  /** Whether the field is a row of segments, one for each part of the date or
+time, in place of a line of text.
+
+Each segment is set with digits or the arrow keys, in the order the
+locale writes them, so a reader types a date the way they write one and
+no format has to be read back. The picker still opens from the trigger
+and with Alt+Down. */
+  segmented?: (HelixDateInput["segmented"]) | undefined;
   /** Whether the value is locked. A read-only control still submits its value.
 
 **Enforced by refusing every request in one place**, which is the seam this
@@ -4523,6 +4950,12 @@ and is Sunday otherwise. */
   locale?: (HelixDateInput["locale"]) | undefined;
   /** The latest date that can be chosen, as `YYYY-MM-DD`. */
   max?: (HelixDateInput["max"]) | undefined;
+  /** How far the calendar's heading steps back from the days: `month` or
+`year`. Handed to the calendar; see Date Picker's `max-view`. */
+  "max-view"?: (HelixDateInput["maxView"]) | undefined;
+  /** How far the calendar's heading steps back from the days: `month` or
+`year`. Handed to the calendar; see Date Picker's `max-view`. */
+  maxView?: (HelixDateInput["maxView"]) | undefined;
   /** The earliest date that can be chosen, as `YYYY-MM-DD`. */
   min?: (HelixDateInput["min"]) | undefined;
   /** How many dates can be held at once.
@@ -4538,16 +4971,38 @@ an end in April otherwise means paging between them and losing sight of the
 first. The panel is sized by its content, so this widens it, and where the
 window has no room for that width it shows one month until there is. */
   months?: (HelixDateInput["months"]) | undefined;
+  /** The name of the calendar's heading where it shows the months, with
+`{heading}` filled in. */
+  "month-view-label"?: (HelixDateInput["monthViewLabel"]) | undefined;
+  /** The name of the calendar's heading where it shows the months, with
+`{heading}` filled in. */
+  monthViewLabel?: (HelixDateInput["monthViewLabel"]) | undefined;
   /** The name of the calendar's control that moves to the next month. */
   "next-label"?: (HelixDateInput["nextLabel"]) | undefined;
   /** The name of the calendar's control that moves to the next month. */
   nextLabel?: (HelixDateInput["nextLabel"]) | undefined;
+  /** The name of the calendar's control that moves forward a year. */
+  "next-year-label"?: (HelixDateInput["nextYearLabel"]) | undefined;
+  /** The name of the calendar's control that moves forward a year. */
+  nextYearLabel?: (HelixDateInput["nextYearLabel"]) | undefined;
+  /** The name of the calendar's control that moves forward a page of years. */
+  "next-years-label"?: (HelixDateInput["nextYearsLabel"]) | undefined;
+  /** The name of the calendar's control that moves forward a page of years. */
+  nextYearsLabel?: (HelixDateInput["nextYearsLabel"]) | undefined;
   /** The text the field shows before a date is entered. */
   placeholder?: (HelixDateInput["placeholder"]) | undefined;
   /** The name of the calendar's control that moves to the previous month. */
   "previous-label"?: (HelixDateInput["previousLabel"]) | undefined;
   /** The name of the calendar's control that moves to the previous month. */
   previousLabel?: (HelixDateInput["previousLabel"]) | undefined;
+  /** The name of the calendar's control that moves back a year. */
+  "previous-year-label"?: (HelixDateInput["previousYearLabel"]) | undefined;
+  /** The name of the calendar's control that moves back a year. */
+  previousYearLabel?: (HelixDateInput["previousYearLabel"]) | undefined;
+  /** The name of the calendar's control that moves back a page of years. */
+  "previous-years-label"?: (HelixDateInput["previousYearsLabel"]) | undefined;
+  /** The name of the calendar's control that moves back a page of years. */
+  previousYearsLabel?: (HelixDateInput["previousYearsLabel"]) | undefined;
   /** The message shown when a range holds more than two dates.
 
 **Every sentence a control raises in the browser's bubble is a property**,
@@ -4603,6 +5058,12 @@ platform's base. */
   "unavailable-message"?: (HelixDateInput["unavailableMessage"]) | undefined;
   /** The message shown when `disable-dates` or `disable-days` bars a date. */
   unavailableMessage?: (HelixDateInput["unavailableMessage"]) | undefined;
+  /** The name of the calendar's heading where it shows a page of years, with
+`{heading}` filled in. */
+  "year-view-label"?: (HelixDateInput["yearViewLabel"]) | undefined;
+  /** The name of the calendar's heading where it shows a page of years, with
+`{heading}` filled in. */
+  yearViewLabel?: (HelixDateInput["yearViewLabel"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -4629,6 +5090,14 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixDateInput["name"]) | undefined;
+  /** What each day in the calendar shows, in place of its number: a function
+given the date as `YYYY-MM-DD`. Handed to the calendar; see Date Picker's
+`dayContent`. */
+  dayContent?: (HelixDateInput["dayContent"]) | undefined;
+  /** A rule for which dates cannot be chosen: a function given the date as
+`YYYY-MM-DD` that returns `true` to bar it. The calendar offers such a date
+as unavailable, and a typed one is invalid, as with `disable-dates`. */
+  isDateUnavailable?: (HelixDateInput["isDateUnavailable"]) | undefined;
   /** The value as a `Date`, at midnight UTC, or `null` while there is no date.
 
 The platform's own pair on `<input type="date">`, and this control holds the
@@ -4732,6 +5201,24 @@ Absent uses the runtime's own. */
   locale?: (HelixDatePicker["locale"]) | undefined;
   /** Latest selectable date, as `YYYY-MM-DD`. */
   max?: (HelixDatePicker["max"]) | undefined;
+  /** How far the heading lets a reader step back from the days: `month` to a
+year's months, or `year` to a page of years and then its months.
+
+Absent, the heading is text and the calendar moves a month at a time. Set,
+the heading is a button that shows the months, and from there the years,
+so a birth date forty years back is three presses rather than four hundred
+and eighty. Choosing a year shows its months, and choosing a month shows
+its days. */
+  "max-view"?: (HelixDatePicker["maxView"]) | undefined;
+  /** How far the heading lets a reader step back from the days: `month` to a
+year's months, or `year` to a page of years and then its months.
+
+Absent, the heading is text and the calendar moves a month at a time. Set,
+the heading is a button that shows the months, and from there the years,
+so a birth date forty years back is three presses rather than four hundred
+and eighty. Choosing a year shows its months, and choosing a month shows
+its days. */
+  maxView?: (HelixDatePicker["maxView"]) | undefined;
   /** Earliest selectable date, as `YYYY-MM-DD`. */
   min?: (HelixDatePicker["min"]) | undefined;
   /** How many dates can be held at once. */
@@ -4745,10 +5232,24 @@ can drive the view. Reading gives the month on show; writing sets it, and
   month?: (HelixDatePicker["month"]) | undefined;
   /** How many months to show, side by side. */
   months?: (HelixDatePicker["months"]) | undefined;
+  /** The name of the heading where it shows the months, with `{heading}`
+filled in as the month on show. */
+  "month-view-label"?: (HelixDatePicker["monthViewLabel"]) | undefined;
+  /** The name of the heading where it shows the months, with `{heading}`
+filled in as the month on show. */
+  monthViewLabel?: (HelixDatePicker["monthViewLabel"]) | undefined;
   /** Accessible name for the control that pages forward. */
   "next-label"?: (HelixDatePicker["nextLabel"]) | undefined;
   /** Accessible name for the control that pages forward. */
   nextLabel?: (HelixDatePicker["nextLabel"]) | undefined;
+  /** Accessible name for the control that moves forward a year, in the months. */
+  "next-year-label"?: (HelixDatePicker["nextYearLabel"]) | undefined;
+  /** Accessible name for the control that moves forward a year, in the months. */
+  nextYearLabel?: (HelixDatePicker["nextYearLabel"]) | undefined;
+  /** Accessible name for the control that moves forward a page, in the years. */
+  "next-years-label"?: (HelixDatePicker["nextYearsLabel"]) | undefined;
+  /** Accessible name for the control that moves forward a page, in the years. */
+  nextYearsLabel?: (HelixDatePicker["nextYearsLabel"]) | undefined;
   /** Accessible name for the control that pages back.
 
 A property because a calendar rendering its own month names from `locale`
@@ -4763,6 +5264,14 @@ would otherwise still announce its controls in English. `attribute:`
 spelled out, since Lit lowercases a camelCase name rather than dash-casing
 it. */
   previousLabel?: (HelixDatePicker["previousLabel"]) | undefined;
+  /** Accessible name for the control that moves back a year, in the months. */
+  "previous-year-label"?: (HelixDatePicker["previousYearLabel"]) | undefined;
+  /** Accessible name for the control that moves back a year, in the months. */
+  previousYearLabel?: (HelixDatePicker["previousYearLabel"]) | undefined;
+  /** Accessible name for the control that moves back a page, in the years. */
+  "previous-years-label"?: (HelixDatePicker["previousYearsLabel"]) | undefined;
+  /** Accessible name for the control that moves back a page, in the years. */
+  previousYearsLabel?: (HelixDatePicker["previousYearsLabel"]) | undefined;
   /** The validation message for a date after `max`. `{max}` is replaced with
 `max`, written as a date in `locale`. */
   "range-overflow-message"?: (HelixDatePicker["rangeOverflowMessage"]) | undefined;
@@ -4827,6 +5336,17 @@ bars. */
   "value-missing-message"?: (HelixDatePicker["valueMissingMessage"]) | undefined;
   /** The validation message for a required date picker with no date chosen. */
   valueMissingMessage?: (HelixDatePicker["valueMissingMessage"]) | undefined;
+  /** What the calendar shows: the days of a month, the months of a year, or a
+page of years. `day` unless `max-view` lets a reader step back.
+
+Not reflected, being state. Set it to open on the months or the years. */
+  view?: (HelixDatePicker["view"]) | undefined;
+  /** The name of the heading where it shows a page of years, with `{heading}`
+filled in as the year on show. */
+  "year-view-label"?: (HelixDatePicker["yearViewLabel"]) | undefined;
+  /** The name of the heading where it shows a page of years, with `{heading}`
+filled in as the year on show. */
+  yearViewLabel?: (HelixDatePicker["yearViewLabel"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -4853,6 +5373,24 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixDatePicker["name"]) | undefined;
+  /** What each day shows, in place of its number: a function given the date as
+`YYYY-MM-DD` that returns text, an element or a Lit template.
+
+For a price or a dot under the number, as React Aria's `CalendarCell`
+takes children. The cell is still named by its whole date, so what you
+draw here is for the eye; say anything a reader must hear in the date's
+description elsewhere. Return the day's number with it where it should
+still show. A property only, there being no way to write a function in
+markup. */
+  dayContent?: (HelixDatePicker["dayContent"]) | undefined;
+  /** A rule for which dates cannot be chosen: a function given the date as
+`YYYY-MM-DD` that returns `true` to bar it.
+
+For what a list cannot say, such as the second Tuesday of each month or
+the days a server has fully booked. It bars a date as `disable-dates`
+does, in the grid and in validation. A property only, as React Aria's
+`isDateUnavailable` is a prop. */
+  isDateUnavailable?: (HelixDatePicker["isDateUnavailable"]) | undefined;
   /** The value as a `Date`, at midnight UTC, or `null` while there is no date.
 
 The platform's own pair on `<input type="date">`, and this control holds the
@@ -4930,6 +5468,9 @@ labels line up, and lining up is a fact about all of them.
 a reflecting default writes an attribute onto markup the consumer rendered,
 and React reports that as a hydration mismatch. */
   direction?: (HelixDescriptionList["direction"]) | undefined;
+  /** The list's name, read by screen readers, such as "Server details". It
+makes the list a named group. */
+  label?: (HelixDescriptionList["label"]) | undefined;
 };
 
 export type HelixDescriptionListVueEvents = {};
@@ -5022,6 +5563,16 @@ hydration, or diffed by a framework, it comes back holding whatever the
 last reader did rather than what the author wrote. `:state(open)` carries
 the resolved state for stylesheets, which is what the mirror is for. */
   open?: (HelixDialog["open"]) | undefined;
+  /** Makes the dialog an alert dialog, for a message that interrupts to ask for
+an answer, such as a confirmation before something is deleted.
+
+The `<dialog>` takes `role="alertdialog"`, so a screen reader announces the
+dialog and its description as it opens. Everything else stays the same:
+the dialog is modal, Escape asks to close it, and `persistent` still
+refuses that.
+
+Not reflected, because no stylesheet selects on it. */
+  alert?: (HelixDialog["alert"]) | undefined;
   /** Which close requests the browser handles on its own.
 
 `<dialog closedby>`, forwarded, and safe to forward because every path it
@@ -5044,6 +5595,17 @@ the property this component exists to keep.
 Absent by default, which is the platform's `auto` and this library's rule
 that a resting value is an attribute's absence. */
   closedBy?: (HelixDialog["closedBy"]) | undefined;
+  /** Draws a control that closes the dialog, in the corner where the title is.
+
+Pressing it is `close()`, so it sends `helix-before-close` like every other
+way out, and `persistent` does not disable it. */
+  dismissible?: (HelixDialog["dismissible"]) | undefined;
+  /** The close control's accessible name. Translate it with the rest of your
+interface. */
+  "dismiss-label"?: (HelixDialog["dismissLabel"]) | undefined;
+  /** The close control's accessible name. Translate it with the rest of your
+interface. */
+  dismissLabel?: (HelixDialog["dismissLabel"]) | undefined;
   /** Accessible name for the dialog. When it is empty, the heading in the
 `header` slot names the dialog. */
   label?: (HelixDialog["label"]) | undefined;
@@ -5082,6 +5644,18 @@ export type HelixDialogVueEvents = {
 };
 
 export type HelixDividerVueProps = {
+  /** Where content set into the line sits along it.
+
+Absent is the middle. `start` and `end` move it toward one end, with a
+short length of line, `--divider-content-offset`, kept before or after it.
+A divider with nothing set into it is one line whatever this says. */
+  "content-placement"?: (HelixDivider["contentPlacement"]) | undefined;
+  /** Where content set into the line sits along it.
+
+Absent is the middle. `start` and `end` move it toward one end, with a
+short length of line, `--divider-content-offset`, kept before or after it.
+A divider with nothing set into it is one line whatever this says. */
+  contentPlacement?: (HelixDivider["contentPlacement"]) | undefined;
   /** Whether screen readers announce the line as a separator.
 
 Off by default, and out of the accessibility tree. Most rules on a page
@@ -5305,6 +5879,24 @@ default assigned to the property would reflect onto every host and put a
 `placement="end"` into markup no consumer wrote. So what this tier
 guarantees is the absence, and a sheet selects on it. */
   placement?: (HelixDrawer["placement"]) | undefined;
+  /** The fractions of the panel a reader can leave on screen, as a list such as
+`0.5 1`. The drawer opens at the smallest, and a swipe comes to rest at the
+nearest, or closes the drawer below the smallest.
+
+Empty is `1`: the whole panel, and a swipe either closes it or puts it
+back. */
+  "snap-points"?: (HelixDrawer["snapPoints"]) | undefined;
+  /** The fractions of the panel a reader can leave on screen, as a list such as
+`0.5 1`. The drawer opens at the smallest, and a swipe comes to rest at the
+nearest, or closes the drawer below the smallest.
+
+Empty is `1`: the whole panel, and a swipe either closes it or puts it
+back. */
+  snapPoints?: (HelixDrawer["snapPoints"]) | undefined;
+  /** Whether a touch or a pen can swipe the drawer away. `swipe="false"` turns
+it off, for a panel whose content has its own use for the gesture, such as
+a map. */
+  swipe?: (HelixDrawer["swipe"]) | undefined;
   /** What the dialog closed with, the way `<dialog>` reports it.
 
 **The whole point of a `<dialog>` returning a value is lost behind a shadow
@@ -5359,14 +5951,6 @@ elements, and writing `tabindex` onto a host the consumer rendered is a
 change a React consumer's hydration reports and does not patch up. The stop
 lands inside this shadow root instead. */
   focusable?: (HelixDrilldownItem["focusable"]) | undefined;
-  /** Whether the page showing is the one this row is on.
-
-Written by the stack. */
-  onPage?: (HelixDrilldownItem["onPage"]) | undefined;
-  /** Whether this row's own page is the one showing.
-
-Written by the stack. */
-  showingPage?: (HelixDrilldownItem["showingPage"]) | undefined;
 };
 
 export type HelixDrilldownItemVueEvents = {
@@ -5440,6 +6024,9 @@ export type HelixFileInputElementEvent<E = Event> = TypedEvent<
 /** `helix-before-change` event type */
 export type HelixFileInputHelixBeforeChangeElementEvent =
   HelixFileInputElementEvent<HelixBeforeChangeEvent>;
+/** `helix-reject` event type */
+export type HelixFileInputHelixRejectElementEvent =
+  HelixFileInputElementEvent<HelixRejectEvent>;
 
 export type HelixFileInputVueProps = {
   /**  */
@@ -5479,12 +6066,31 @@ filter is the only check the platform makes and a drop never meets it. */
   accept?: (HelixFileInput["accept"]) | undefined;
   /** Which camera or microphone a mobile picker should offer, if any. */
   capture?: (HelixFileInput["capture"]) | undefined;
+  /** Whether the picker chooses a folder, and the field takes every file in
+it. The platform's `webkitdirectory`. */
+  directory?: (HelixFileInput["directory"]) | undefined;
   /** Language tag the sizes are written in.
 
 Absent uses the runtime's own. */
   locale?: (HelixFileInput["locale"]) | undefined;
+  /** The most files the field holds, under `multiple`. Files past it are
+refused. */
+  "max-files"?: (HelixFileInput["maxFiles"] | `${number}`) | undefined;
+  /** The most files the field holds, under `multiple`. Files past it are
+refused. */
+  maxFiles?: (HelixFileInput["maxFiles"]) | undefined;
+  /** The most bytes one file may have. A larger one is refused. */
+  "max-file-size"?: (HelixFileInput["maxFileSize"] | `${number}`) | undefined;
+  /** The most bytes one file may have. A larger one is refused. */
+  maxFileSize?: (HelixFileInput["maxFileSize"]) | undefined;
   /** Whether more than one file can be chosen. */
   multiple?: (HelixFileInput["multiple"]) | undefined;
+  /** What a reader hears when files are refused, with `{count}` and `{names}`
+filled in. */
+  "rejected-text"?: (HelixFileInput["rejectedText"]) | undefined;
+  /** What a reader hears when files are refused, with `{count}` and `{names}`
+filled in. */
+  rejectedText?: (HelixFileInput["rejectedText"]) | undefined;
   /** The accessible name of the control that removes a file. `{name}` is
 replaced with the file's name.
 
@@ -5529,6 +6135,9 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixFileInput["name"]) | undefined;
+  /** Your own check on each arriving file, which returns why it is refused, or
+nothing to take it. A property, since a function cannot be an attribute. */
+  validate?: (HelixFileInput["validate"]) | undefined;
 };
 
 export type HelixFileInputVueEvents = {
@@ -5536,6 +6145,8 @@ export type HelixFileInputVueEvents = {
   change: HelixFileInputElementEvent;
   /** Fired before the chosen files change, with their names, and cancelable. Canceling it keeps the files the field had, even when the browser has already written a new pick. */
   "helix-before-change": HelixFileInputHelixBeforeChangeElementEvent;
+  /** Fired when files arrive and some are left out. `detail.files` lists each with its `reason`: `type`, `size`, `count` or `invalid`, and your `validate` message. */
+  "helix-reject": HelixFileInputHelixRejectElementEvent;
   /** Fired after the value changes. */
   input: HelixFileInputElementEvent;
 };
@@ -5823,10 +6434,26 @@ an icon. */
   /** The name of the clear button, read by screen readers. The button shows only
 an icon. */
   clearLabel?: (HelixFilterInput["clearLabel"]) | undefined;
+  /** Whether the panel narrows itself to the suggestions that hold the term
+being typed, as React Aria's Autocomplete filters. Off, the panel shows
+what you slot and you narrow it. */
+  "filter-suggestions"?: (HelixFilterInput["filterSuggestions"]) | undefined;
+  /** Whether the panel narrows itself to the suggestions that hold the term
+being typed, as React Aria's Autocomplete filters. Off, the panel shows
+what you slot and you narrow it. */
+  filterSuggestions?: (HelixFilterInput["filterSuggestions"]) | undefined;
   /** The text shown while the field is empty.
 
 Not a label: it goes when typing starts. */
   placeholder?: (HelixFilterInput["placeholder"]) | undefined;
+  /** What a reader hears for one suggestion, with `{count}` filled in. */
+  "suggestion-label"?: (HelixFilterInput["suggestionLabel"]) | undefined;
+  /** What a reader hears for one suggestion, with `{count}` filled in. */
+  suggestionLabel?: (HelixFilterInput["suggestionLabel"]) | undefined;
+  /** What a reader hears for any other number of suggestions, with `{count}` filled in. */
+  "suggestions-label"?: (HelixFilterInput["suggestionsLabel"]) | undefined;
+  /** What a reader hears for any other number of suggestions, with `{count}` filled in. */
+  suggestionsLabel?: (HelixFilterInput["suggestionsLabel"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -5877,6 +6504,18 @@ export type HelixFilterInputVueEvents = {
 };
 
 export type HelixFlexVueProps = {
+  /** How the lines of a wrapping row share the space across it, set as
+`align-content`.
+
+Named for the CSS property it sets, the way `alignItems` is. It moves
+nothing in a row that does not wrap, which has one line. */
+  "align-content"?: (HelixFlex["alignContent"]) | undefined;
+  /** How the lines of a wrapping row share the space across it, set as
+`align-content`.
+
+Named for the CSS property it sets, the way `alignItems` is. It moves
+nothing in a row that does not wrap, which has one line. */
+  alignContent?: (HelixFlex["alignContent"]) | undefined;
   /** How items align across the direction, set as `align-items`.
 
 **Named for the CSS property it sets, because it is that property.** A flex
@@ -5911,7 +6550,17 @@ inside every field in it, through a hint no rule here declares and none can
 see, and the fix is a name the platform has no opinion about rather than a
 guard against the hint. */
   alignItems?: (HelixFlex["alignItems"]) | undefined;
-  /** Whether items run across or down. */
+  /** Space between the items of a row, named on the space scale. Wins over
+`gap` across the row. */
+  "column-gap"?: (HelixFlex["columnGap"]) | undefined;
+  /** Space between the items of a row, named on the space scale. Wins over
+`gap` across the row. */
+  columnGap?: (HelixFlex["columnGap"]) | undefined;
+  /** Whether items run across or down, and from which end.
+
+`row-reverse` and `column-reverse` change only where the items are drawn.
+Focus and a screen reader still follow the order of the markup, so use
+them for a visual order that reads the same either way. */
   direction?: (HelixFlex["direction"]) | undefined;
   /** Space between items, named on the space scale. */
   gap?: (HelixFlex["gap"]) | undefined;
@@ -5929,7 +6578,20 @@ Named for the property it sets, the way `alignItems` is. `between` and
 `around` drop the `space-` prefix and nothing else does, because those two
 are the only values whose CSS spelling is two words. */
   justifyContent?: (HelixFlex["justifyContent"]) | undefined;
-  /** Whether items wrap onto more lines. */
+  /** A common layout pattern: `cluster`, `split`, `flank` or `flank-end`.
+
+Each sets the wrapping, alignment and spread it needs, and an attribute
+you write as well wins over it. `flank` holds the first item at its own
+width and gives the last one the rest, and `flank-end` does the reverse. */
+  layout?: (HelixFlex["layout"]) | undefined;
+  /** Space between the lines of a wrapping row, or between the items of a
+column, named on the space scale. Wins over `gap` down the column. */
+  "row-gap"?: (HelixFlex["rowGap"]) | undefined;
+  /** Space between the lines of a wrapping row, or between the items of a
+column, named on the space scale. Wins over `gap` down the column. */
+  rowGap?: (HelixFlex["rowGap"]) | undefined;
+  /** Whether items wrap onto more lines. `wrap="reverse"` wraps them upward,
+each new line above the one before. */
   wrap?: (HelixFlex["wrap"]) | undefined;
 };
 
@@ -5952,6 +6614,12 @@ Lit's server shim, `textContent`, `children`, `firstChild` and
 it. An element rendered on a server needs the attribute; one rendered in a
 browser may use either. */
   date?: (HelixFormatDate["date"]) | undefined;
+  /** The locale's own pattern for the date: `full`, `long`, `medium`, or
+`short`. Set, it stands in for `weekday`, `day`, `month`, `year` and `era`. */
+  "date-style"?: (HelixFormatDate["dateStyle"]) | undefined;
+  /** The locale's own pattern for the date: `full`, `long`, `medium`, or
+`short`. Set, it stands in for `weekday`, `day`, `month`, `year` and `era`. */
+  dateStyle?: (HelixFormatDate["dateStyle"]) | undefined;
   /** How the day of the month is written, where a date is shown. */
   day?: (HelixFormatDate["day"]) | undefined;
   /** Shows how long ago the timestamp was, in a compact form such as "3h", in
@@ -5961,8 +6629,22 @@ Reflected, because it is the one property that decides which of two readings
 this is and a stylesheet has a reason to know: a compact reading is a fixed
 few characters and a date is not. */
   elapsed?: (HelixFormatDate["elapsed"]) | undefined;
+  /** How the era is written, such as AD, where a date is shown. */
+  era?: (HelixFormatDate["era"]) | undefined;
   /** How the hour is written, where a time of day is shown. */
   hour?: (HelixFormatDate["hour"]) | undefined;
+  /** The clock a time of day is written on: `h12` or `h11` for twelve hours,
+`h23` or `h24` for twenty-four.
+
+Absent is the locale's own, which is right unless your product shows every
+reader the same clock whatever their language. */
+  "hour-cycle"?: (HelixFormatDate["hourCycle"]) | undefined;
+  /** The clock a time of day is written on: `h12` or `h11` for twelve hours,
+`h23` or `h24` for twenty-four.
+
+Absent is the locale's own, which is right unless your product shows every
+reader the same clock whatever their language. */
+  hourCycle?: (HelixFormatDate["hourCycle"]) | undefined;
   /** The locale to format the timestamp in.
 
 Empty is the runtime's own. */
@@ -5971,8 +6653,26 @@ Empty is the runtime's own. */
   minute?: (HelixFormatDate["minute"]) | undefined;
   /** How the month is written, where a date is shown. */
   month?: (HelixFormatDate["month"]) | undefined;
+  /** Whether a `relative` reading may use a word for a number: `auto` says
+"yesterday" and "now", and `always` says "1 day ago" and "in 0 seconds". */
+  numeric?: (HelixFormatDate["numeric"]) | undefined;
+  /** Shows how long ago the timestamp was, or how long until it, in words, in
+place of the date: `long` ("3 hours ago"), `short` ("3 hr. ago") or
+`narrow` ("3h ago").
+
+The reading refreshes as it goes stale, as `elapsed` does, and the whole
+date is its title. `elapsed` wins where both are set. */
+  relative?: (HelixFormatDate["relative"]) | undefined;
   /** How the second is written, where a time of day is shown. */
   second?: (HelixFormatDate["second"]) | undefined;
+  /** The locale's own pattern for the time of day: `full`, `long`, `medium`, or
+`short`. Set, it stands in for `hour`, `minute`, `second` and
+`time-zone-name`. */
+  "time-style"?: (HelixFormatDate["timeStyle"]) | undefined;
+  /** The locale's own pattern for the time of day: `full`, `long`, `medium`, or
+`short`. Set, it stands in for `hour`, `minute`, `second` and
+`time-zone-name`. */
+  timeStyle?: (HelixFormatDate["timeStyle"]) | undefined;
   /** The time zone to read the timestamp in.
 
 Empty is the runtime's own. */
@@ -6320,6 +7020,28 @@ There is no `justifyContent` here for the same reason: the tracks are
 distribute. `columns`, `min` and `--grid-columns` are how a grid says how
 wide its tracks are. */
   alignItems?: (HelixGrid["alignItems"]) | undefined;
+  /** How cells fill the grid when no child places itself, set as
+`grid-auto-flow`.
+
+`column` fills each column before the next. `dense` and `column-dense`
+also move a later small cell back into an earlier gap. Moving them changes
+only where they are drawn, so focus and a screen reader still follow the
+markup. */
+  "auto-flow"?: (HelixGrid["autoFlow"]) | undefined;
+  /** How cells fill the grid when no child places itself, set as
+`grid-auto-flow`.
+
+`column` fills each column before the next. `dense` and `column-dense`
+also move a later small cell back into an earlier gap. Moving them changes
+only where they are drawn, so focus and a screen reader still follow the
+markup. */
+  autoFlow?: (HelixGrid["autoFlow"]) | undefined;
+  /** The space between columns, as a step on the space scale. Wins over `gap`
+across the row. */
+  "column-gap"?: (HelixGrid["columnGap"]) | undefined;
+  /** The space between columns, as a step on the space scale. Wins over `gap`
+across the row. */
+  columnGap?: (HelixGrid["columnGap"]) | undefined;
   /** A fixed number of equal columns.
 
 Two to six are plain CSS. Any other count is written into the shadow
@@ -6327,6 +7049,16 @@ root's rule, which the server renders too. */
   columns?: (HelixGrid["columns"]) | undefined;
   /** The space between cells, as a step on the space scale. */
   gap?: (HelixGrid["gap"]) | undefined;
+  /** How each cell aligns within its column. Sets `justify-items`.
+
+Named for the CSS property it sets, the way `alignItems` is. Absent, every
+cell stretches to the width of its column. */
+  "justify-items"?: (HelixGrid["justifyItems"]) | undefined;
+  /** How each cell aligns within its column. Sets `justify-items`.
+
+Named for the CSS property it sets, the way `alignItems` is. Absent, every
+cell stretches to the width of its column. */
+  justifyItems?: (HelixGrid["justifyItems"]) | undefined;
   /** The minimum column width. The grid fits as many columns as the width allows.
 
 A length, such as `12rem`, or `calc()`, `clamp()`, `min()`, `max()` and
@@ -6336,6 +7068,12 @@ lays out by `columns`.
 Takes precedence over `columns`: a grid that both fixes a count and reflows
 is two intentions in one element. */
   min?: (HelixGrid["min"]) | undefined;
+  /** The space between rows, as a step on the space scale. Wins over `gap` down
+the column. */
+  "row-gap"?: (HelixGrid["rowGap"]) | undefined;
+  /** The space between rows, as a step on the space scale. Wins over `gap` down
+the column. */
+  rowGap?: (HelixGrid["rowGap"]) | undefined;
 };
 
 export type HelixGridVueEvents = {};
@@ -6568,6 +7306,22 @@ Lives here rather than only on `IconButton` so the two share one render.
 An icon-only button without it is a control a screen reader announces as
 "button" and nothing else. */
   label?: (HelixIconButton["label"]) | undefined;
+  /** Whether the action the button started is still running.
+
+A pending button keeps focus and stays in the tab order, and refuses every
+press: a click, Enter and Space, and Enter in a field of its form. The
+click does not reach your listeners. The inner control carries
+`aria-busy` and `aria-disabled`, and when the button becomes pending while
+it has focus, a reader hears `pending-label`. The styled button draws a
+turning ring over its words.
+
+`disabled` takes the button out of reach. Use `pending` for the wait after
+a press, so focus stays where the reader left it. */
+  pending?: (HelixIconButton["pending"]) | undefined;
+  /** What a reader hears when the button becomes pending while it has focus. */
+  "pending-label"?: (HelixIconButton["pendingLabel"]) | undefined;
+  /** What a reader hears when the button becomes pending while it has focus. */
+  pendingLabel?: (HelixIconButton["pendingLabel"]) | undefined;
   /** What activating the button does to its form. */
   type?: (HelixIconButton["type"]) | undefined;
   /** The value this button submits under its own `name`, as a native submit
@@ -6687,8 +7441,12 @@ disagreeing with its own name for every reader who meant the left. */
 so it is what markup can carry, and resolving one means an index of the
 whole set that no bundler can shake: 15 kB for a consumer who renders one
 mark. An attribute is the only thing an HTML author can write, and that is
-worth the index; a consumer who would rather not pay it hands over the
-value instead. */
+worth the index; a consumer who would rather not pay it imports the
+element from `icon/root` and registers the glyphs it names, or hands over
+the value instead.
+
+A name written `prefix:name` asks the library registered under that
+prefix. */
   name?: (HelixIcon["name"]) | undefined;
   /** The icon to draw, as an object you import.
 
@@ -6706,8 +7464,10 @@ for. Set both and this wins, the value being the more specific statement. */
 };
 
 export type HelixIconVueEvents = {
-  /** `name` matches no icon in the set, so nothing is drawn. */
+  /** `name` matches no registered icon and no library answers it, so nothing is drawn. */
   error: HelixIconElementEvent;
+  /** A glyph a library gave later for `name` is drawn. */
+  load: HelixIconElementEvent;
 };
 
 /** `HelixImage` component event */
@@ -6766,6 +7526,18 @@ ninety-nine pictures. */
 picture worth putting in a component is usually below the fold and the one
 that is not is the exception worth writing down. */
   loading?: (HelixImage["loading"]) | undefined;
+  /** How long, in milliseconds, the placeholder waits before it shows.
+
+Absent or `0` shows it at once. A picture that arrives inside
+the wait never shows a placeholder at all, so a cached or fast image does
+not flash one. Radix's `delayMs` on its avatar fallback is the same idea. */
+  "placeholder-delay"?: (HelixImage["placeholderDelay"] | `${number}`) | undefined;
+  /** How long, in milliseconds, the placeholder waits before it shows.
+
+Absent or `0` shows it at once. A picture that arrives inside
+the wait never shows a placeholder at all, so a cached or fast image does
+not flash one. Radix's `delayMs` on its avatar fallback is the same idea. */
+  placeholderDelay?: (HelixImage["placeholderDelay"]) | undefined;
   /** How much of the referring URL to send with the request. */
   referrerpolicy?: (HelixImage["referrerPolicy"]) | undefined;
   /** How much of the referring URL to send with the request. */
@@ -6809,6 +7581,9 @@ export type HelixInputElementEvent<E = Event> = TypedEvent<HelixInput, E>;
 /** `helix-before-change` event type */
 export type HelixInputHelixBeforeChangeElementEvent =
   HelixInputElementEvent<HelixBeforeChangeEvent>;
+/** `helix-clear` event type */
+export type HelixInputHelixClearElementEvent =
+  HelixInputElementEvent<HelixClearEvent>;
 
 export type HelixInputVueProps = {
   /** The value the control starts with. A form reset returns it to this value. */
@@ -7011,6 +7786,8 @@ export type HelixInputVueEvents = {
   change: HelixInputElementEvent;
   /** The text is about to change. Cancelable: cancel it to keep the current text. */
   "helix-before-change": HelixInputHelixBeforeChangeElementEvent;
+  /** Fired after the clear button has emptied the field, after `input` and `change`. */
+  "helix-clear": HelixInputHelixClearElementEvent;
   /** Fired as the value changes. */
   input: HelixInputElementEvent;
 };
@@ -7022,6 +7799,13 @@ export type HelixKbdHelixShortcutElementEvent =
   HelixKbdElementEvent<HelixShortcutEvent>;
 
 export type HelixKbdVueProps = {
+  /** The id of the control the shortcut works, which is given the chord as its
+`aria-keyshortcuts`.
+
+Names an element in the same tree, the way `Tooltip.for` does. Separate
+from `within`, which says where the key listens: a key can describe a
+shortcut the page binds itself. */
+  for?: (HelixKbd["for"]) | undefined;
   /** The key or chord to show, such as `mod+k`, `?`, or `/`.
 
 `mod` is the platform's own command modifier, which is the reason to write
@@ -7050,6 +7834,12 @@ export type HelixKbdVueEvents = {
   "helix-shortcut": HelixKbdHelixShortcutElementEvent;
 };
 
+/** `HelixLegend` component event */
+export type HelixLegendElementEvent<E = Event> = TypedEvent<HelixLegend, E>;
+/** `helix-before-change` event type */
+export type HelixLegendHelixBeforeChangeElementEvent =
+  HelixLegendElementEvent<HelixBeforeChangeEvent>;
+
 export type HelixLegendVueProps = {
   /** How the swatches are drawn: `outlined`, `subtle`, or `solid`.
 
@@ -7145,14 +7935,40 @@ shadow root reads a table in that root rather than one in the document.
 **In React this arrives as a property and not as an attribute**, the way
 `Tooltip.for` does, so it does not reflect and nothing styles on it. */
   for?: (HelixLegend["for"]) | undefined;
+  /** The series hidden on the table, by name, separated by commas: what
+`toggles` hides and shows.
+
+Set it to start with series hidden. Every chart reading the same table
+draws without them. Commas only, because a column's heading may hold a
+space. For a ring the names are the rows. */
+  "hidden-series"?: (HelixLegend["hiddenSeries"]) | undefined;
+  /** The series hidden on the table, by name, separated by commas: what
+`toggles` hides and shows.
+
+Set it to start with series hidden. Every chart reading the same table
+draws without them. Commas only, because a column's heading may hold a
+space. For a ring the names are the rows. */
+  hiddenSeries?: (HelixLegend["hiddenSeries"]) | undefined;
   /** The name of the list, which a screen reader announces before its entries.
 
 Absent names the list after the table's caption, so a page with several
 charts has a legend list for each that says which chart it keys. */
   label?: (HelixLegend["label"]) | undefined;
+  /** Makes each entry a button that hides or shows its series in every chart
+reading the same table.
+
+Absent, the legend only displays, which is what it did before this
+existed. Reflected, because the styled tier draws a button differently
+from a plain entry. */
+  toggles?: (HelixLegend["toggles"]) | undefined;
 };
 
-export type HelixLegendVueEvents = {};
+export type HelixLegendVueEvents = {
+  /** Fired once a toggle has hidden or shown a series. */
+  change: HelixLegendElementEvent;
+  /** Fired before a toggle hides or shows a series, with the `hidden-series` it would leave. Cancelable. */
+  "helix-before-change": HelixLegendHelixBeforeChangeElementEvent;
+};
 
 export type HelixLightboxItemVueProps = {
   /** Whether this item is the one shown.
@@ -7221,6 +8037,19 @@ hydration, or diffed by a framework, it comes back holding whatever the
 last reader did rather than what the author wrote. `:state(open)` carries
 the resolved state for stylesheets, which is what the mirror is for. */
   open?: (HelixLightbox["open"]) | undefined;
+  /** Draws the viewer's own previous, next and close controls over the picture.
+
+Off by default, for a viewer whose chrome you compose in the `header` and
+`footer` slots. The controls hide with the rest of the chrome while the
+reader is idle, and the previous and next ones say they are unavailable at
+either end of a set that does not `loop`. */
+  controls?: (HelixLightbox["controls"]) | undefined;
+  /** The close control's accessible name. Translate it with the rest of your
+interface. */
+  "dismiss-label"?: (HelixLightbox["dismissLabel"]) | undefined;
+  /** The close control's accessible name. Translate it with the rest of your
+interface. */
+  dismissLabel?: (HelixLightbox["dismissLabel"]) | undefined;
   /** How long the user can be idle before the header and footer hide, in
 milliseconds.
 
@@ -7239,6 +8068,28 @@ keep the chrome up is the consumer's to decide with this. */
   label?: (HelixLightbox["label"]) | undefined;
   /** Whether moving past the last item returns to the first. */
   loop?: (HelixLightbox["loop"]) | undefined;
+  /** The next control's accessible name. */
+  "next-label"?: (HelixLightbox["nextLabel"]) | undefined;
+  /** The next control's accessible name. */
+  nextLabel?: (HelixLightbox["nextLabel"]) | undefined;
+  /** The previous control's accessible name. */
+  "previous-label"?: (HelixLightbox["previousLabel"]) | undefined;
+  /** The previous control's accessible name. */
+  previousLabel?: (HelixLightbox["previousLabel"]) | undefined;
+  /** The name of an item with no `label` of its own, with `{index}` and
+`{count}` filled in. */
+  "slide-label"?: (HelixLightbox["slideLabel"]) | undefined;
+  /** The name of an item with no `label` of its own, with `{index}` and
+`{count}` filled in. */
+  slideLabel?: (HelixLightbox["slideLabel"]) | undefined;
+  /** The word screen readers announce in place of an item's role, set as
+`aria-roledescription`. Translate it with the rest of your text, or empty
+it to leave the role as `group`. */
+  "slide-role-label"?: (HelixLightbox["slideRoleLabel"]) | undefined;
+  /** The word screen readers announce in place of an item's role, set as
+`aria-roledescription`. Translate it with the rest of your text, or empty
+it to leave the role as `group`. */
+  slideRoleLabel?: (HelixLightbox["slideRoleLabel"]) | undefined;
   /** The status text that says which item is shown, with `{index}`, `{count}`
 and the item's `{label}` filled in.
 
@@ -7428,7 +8279,24 @@ near the top of the box. */
 
 export type HelixLineChartVueEvents = {};
 
+/** `HelixListItem` component event */
+export type HelixListItemElementEvent<E = Event> = TypedEvent<HelixListItem, E>;
+/** `helix-action` event type */
+export type HelixListItemHelixActionElementEvent =
+  HelixListItemElementEvent<HelixActionEvent>;
+
 export type HelixListItemVueProps = {
+  /** Marks the row a reader is on: `page` for the page they are reading, `step`,
+`location`, `date` or `time` for those, and written bare for the current
+one of a set. It is `aria-current` on the row's link, or on the row where
+it has none.
+
+Not reflected, as a state never is. `row-current` is the part a
+stylesheet draws it from. */
+  current?: (HelixListItem["current"]) | undefined;
+  /** Takes the row out of reach in a list with `selection-mode`: the arrow keys
+pass over it and it cannot be selected or acted on. */
+  disabled?: (HelixListItem["disabled"]) | undefined;
   /** The URL the row links to. Leave it empty for a row that is not a link.
 
 Empty rather than optional, and unset by default: a list is not always a
@@ -7440,9 +8308,36 @@ to the current page on every row a consumer never asked to be one. */
   rel?: (HelixListItem["rel"]) | undefined;
   /** Where the link opens. Use it for a row that leaves the site. */
   target?: (HelixListItem["target"]) | undefined;
+  /** What the row stands for in its list's `value`.
+
+Absent is the row's own words. */
+  value?: (HelixListItem["value"]) | undefined;
+  /** Whether the row holds its list's tab stop.
+
+Written by a list with `selection-mode` on every row it holds, and unset
+otherwise, which is how a row knows it is a row of a grid. No attribute:
+it is coordination between elements, as `Tag.focusable` is. */
+  focusable?: (HelixListItem["focusable"]) | undefined;
+  /** Whether the row is selected, in a list that selects.
+
+Written by the list from its own `value`, and unset where nothing can be
+selected, which keeps `aria-selected` off a list that does not select. */
+  selected?: (HelixListItem["selected"]) | undefined;
 };
 
-export type HelixListItemVueEvents = {};
+export type HelixListItemVueEvents = {
+  /** The reader pressed Enter on the row, or pressed the row in a list that selects nothing, in a list with `selection-mode`. Read the row from `target`. A row with `href` follows its link instead. */
+  "helix-action": HelixListItemHelixActionElementEvent;
+};
+
+/** `HelixList` component event */
+export type HelixListElementEvent<E = Event> = TypedEvent<HelixList, E>;
+/** `helix-action` event type */
+export type HelixListHelixActionElementEvent =
+  HelixListElementEvent<HelixActionEvent>;
+/** `helix-before-change` event type */
+export type HelixListHelixBeforeChangeElementEvent =
+  HelixListElementEvent<HelixBeforeChangeEvent>;
 
 export type HelixListVueProps = {
   /** Draws a line between rows. */
@@ -7485,6 +8380,20 @@ has to survive with the stylesheet turned off.
   kind?: (HelixList["kind"]) | undefined;
   /** The list's name, read by screen readers. */
   label?: (HelixList["label"]) | undefined;
+  /** Numbers an ordered list downward, so the count falls row by row and ends at
+its last row, as `<ol reversed>` does. */
+  reversed?: (HelixList["reversed"]) | undefined;
+  /** Makes the list interactive: `single` selects one row, `multiple` any
+number, and `none` moves and acts without selecting. Unset is a list a
+reader reads, with no tab stop of its own. */
+  "selection-mode"?: (HelixList["selectionMode"]) | undefined;
+  /** Makes the list interactive: `single` selects one row, `multiple` any
+number, and `none` moves and acts without selecting. Unset is a list a
+reader reads, with no tab stop of its own. */
+  selectionMode?: (HelixList["selectionMode"]) | undefined;
+  /** The number of an ordered list's first row, as `<ol start>` is. Unset counts
+from one, or down from the number of rows where `reversed`. */
+  start?: (HelixList["start"]) | undefined;
   /** The markers an ordered list draws. It takes the five values of `<ol type>`.
 
 Reflected, because this is one of the things a stylesheet selects on, each
@@ -7492,18 +8401,24 @@ value mapping to a `list-style-type`. The platform's spellings rather than
 the CSS ones, so `<helix-headless-list kind="ordered" type="i">` is what a
 consumer would have written on an `<ol>`.
 
-**`start` and `reversed` are both absent and neither can be done here.**
-This renders no `<ol>`: the rows are slotted and numbered by the CSS
-`list-item` counter, and that counter is not author-resettable. Measured in
-Chrome 148, `counter-reset: list-item 4` moves nothing on a `<div>`, on a
-`<ul>`, or even on a real `<ol>`, while `<ol start="5">` does and a *named*
-counter with explicit `::before` content does. So the markers would have to
-be rebuilt out of generated content to gain a start, which is a different
-component. `type` is only `list-style-type` and works. */
+`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.
+
+Set it to start with rows selected. A row's value is its `value`, or its
+words where it has none. */
+  value?: (HelixList["value"]) | undefined;
 };
 
-export type HelixListVueEvents = {};
+export type HelixListVueEvents = {
+  /** Fired once a press has changed which rows are selected. */
+  change: HelixListElementEvent;
+  /** Sent from a row when the reader acts on it: Enter, or a press in a list that selects nothing. Read the row from `target`. A row with `href` follows its link instead. */
+  "helix-action": HelixListHelixActionElementEvent;
+  /** Fired before a press changes which rows are selected, with the `value` it would leave. Cancelable. */
+  "helix-before-change": HelixListHelixBeforeChangeElementEvent;
+};
 
 /** `HelixListbox` component event */
 export type HelixListboxElementEvent<E = Event> = TypedEvent<HelixListbox, E>;
@@ -7595,6 +8510,22 @@ filtering already does: `filter`, the empty state and the keyboard are all
 this component's. A select, a combobox and a command palette drawing their
 own search boxes would be three copies of one field. */
   filterable?: (HelixListbox["filterable"]) | undefined;
+  /** How long typing in the filter field rests before the list is filtered, in
+milliseconds. `0` filters on every keystroke.
+
+For a list filtered on a server, where `helix-filter` starts a request: a
+reader typing a word sends one request for the word, not one for each
+letter. Enter and the arrow keys filter at once on what is typed, so they
+act on the list the reader expects. */
+  "filter-delay"?: (HelixListbox["filterDelay"] | `${number}`) | undefined;
+  /** How long typing in the filter field rests before the list is filtered, in
+milliseconds. `0` filters on every keystroke.
+
+For a list filtered on a server, where `helix-filter` starts a request: a
+reader typing a word sends one request for the word, not one for each
+letter. Enter and the arrow keys filter at once on what is typed, so they
+act on the list the reader expects. */
+  filterDelay?: (HelixListbox["filterDelay"]) | undefined;
   /** Placeholder text for the filter field. */
   "filter-label"?: (HelixListbox["filterLabel"]) | undefined;
   /** Placeholder text for the filter field. */
@@ -7608,6 +8539,26 @@ a reader can move through the options before closing the panel on one. */
   manual?: (HelixListbox["manual"]) | undefined;
   /** Whether more than one option can be chosen. */
   multiple?: (HelixListbox["multiple"]) | undefined;
+  /** What a screen reader hears when a filter leaves one option. `{count}` is
+the count. */
+  "result-label"?: (HelixListbox["resultLabel"]) | undefined;
+  /** What a screen reader hears when a filter leaves one option. `{count}` is
+the count. */
+  resultLabel?: (HelixListbox["resultLabel"]) | undefined;
+  /** What a screen reader hears when a filter leaves any other number of
+options. `{count}` is the count.
+
+**Two sentences, chosen by `Intl.PluralRules`**, which is Data Table's
+pair: a language with more forms than two picks the one for its `one` and
+writes the rest here. */
+  "results-label"?: (HelixListbox["resultsLabel"]) | undefined;
+  /** What a screen reader hears when a filter leaves any other number of
+options. `{count}` is the count.
+
+**Two sentences, chosen by `Intl.PluralRules`**, which is Data Table's
+pair: a language with more forms than two picks the one for its `one` and
+writes the rest here. */
+  resultsLabel?: (HelixListbox["resultsLabel"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -7671,6 +8622,18 @@ swells with it, in step. It is the shape for a wait that has a mark to
 show, a splash or a first paint behind a wordmark, where a rotating rim
 around a logo reads as chrome bolted to the brand. */
   variant?: (HelixLoader["variant"]) | undefined;
+  /** How long the loader waits before it shows, in milliseconds, so work that
+finishes quickly never flashes one.
+
+Absent shows it at once. Hidden in the served markup too, so a page that
+loads quickly never draws it. */
+  delay?: (HelixLoader["delay"]) | undefined;
+  /** The id of the region being loaded, which is marked `aria-busy` while the
+loader is on the page.
+
+Names an element in the same tree. In React it arrives as a property, the
+way `Tooltip.for` does. */
+  for?: (HelixLoader["for"]) | undefined;
   /** The loader's name, announced by screen readers while the work is in
 progress. */
   label?: (HelixLoader["label"]) | undefined;
@@ -8041,6 +9004,9 @@ export type HelixMapHelixMapTiltElementEvent =
 /** `helix-map-zoom` event type */
 export type HelixMapHelixMapZoomElementEvent =
   HelixMapElementEvent<HelixMapZoomEvent>;
+/** `helix-toggle` event type */
+export type HelixMapHelixToggleElementEvent =
+  HelixMapElementEvent<HelixToggleEvent>;
 
 export type HelixMapVueProps = {
   /** Where the map's credit is drawn. Unset, it is a strip under the map.
@@ -8366,6 +9332,8 @@ export type HelixMapVueEvents = {
   "helix-map-tilt": HelixMapHelixMapTiltElementEvent;
   /** A zoom button or key was pressed, with a direction. Zoom your map in response. */
   "helix-map-zoom": HelixMapHelixMapZoomElementEvent;
+  /** A layer's tile in the layers menu showed or hid it. Sent from the layer once its `hidden` attribute holds the choice, with `checked` true when it is shown. */
+  "helix-toggle": HelixMapHelixToggleElementEvent;
 };
 
 /** `HelixMapRoute` component event */
@@ -8630,37 +9598,24 @@ So the anchor *is* the row, carrying `menuitem` and the `tabindex` the menu
 roves, which is the same maneuver `Tree.Item` makes and the reason `href`
 changes the markup rather than only adding an attribute.
 
-**`Option` cannot have this and the reason is worth knowing**, since a
-command palette is the obvious place to want it. A listbox has to keep
-focus somewhere else, in the text field for a combobox, so it says which
-option is current with `aria-activedescendant`. That reference can only
-point at the option's host, measured: assigning
-`ariaActiveDescendantElement` an element inside a sibling shadow root reads
-back `null`. So `role="option"` is pinned to the host, and an anchor under
-it hits the naming failure above. A menu has no such constraint because
-focus really moves to the row. */
+**`Option` takes an `href` too, and keeps its role a different way.** A
+listbox keeps focus somewhere else, in the text field for a combobox, and
+names the current option with `aria-activedescendant`, which can only point
+at the option's host. So an option stays `role="option"` on its host, draws
+no anchor, and follows its link through an anchor made for the moment. A
+menu has no such constraint, because focus really moves to the row. */
   href?: (HelixMenuItem["href"]) | undefined;
   /** The link's `rel`. Set it whenever you set `target="_blank"`. */
   rel?: (HelixMenuItem["rel"]) | undefined;
+  /** The row's keyboard shortcut as a chord, such as `mod+s`, shown after the
+label in the platform's glyphs and given to the row as
+`aria-keyshortcuts`. `mod` is Command on an Apple keyboard and Control
+elsewhere. Showing a shortcut does not bind it. */
+  shortcut?: (HelixMenuItem["shortcut"]) | undefined;
   /** Where the link opens, for rows that should open outside the current page. */
   target?: (HelixMenuItem["target"]) | undefined;
   /** The row's value, sent in `helix-select` when the row is chosen. */
   value?: (HelixMenuItem["value"]) | undefined;
-  /** Whether the row is on the menu page that is showing.
-
-Set by the menu, and a property rather than an attribute for that reason.
-Public because the menu has to reach it, and not something a consumer
-writes: which page is open is the menu's business. */
-  onPage?: (HelixMenuItem["onPage"]) | undefined;
-  /** Whether the page showing is this row's submenu, or one below it.
-
-Separate from `onPage`, and it has to be. A row that opened a page is not
-itself on that page, so both are false for it, and rendering nothing on
-that basis takes its `slot[name="submenu"]` with it: the rows inside have
-nowhere to be assigned and are never laid out. Every row on the way down to
-the open page has to keep its slot, not only the one directly above it.
-Three levels deep, the topmost row holds the slot the middle one lives in. */
-  showingSubmenu?: (HelixMenuItem["showingSubmenu"]) | undefined;
 };
 
 export type HelixMenuItemVueEvents = {
@@ -8720,6 +9675,9 @@ the resolved state for stylesheets, which is what the mirror is for. */
   "back-label"?: (HelixMenu["backLabel"]) | undefined;
   /** The text of the row that returns from a submenu. */
   backLabel?: (HelixMenu["backLabel"]) | undefined;
+  /** Whether the menu is the trigger's context menu: it opens where the reader
+asks for one, with a right-click, a long press, Shift+F10 or the menu key. */
+  context?: (HelixMenu["context"]) | undefined;
   /** Accessible name for the surface.
 
 Empty by default, which names the surface by its trigger, so a menu opened
@@ -8745,6 +9703,14 @@ export type HelixMenuVueEvents = {
   "helix-select": HelixMenuHelixSelectElementEvent;
 };
 
+export type HelixMenuSectionVueProps = {
+  /** The heading's words, when they are plain text. Content in the `heading`
+slot replaces it. */
+  label?: (HelixMenuSection["label"]) | undefined;
+};
+
+export type HelixMenuSectionVueEvents = {};
+
 export type HelixMeterVueProps = {
   /** How strongly the reading is drawn. `subtle` draws it as a wash of its color.
 
@@ -8797,7 +9763,10 @@ no reader. */
 
 Absent leaves the range unbanded. */
   high?: (HelixMeter["high"]) | undefined;
-  /** Accessible name for the reading. */
+  /** Accessible name for the reading.
+
+A visible label in the `label` slot names it instead, with the words it
+shows, so the name and the label cannot disagree. */
   label?: (HelixMeter["label"]) | undefined;
   /** The locale the percentage is written in, such as `fr` for `72 %`.
 
@@ -8867,6 +9836,11 @@ fair summary of a task and a poor one of a quantity. */
 export type HelixMeterVueEvents = {};
 
 export type HelixNavigationVueProps = {
+  /** Whether the arrow keys move focus between the destinations.
+
+Off by default, so a page whose readers scroll with the arrow keys while
+a link has focus keeps doing so. */
+  arrows?: (HelixNavigation["arrows"]) | undefined;
   /** The landmark's name, read by screen readers.
 
 An `aria-label` or `aria-labelledby` on the host names the landmark too,
@@ -9046,6 +10020,9 @@ export type HelixNotificationsElementEvent<E = Event> = TypedEvent<
 /** `helix-dismiss` event type */
 export type HelixNotificationsHelixDismissElementEvent =
   HelixNotificationsElementEvent<HelixDismissEvent>;
+/** `helix-load-more` event type */
+export type HelixNotificationsHelixLoadMoreElementEvent =
+  HelixNotificationsElementEvent<HelixLoadMoreEvent>;
 /** `helix-read` event type */
 export type HelixNotificationsHelixReadElementEvent =
   HelixNotificationsElementEvent<HelixReadEvent>;
@@ -9067,6 +10044,16 @@ say that without the component knowing what a row looks like. */
   loadingText?: (HelixNotifications["loadingText"]) | undefined;
   /** The feed's name, read by screen readers. */
   label?: (HelixNotifications["label"]) | undefined;
+  /** Whether to draw a button after the list that asks for the next page, by
+sending `helix-load-more`. Take it off once there is nothing more. */
+  "load-more"?: (HelixNotifications["loadMore"]) | undefined;
+  /** Whether to draw a button after the list that asks for the next page, by
+sending `helix-load-more`. Take it off once there is nothing more. */
+  loadMore?: (HelixNotifications["loadMore"]) | undefined;
+  /** The text of the `load-more` button. */
+  "load-more-label"?: (HelixNotifications["loadMoreLabel"]) | undefined;
+  /** The text of the `load-more` button. */
+  loadMoreLabel?: (HelixNotifications["loadMoreLabel"]) | undefined;
   /** Whether to draw a control that marks everything read. */
   "mark-all"?: (HelixNotifications["markAll"]) | undefined;
   /** Whether to draw a control that marks everything read. */
@@ -9075,11 +10062,19 @@ say that without the component knowing what a row looks like. */
   "mark-all-label"?: (HelixNotifications["markAllLabel"]) | undefined;
   /** Label for the mark-all control. */
   markAllLabel?: (HelixNotifications["markAllLabel"]) | undefined;
+  /** How many notifications there are in all, where the feed holds only some of
+them, read as each row's `aria-setsize`. `-1` says the count is unknown.
+
+Unset, the browser counts the rows it can see, which is right for a feed
+that holds everything. */
+  total?: (HelixNotifications["total"]) | undefined;
 };
 
 export type HelixNotificationsVueEvents = {
   /** Fired when the user dismisses a row. The row dispatches it, and you can listen for it on the feed. Cancelable: cancel it to keep the row. */
   "helix-dismiss": HelixNotificationsHelixDismissElementEvent;
+  /** Fired when a reader presses the `load-more` button, asking for the next page of the feed. */
+  "helix-load-more": HelixNotificationsHelixLoadMoreElementEvent;
   /** Fired by an item when it is marked read or unread, and by the feed when everything is marked read. Cancelable. */
   "helix-read": HelixNotificationsHelixReadElementEvent;
 };
@@ -9162,6 +10157,22 @@ reach the bubble. Absent is the control's own sentence, in English. */
   "decrement-label"?: (HelixNumberInput["decrementLabel"]) | undefined;
   /** The name of the step down button, read by screen readers. */
   decrementLabel?: (HelixNumberInput["decrementLabel"]) | undefined;
+  /** `Intl.NumberFormat` options the number is shown with while the field is
+not being edited: a currency, a percent, a unit, or a number of decimals.
+Written as JSON in the attribute.
+
+```html
+<helix-number-input format-options='{"style":"currency","currency":"EUR"}'></helix-number-input>
+``` */
+  "format-options"?: (HelixNumberInput["formatOptions"]) | undefined;
+  /** `Intl.NumberFormat` options the number is shown with while the field is
+not being edited: a currency, a percent, a unit, or a number of decimals.
+Written as JSON in the attribute.
+
+```html
+<helix-number-input format-options='{"style":"currency","currency":"EUR"}'></helix-number-input>
+``` */
+  formatOptions?: (HelixNumberInput["formatOptions"]) | undefined;
   /** The name of the step up button, read by screen readers. */
   "increment-label"?: (HelixNumberInput["incrementLabel"]) | undefined;
   /** The name of the step up button, read by screen readers. */
@@ -9213,6 +10224,12 @@ filled in. */
   readonly?: (HelixNumberInput["readOnly"]) | undefined;
   /** Prevents editing. The value is still submitted with the form. */
   readOnly?: (HelixNumberInput["readOnly"]) | undefined;
+  /** What the field is described as on iOS and iPadOS, where it carries no
+spinbutton role. See the class description. */
+  "role-description"?: (HelixNumberInput["roleDescription"]) | undefined;
+  /** What the field is described as on iOS and iPadOS, where it carries no
+spinbutton role. See the class description. */
+  roleDescription?: (HelixNumberInput["roleDescription"]) | 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,
@@ -9245,6 +10262,10 @@ A unit slotted into `end` is drawn beside the number and is not part of
 what the spinbutton announces, so it goes here too. Empty announces the
 number alone. */
   valueText?: (HelixNumberInput["valueText"]) | undefined;
+  /** Whether the mouse wheel steps the number while the field has focus, as
+React Aria's NumberField does unless told not to. Off, the wheel scrolls
+the page, which is what a reader passing over a form expects. */
+  wheel?: (HelixNumberInput["wheel"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -9293,11 +10314,31 @@ export type HelixObjectInspectorElementEvent<E = Event> = TypedEvent<
   HelixObjectInspector,
   E
 >;
+/** `helix-activate` event type */
+export type HelixObjectInspectorHelixActivateElementEvent =
+  HelixObjectInspectorElementEvent<HelixActivateEvent>;
+/** `helix-before-activate` event type */
+export type HelixObjectInspectorHelixBeforeActivateElementEvent =
+  HelixObjectInspectorElementEvent<HelixBeforeActivateEvent>;
 /** `helix-copy` event type */
 export type HelixObjectInspectorHelixCopyElementEvent =
   HelixObjectInspectorElementEvent<HelixCopyEvent>;
+/** `helix-filter` event type */
+export type HelixObjectInspectorHelixFilterElementEvent =
+  HelixObjectInspectorElementEvent<HelixFilterEvent>;
+/** `helix-filtered` event type */
+export type HelixObjectInspectorHelixFilteredElementEvent =
+  HelixObjectInspectorElementEvent<HelixFilteredEvent>;
 
 export type HelixObjectInspectorVueProps = {
+  /** The active row's path, such as `/meta/tags/0`, and the empty string for the
+root.
+
+Reading gives the row the keys are on. Writing moves there, opening the
+branches around it, and sends no event, the way a script's write to any
+current value sends none. A path the value does not hold moves to the
+nearest branch above it that it does. */
+  active?: (HelixObjectInspector["active"]) | undefined;
   /** The copy button's accessible name on a row with a key, with the key filled
 in as `{name}`.
 
@@ -9328,6 +10369,15 @@ reader sees the shape of the value before its contents. `0` starts with the
 root closed; a large number opens everything, which on a big value is the
 wall of text this exists to avoid. */
   defaultDepth?: (HelixObjectInspector["defaultDepth"]) | undefined;
+  /** Text the tree is narrowed to: the entries whose key or value holds it,
+ignoring case, and the branches that lead to them. Empty shows everything. */
+  filter?: (HelixObjectInspector["filter"]) | undefined;
+  /** Whether to show a field that sets `filter`. */
+  filterable?: (HelixObjectInspector["filterable"]) | undefined;
+  /** The filter field's placeholder and accessible name. */
+  "filter-label"?: (HelixObjectInspector["filterLabel"]) | undefined;
+  /** The filter field's placeholder and accessible name. */
+  filterLabel?: (HelixObjectInspector["filterLabel"]) | undefined;
   /** The id of a `<script type="application/json">` holding the value.
 
 Read once the document exists, and again whenever this changes. Text that
@@ -9376,6 +10426,16 @@ who set the property. This button is positioned out of the flow and takes no
 room, so nothing selects on it, and reflection exists so that a selector can
 reach a value. */
   noCopy?: (HelixObjectInspector["noCopy"]) | undefined;
+  /** What a screen reader hears when a filter matches one entry. `{count}` is the count. */
+  "result-label"?: (HelixObjectInspector["resultLabel"]) | undefined;
+  /** What a screen reader hears when a filter matches one entry. `{count}` is the count. */
+  resultLabel?: (HelixObjectInspector["resultLabel"]) | undefined;
+  /** What a screen reader hears when a filter matches any other number of
+entries. `{count}` is the count. The two are chosen by `Intl.PluralRules`. */
+  "results-label"?: (HelixObjectInspector["resultsLabel"]) | undefined;
+  /** What a screen reader hears when a filter matches any other number of
+entries. `{count}` is the count. The two are chosen by `Intl.PluralRules`. */
+  resultsLabel?: (HelixObjectInspector["resultsLabel"]) | undefined;
   /** The tree's accessible name when `label` is empty and the host names it
 with neither `aria-label` nor `aria-labelledby`. */
   "tree-label"?: (HelixObjectInspector["treeLabel"]) | undefined;
@@ -9387,6 +10447,11 @@ with neither `aria-label` nor `aria-labelledby`. */
 For a value of thousands of entries. Reflected, because the box it scrolls
 needs a height, which is a stylesheet rule reading this attribute. */
   windowed?: (HelixObjectInspector["windowed"]) | undefined;
+  /** The open branches, by path, in no set order.
+
+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;
   /** 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
@@ -9395,8 +10460,16 @@ is shown as its string. */
 };
 
 export type HelixObjectInspectorVueEvents = {
+  /** The active row moved, by a key or a click. The detail's `value` is its path. */
+  "helix-activate": HelixObjectInspectorHelixActivateElementEvent;
+  /** The active row is about to move, with its new path. Cancelable: cancel it to keep the row where it is. */
+  "helix-before-activate": HelixObjectInspectorHelixBeforeActivateElementEvent;
   /** A value was put on the clipboard, from the copy button or the keyboard. */
   "helix-copy": HelixObjectInspectorHelixCopyElementEvent;
+  /** Text was typed in the filter field, with what it now holds. Cancelable: cancel it to keep the filter as it was. */
+  "helix-filter": HelixObjectInspectorHelixFilterElementEvent;
+  /** The filter field changed `filter`, which now holds the text. */
+  "helix-filtered": HelixObjectInspectorHelixFilteredElementEvent;
 };
 
 export type HelixOptionGroupVueProps = {
@@ -9479,6 +10552,24 @@ string is not a fact a selector needs. */
   description?: (HelixOption["description"]) | undefined;
   /** Prevents the option from being chosen. */
   disabled?: (HelixOption["disabled"]) | undefined;
+  /** Whether following the link downloads what it names. Only meaningful
+beside an `href`. */
+  download?: (HelixOption["download"]) | undefined;
+  /** The URL the option links to. Setting it makes the option a link: choosing
+it, with a press, Enter or a click, follows the link and selects nothing,
+as React Aria's items with `href` do. Command, Control and Shift open it
+where they open a link, in a new tab or a new window.
+
+`helix-select` is said first with the `href` in it, and canceling it keeps
+the browser from following, so a client-side router follows it instead.
+
+**The option stays an option**, and an anchor is never drawn inside it:
+`role="option"` sits on the host, where a listbox's
+`aria-activedescendant` can name it, and an `<a>` inside would be exposed
+as a link within the option and take its name (Menu Item's `href` records
+the measurement). The link is followed through an anchor made for the
+moment, which `followLink` describes. */
+  href?: (HelixOption["href"]) | undefined;
   /** A shorter name for this choice, for where the row does not fit.
 
 `<option label>`'s own meaning: the text a chooser shows when it has less
@@ -9490,10 +10581,30 @@ 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 link's `rel`. Set it whenever you set `target="_blank"`. */
+  rel?: (HelixOption["rel"]) | undefined;
   /** Whether this choice is currently chosen.
 
 Written by the listbox. */
   selected?: (HelixOption["selected"]) | undefined;
+  /** Where the link opens, such as `_blank`, for an option with an `href`. */
+  target?: (HelixOption["target"]) | undefined;
+  /** The words a reader types to reach this choice, where the row's own words
+are not them: typeahead, a filter and a combobox match against it, and a
+select's trigger shows it.
+
+For a row whose content is a picture, an avatar beside a name and a role,
+or a name written in another script, as React Aria's `textValue`. Empty
+reads the row's words, then `label`. */
+  "text-value"?: (HelixOption["textValue"]) | undefined;
+  /** The words a reader types to reach this choice, where the row's own words
+are not them: typeahead, a filter and a combobox match against it, and a
+select's trigger shows it.
+
+For a row whose content is a picture, an avatar beside a name and a role,
+or a name written in another script, as React Aria's `textValue`. Empty
+reads the row's words, then `label`. */
+  textValue?: (HelixOption["textValue"]) | undefined;
   /** The value that identifies the option, and that a form submits. */
   value?: (HelixOption["value"]) | undefined;
   /** Whether the markup declares this option selected. A form reset returns to it.
@@ -9525,11 +10636,18 @@ change of its own rather than a property being added. */
 };
 
 export type HelixOptionVueEvents = {
-  /** The option was chosen. Cancelable: canceling it leaves the selection as it was. */
+  /** The option was chosen. Cancelable: canceling it leaves the selection as it was, and keeps the browser from following an option's `href`. */
   "helix-select": HelixOptionHelixSelectElementEvent;
 };
 
 export type HelixOrbVueProps = {
+  /** Says each new state through a polite live region, such as "Working" and
+then "Done".
+
+Off by default, because the name and the busy state already change with
+the state, and an orb beside a stream of messages would otherwise talk
+over them. Set it on an orb that is the only sign of progress on the page. */
+  announce?: (HelixOrb["announce"]) | undefined;
   /** The name read by screen readers. Defaults to the name of the state, such
 as "Thinking".
 
@@ -9557,14 +10675,23 @@ The set of things an agent can be doing grows faster than this list, and a
 verb we have not made a shape for should cost a reader a less specific
 indicator, not an empty box where the indicator was.
 
-Not reflected: no rule selects on it, because the state is drawn rather than
-styled. A consumer writing the attribute can still select on their own
-markup. */
+Not reflected, because a state set from script would then write an
+attribute onto the host after a server sent it without one. Each state is
+a custom state instead, such as `:state(working)`. */
   state?: (HelixOrb["state"]) | undefined;
   /** The word for each state, for a page in another language.
 
-A state left out keeps its English word, and `label` wins over both. It is
-a property with no attribute, keyed by state, such as `{ thinking: '…' }`. */
+A state left out keeps its English word, and `label` wins over both.
+Keyed by state, such as `{ thinking: '…' }`. As an attribute it is that
+object as JSON, such as `state-labels='{"done":"Terminé"}'`, so server
+markup and plain HTML can carry the words too. */
+  "state-labels"?: (HelixOrb["stateLabels"]) | undefined;
+  /** The word for each state, for a page in another language.
+
+A state left out keeps its English word, and `label` wins over both.
+Keyed by state, such as `{ thinking: '…' }`. As an attribute it is that
+object as JSON, such as `state-labels='{"done":"Terminé"}'`, so server
+markup and plain HTML can carry the words too. */
   stateLabels?: (HelixOrb["stateLabels"]) | undefined;
 };
 
@@ -9597,7 +10724,8 @@ read at the click rather than cached, because a reader can change it while
 the page is open and this is the only motion in the component that
 JavaScript rather than CSS decides. */
   behavior?: (HelixOutline["behavior"]) | undefined;
-  /** The navigation's name, read by screen readers. */
+  /** The navigation's name, read by screen readers. A heading in the `heading`
+slot names it in place of this. */
   label?: (HelixOutline["label"]) | undefined;
   /** How far below the top of the scroll container a heading counts as reached,
 in pixels. The scroll container is the window or the panel the sections
@@ -9807,6 +10935,32 @@ Reading gives the real one; writing declares it the consumer's, and
 `default-value` seeds one this element owns. Same accessor pair as
 `Pagination.page` and the calendar's `month`. */
   value?: (HelixPaginationSize["value"]) | undefined;
+  /** Whether the control is disabled and cannot be used.
+
+Reflected, because the styled tier selects on it, and mirrored to
+`aria-disabled` rather than removing the element from the accessibility
+tree, so a screen reader can still announce that the control exists.
+
+The mirror itself is in `willUpdate` below, here rather than in each
+control, because here is where `disabled` is. */
+  disabled?: (HelixPaginationSize["disabled"]) | undefined;
+  /** The name the control's value is submitted under.
+
+**Reflected, and it is the exception to "reflect only what CSS selects
+on".** The platform builds a form's entry list from the `name` *content
+attribute*, not from the property, so a control named through the property
+submitted under no name at all and was silently dropped. Measured: two
+inputs in one form, one named by attribute and one by property, and the
+form carried a single entry.
+
+Safe for a React consumer, which is what the rule is protecting: React
+renders a custom element's props as attributes on the server, so the name
+is already in the markup being hydrated and reflecting it writes what is
+there. It is only a change to the markup when a consumer assigns it
+imperatively later, and nothing is hydrating by then.
+
+Here rather than on each control. */
+  name?: (HelixPaginationSize["name"]) | undefined;
 };
 
 export type HelixPaginationSizeVueEvents = {
@@ -9908,10 +11062,18 @@ that lets a phone offer the code out of a message. Later cells stay `off`
 for the reason in the class comment above, that six cells each offering
 the same code is one offer made six times. */
   autocomplete?: (HelixPinInput["autocomplete"]) | undefined;
+  /** Whether the form is submitted once the last box is filled, as Web
+Awesome's `autosubmit` and Radix's `autoSubmit`. Only for a code the field
+took: a refused last character submits nothing. */
+  autosubmit?: (HelixPinInput["autosubmit"]) | undefined;
   /** Accessible name for one box, with `{index}` and `{length}` filled in. */
   "cell-label"?: (HelixPinInput["cellLabel"]) | undefined;
   /** Accessible name for one box, with `{index}` and `{length}` filled in. */
   cellLabel?: (HelixPinInput["cellLabel"]) | undefined;
+  /** Separators drawn between the boxes: `#` or `*` for a box and anything
+else as it is written, so `###-###` draws a dash after the third. The
+separators are hidden from screen readers and are not part of the value. */
+  format?: (HelixPinInput["format"]) | undefined;
   /** How many characters the code has. */
   length?: (HelixPinInput["length"]) | undefined;
   /** Whether the characters are hidden, the way a password is. */
@@ -10037,8 +11199,17 @@ hydration, or diffed by a framework, it comes back holding whatever the
 last reader did rather than what the author wrote. `:state(open)` carries
 the resolved state for stylesheets, which is what the mirror is for. */
   open?: (HelixPopover["open"]) | undefined;
-  /** The panel's name, read by screen readers. */
+  /** Draws a point on the panel's edge facing the trigger.
+
+Off by default, which is the house style: a panel that opens from its
+trigger already reads as belonging to it. */
+  arrow?: (HelixPopover["arrow"]) | undefined;
+  /** The panel's name, read by screen readers. Left at `Popover`, the first
+heading in the panel names it instead. */
   label?: (HelixPopover["label"]) | undefined;
+  /** Keeps `Tab` inside the panel while it is open, and marks the panel
+`aria-modal`. A press outside and Escape still close it. */
+  modal?: (HelixPopover["modal"]) | undefined;
   /** Space between the trigger and the panel, in pixels. */
   offset?: (HelixPopover["offset"]) | undefined;
   /** Preferred side.
@@ -10088,7 +11259,10 @@ Not `Loader`, which is the other thing this could be. A loader says the
 page is busy; a bar says a named piece of work is running, and keeps its
 place in the layout when the answer arrives and it becomes determinate. */
   indeterminate?: (HelixProgress["indeterminate"]) | undefined;
-  /** Accessible name for what is in progress. */
+  /** Accessible name for what is in progress.
+
+A visible label in the `label` slot names it instead, with the words it
+shows, so the name and the label cannot disagree. */
   label?: (HelixProgress["label"]) | undefined;
   /** The locale the percentage is written in, such as `fr` for `72 %`.
 
@@ -10271,6 +11445,22 @@ not touch, and React reads that as a hydration mismatch. The absent
 attribute *is* the column, which the stylesheet reads as the base rule, so
 only `horizontal` has to be named. */
   orientation?: (HelixRadioGroup["orientation"]) | undefined;
+  /** Whether a reader can see and focus the answer and cannot change it. A
+read-only group still submits its value.
+
+React Aria's `isReadOnly`. A press on a radio is refused. The arrow keys,
+Home and End move focus between the radios and choose nothing, so a reader
+can hear every choice, and Tab still reaches the answer. The group says
+`aria-readonly`. A script can still set `value`. */
+  readonly?: (HelixRadioGroup["readOnly"]) | undefined;
+  /** Whether a reader can see and focus the answer and cannot change it. A
+read-only group still submits its value.
+
+React Aria's `isReadOnly`. A press on a radio is refused. The arrow keys,
+Home and End move focus between the radios and choose nothing, so a reader
+can hear every choice, and Tab still reaches the answer. The group says
+`aria-readonly`. A script can still set `value`. */
+  readOnly?: (HelixRadioGroup["readOnly"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -10463,6 +11653,9 @@ export type HelixRatingElementEvent<E = Event> = TypedEvent<HelixRating, E>;
 /** `helix-before-change` event type */
 export type HelixRatingHelixBeforeChangeElementEvent =
   HelixRatingElementEvent<HelixBeforeChangeEvent>;
+/** `helix-clear` event type */
+export type HelixRatingHelixClearElementEvent =
+  HelixRatingElementEvent<HelixClearEvent>;
 
 export type HelixRatingVueProps = {
   /** The shape of each mark. `dots` draws plain circles.
@@ -10528,6 +11721,10 @@ and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   valueMissingMessage?: (HelixRating["valueMissingMessage"]) | undefined;
+  /** Whether a reader can take the rating back to unrated: by pressing the
+chosen score again, or with Backspace or Delete. Zag's rating group
+clears the same way. */
+  clearable?: (HelixRating["clearable"]) | undefined;
   /** How many marks there are. */
   max?: (HelixRating["max"]) | undefined;
   /** The lowest score that can be given. A cleared rating shows this score.
@@ -10673,6 +11870,8 @@ export type HelixRatingVueEvents = {
   change: HelixRatingElementEvent;
   /** The score is about to change. Cancelable: cancel it to keep the current score. */
   "helix-before-change": HelixRatingHelixBeforeChangeElementEvent;
+  /** The rating went back to unrated, under `clearable`. Sent after `input` and `change`. */
+  "helix-clear": HelixRatingHelixClearElementEvent;
   /** The score changed. */
   input: HelixRatingElementEvent;
 };
@@ -10771,9 +11970,18 @@ export type HelixSandboxHelixCaretElementEvent =
 /** `helix-console` event type */
 export type HelixSandboxHelixConsoleElementEvent =
   HelixSandboxElementEvent<HelixConsoleEvent>;
+/** `helix-edit` event type */
+export type HelixSandboxHelixEditElementEvent =
+  HelixSandboxElementEvent<HelixEditEvent>;
+/** `helix-panel-resize` event type */
+export type HelixSandboxHelixPanelResizeElementEvent =
+  HelixSandboxElementEvent<HelixPanelResizeEvent>;
 /** `helix-resize` event type */
 export type HelixSandboxHelixResizeElementEvent =
   HelixSandboxElementEvent<HelixResizeEvent>;
+/** `helix-split` event type */
+export type HelixSandboxHelixSplitElementEvent =
+  HelixSandboxElementEvent<HelixSplitEvent>;
 
 export type HelixSandboxVueProps = {
   /** The name of the corner handle that moves both dividers at once, read by
@@ -10897,8 +12105,14 @@ export type HelixSandboxVueEvents = {
   "helix-caret": HelixSandboxHelixCaretElementEvent;
   /** Fired once per console call in the preview frame. The preview pane dispatches it. */
   "helix-console": HelixSandboxHelixConsoleElementEvent;
+  /** Fired after the source was edited, with the new source. The source pane dispatches it, and you can listen for it on the sandbox. */
+  "helix-edit": HelixSandboxHelixEditElementEvent;
+  /** Fired after the panel's divider settled at a new height, with the height in pixels. */
+  "helix-panel-resize": HelixSandboxHelixPanelResizeElementEvent;
   /** Fired by the preview pane when the height of the frame's content changes, with the new height. */
   "helix-resize": HelixSandboxHelixResizeElementEvent;
+  /** Fired after the panes' divider settled somewhere new, with the lead pane's share. */
+  "helix-split": HelixSandboxHelixSplitElementEvent;
 };
 
 /** `HelixSandboxSource` component event */
@@ -10912,6 +12126,9 @@ export type HelixSandboxSourceHelixBeforeEditElementEvent =
 /** `helix-caret` event type */
 export type HelixSandboxSourceHelixCaretElementEvent =
   HelixSandboxSourceElementEvent<HelixCaretEvent>;
+/** `helix-edit` event type */
+export type HelixSandboxSourceHelixEditElementEvent =
+  HelixSandboxSourceElementEvent<HelixEditEvent>;
 
 export type HelixSandboxSourceVueProps = {
   /** The editable region's name, read by screen readers. */
@@ -10942,6 +12159,8 @@ export type HelixSandboxSourceVueEvents = {
   "helix-before-edit": HelixSandboxSourceHelixBeforeEditElementEvent;
   /** Fired when the cursor moves. */
   "helix-caret": HelixSandboxSourceHelixCaretElementEvent;
+  /** Fired after the source was edited, with the new source. */
+  "helix-edit": HelixSandboxSourceHelixEditElementEvent;
 };
 
 export type HelixSandboxStatusBarVueProps = {
@@ -10960,12 +12179,39 @@ Absent shows no readout. */
 export type HelixSandboxStatusBarVueEvents = {};
 
 export type HelixSandboxTerminalVueProps = {
+  /** The clear button's text, under `controls`. */
+  "clear-label"?: (HelixSandboxTerminal["clearLabel"]) | undefined;
+  /** The clear button's text, under `controls`. */
+  clearLabel?: (HelixSandboxTerminal["clearLabel"]) | undefined;
+  /** Shows a clear button and a level filter above the log.
+
+Off by default, because a sandbox that puts the terminal in a panel often
+has a toolbar of its own for them. */
+  controls?: (HelixSandboxTerminal["controls"]) | undefined;
   /** Text shown before anything has been written. */
   "empty-label"?: (HelixSandboxTerminal["emptyLabel"]) | undefined;
   /** Text shown before anything has been written. */
   emptyLabel?: (HelixSandboxTerminal["emptyLabel"]) | undefined;
   /** The log's name, read by screen readers. */
   label?: (HelixSandboxTerminal["label"]) | undefined;
+  /** The quietest level shown: `info` hides plain logs, `warn` shows warnings
+and errors, and `error` shows errors only. Absent shows every line.
+
+Lines it hides are kept, so lowering it shows them again. The filter under
+`controls` sets it. */
+  level?: (HelixSandboxTerminal["level"]) | undefined;
+  /** The level filter's name, read by screen readers, under `controls`. */
+  "level-label"?: (HelixSandboxTerminal["levelLabel"]) | undefined;
+  /** The level filter's name, read by screen readers, under `controls`. */
+  levelLabel?: (HelixSandboxTerminal["levelLabel"]) | undefined;
+  /** What each choice of the level filter reads, for a page in another
+language, keyed by level, such as `{ warn: '…' }`. A level left out keeps
+its English words. As an attribute it is that object as JSON. */
+  "level-words"?: (HelixSandboxTerminal["levelWords"]) | undefined;
+  /** What each choice of the level filter reads, for a page in another
+language, keyed by level, such as `{ warn: '…' }`. A level left out keeps
+its English words. As an attribute it is that object as JSON. */
+  levelWords?: (HelixSandboxTerminal["levelWords"]) | undefined;
 };
 
 export type HelixSandboxTerminalVueEvents = {};
@@ -11014,14 +12260,44 @@ is read along. */
 
 export type HelixScatterChartVueEvents = {};
 
+/** `HelixScrollArea` component event */
+export type HelixScrollAreaElementEvent<E = Event> = TypedEvent<
+  HelixScrollArea,
+  E
+>;
+
 export type HelixScrollAreaVueProps = {
+  /** How long the scrollbars stay after the content stops moving, or the pointer
+leaves, in milliseconds. Read under `scrollbars="scroll"` and
+`scrollbars="hover"`. */
+  "hide-delay"?: (HelixScrollArea["hideDelay"] | `${number}`) | undefined;
+  /** How long the scrollbars stay after the content stops moving, or the pointer
+leaves, in milliseconds. Read under `scrollbars="scroll"` and
+`scrollbars="hover"`. */
+  hideDelay?: (HelixScrollArea["hideDelay"]) | undefined;
   /** The region's name, read by screen readers.
 
 Without one there is no region: see the note on the class. */
   label?: (HelixScrollArea["label"]) | undefined;
+  /** Draws scrollbars of the component's own in place of the browser's, and
+says when they show.
+
+- `auto`: on each axis that has content past it.
+- `always`: on each axis that can scroll, whether or not it has anything to
+  scroll, so the scrollbar is there before the content grows.
+- `scroll`: while the content is moving, and for `hide-delay` after.
+- `hover`: as `scroll`, and while the pointer is over the scroll area.
+
+Absent keeps the browser's scrollbars. */
+  scrollbars?: (HelixScrollArea["scrollbars"]) | undefined;
 };
 
-export type HelixScrollAreaVueEvents = {};
+export type HelixScrollAreaVueEvents = {
+  /** The content scrolled. Sent from the host, because the viewport's own does not leave the shadow root. Does not bubble. */
+  scroll: HelixScrollAreaElementEvent;
+  /** The content stopped scrolling. Sent from the host, as `scroll` is. Does not bubble. */
+  scrollend: HelixScrollAreaElementEvent;
+};
 
 /** `HelixSelect` component event */
 export type HelixSelectElementEvent<E = Event> = TypedEvent<HelixSelect, E>;
@@ -11183,6 +12459,15 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixSelect["name"]) | 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.
+
+For a trigger that shows more than the words, an avatar beside a name or a
+count of a long set, as React Aria's `SelectValue` takes children. The
+trigger is named by what this draws, so keep the words in it. Nothing
+chosen still shows `placeholder`. A property only, there being no way to
+write a function in markup. */
+  valueContent?: (HelixSelect["valueContent"]) | undefined;
   /** Which option is chosen, as an index, or `-1` where none is.
 
 Read off the listbox this renders, which owns the options and is where the
@@ -11210,6 +12495,11 @@ export type HelixSelectVueEvents = {
 };
 
 export type HelixSkeletonVueProps = {
+  /** How the placeholder shows it is waiting: a sweep when unset, `pulse` to
+fade the fill in and out, or `none` to sit still.
+
+Reduced motion stills both. */
+  effect?: (HelixSkeleton["effect"]) | undefined;
   /** The shape of the placeholder: `text`, `circle`, or a block when unset.
 
 Unset is a block, which is what most missing things are. A block is the
@@ -11221,6 +12511,12 @@ profile".
 
 Absent hides the placeholder from screen readers. */
   label?: (HelixSkeleton["label"]) | undefined;
+  /** Whether the content inside is still loading, which keeps it inert and
+draws the placeholder over it.
+
+Absent shows the content. An empty skeleton is a placeholder whatever
+this says. Reflected, because the styled tier hides the content on it. */
+  loading?: (HelixSkeleton["loading"]) | undefined;
 };
 
 export type HelixSkeletonVueEvents = {};
@@ -11290,6 +12586,25 @@ and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   valueMissingMessage?: (HelixSlider["valueMissingMessage"]) | undefined;
+  /** `Intl.NumberFormat` options the value is written with: a currency, a
+percent, a unit, or a number of decimals. Written as JSON in the
+attribute.
+
+```html
+<helix-slider format-options='{"style":"currency","currency":"USD"}'></helix-slider>
+``` */
+  "format-options"?: (HelixSlider["formatOptions"]) | undefined;
+  /** `Intl.NumberFormat` options the value is written with: a currency, a
+percent, a unit, or a number of decimals. Written as JSON in the
+attribute.
+
+```html
+<helix-slider format-options='{"style":"currency","currency":"USD"}'></helix-slider>
+``` */
+  formatOptions?: (HelixSlider["formatOptions"]) | undefined;
+  /** The locale `format-options` writes the value in, such as `de-DE`. Empty is
+the reader's own. */
+  locale?: (HelixSlider["locale"]) | undefined;
   /** Shows the value at each mark. */
   "marker-labels"?: (HelixSlider["markerLabels"]) | undefined;
   /** Shows the value at each mark. */
@@ -11332,6 +12647,12 @@ property, like every other word a control speaks. */
   "minimum-label"?: (HelixSlider["minimumLabel"]) | undefined;
   /** The name of a range's lower thumb, read after the slider's label. */
   minimumLabel?: (HelixSlider["minimumLabel"]) | undefined;
+  /** How many steps a range's two thumbs stay apart, as Zag's
+`minStepsBetweenThumbs`. A thumb pushed closer stops there. */
+  "min-steps-between-thumbs"?: (HelixSlider["minStepsBetweenThumbs"] | `${number}`) | undefined;
+  /** How many steps a range's two thumbs stay apart, as Zag's
+`minStepsBetweenThumbs`. A thumb pushed closer stops there. */
+  minStepsBetweenThumbs?: (HelixSlider["minStepsBetweenThumbs"]) | undefined;
   /** The direction the track runs. `vertical` stands it on end.
 
 For a level rather than a quantity: a fader, a channel, anything a reader
@@ -11387,6 +12708,10 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixSlider["name"]) | undefined;
+  /** Writes a value as text, in place of `format-options`: words for a scale,
+or anything `Intl.NumberFormat` cannot say. A property, since a function
+cannot be written in an attribute. */
+  formatter?: (HelixSlider["formatter"]) | undefined;
 };
 
 export type HelixSliderVueEvents = {
@@ -11579,6 +12904,11 @@ export type HelixSpeedDialHelixSelectElementEvent =
   HelixSpeedDialElementEvent<HelixSelectEvent>;
 
 export type HelixSpeedDialVueProps = {
+  /** When the actions' names show. Unset, always, beside each action. `hover`
+shows a name only while its action is under the pointer or has focus, as
+a tooltip does, for a dial whose icons speak for themselves. The names stay
+the actions' accessible names either way. */
+  labels?: (HelixSpeedDial["labels"]) | undefined;
   /** Whether the element starts open. Ignored once `open` is written. */
   "default-open"?: (HelixSpeedDial["defaultOpen"]) | undefined;
   /** Whether the element starts open. Ignored once `open` is written. */
@@ -11759,6 +13089,15 @@ Reading gives where it is; writing declares it the consumer's, and
 `default-position` seeds one this element owns. The same accessor pair
 `Pagination.page` and the calendar's `month` carry. */
   position?: (HelixSplitter["position"]) | undefined;
+  /** Where a dragged divider snaps, comma separated, as Web Awesome's split
+panel does: a bare number is a percentage and a length such as `240px` is
+measured along the splitter, so `snap="25, 50, 75"` or `snap="240px, 50"`.
+The arrow keys move by `step` and do not snap. */
+  snap?: (HelixSplitter["snap"]) | undefined;
+  /** How close a drag has to come to a snap point to land on it, in pixels. */
+  "snap-threshold"?: (HelixSplitter["snapThreshold"] | `${number}`) | undefined;
+  /** How close a drag has to come to a snap point to land on it, in pixels. */
+  snapThreshold?: (HelixSplitter["snapThreshold"]) | undefined;
   /** How far one arrow key press moves the divider, as a percentage. */
   step?: (HelixSplitter["step"]) | undefined;
 };
@@ -11857,6 +13196,9 @@ Ignored once `active` is written. */
 A list of stages is a landmark a reader arrives at out of order, so it
 needs a name of its own rather than borrowing the heading above it. */
   label?: (HelixSteps["label"]) | undefined;
+  /** Whether a reader has to finish each stage, or pass an `optional` one,
+before going on to the next. */
+  linear?: (HelixSteps["linear"]) | undefined;
   /** Which way the steps run.
 
 Absent is a row, which is what a form header wants, with each name under
@@ -11900,10 +13242,19 @@ export type HelixStepHelixSelectElementEvent =
 export type HelixStepVueProps = {
   /** Whether this stage is finished. */
   complete?: (HelixStep["complete"]) | undefined;
+  /** The words that tell a screen reader the stage is finished. Translate it
+with the page. */
+  "complete-label"?: (HelixStep["completeLabel"]) | undefined;
+  /** The words that tell a screen reader the stage is finished. Translate it
+with the page. */
+  completeLabel?: (HelixStep["completeLabel"]) | undefined;
   /** Whether this is the current stage. */
   current?: (HelixStep["current"]) | undefined;
   /** Whether the stage is disabled, so the user cannot go to it. */
   disabled?: (HelixStep["disabled"]) | undefined;
+  /** Whether a reader may pass the stage without finishing it, in a sequence
+with `linear`. Ark UI's skippable step. */
+  optional?: (HelixStep["optional"]) | undefined;
   /** The value the step sends in `helix-select`. */
   value?: (HelixStep["value"]) | undefined;
 };
@@ -11933,6 +13284,28 @@ stylesheets. */
   "default-checked"?: (HelixSwitch["defaultChecked"]) | undefined;
   /** Whether the control starts checked. A form reset returns it to this state. */
   defaultChecked?: (HelixSwitch["defaultChecked"]) | undefined;
+  /** Whether a reader can see and focus the control and cannot change it. A
+read-only control still submits its value.
+
+React Aria's `isReadOnly`. A native checkbox has no read-only state, so
+the press is refused at the inner control, which keeps its box as it
+was, and the control says `aria-readonly`. A script can still set
+`checked`, as it can set the value of a read-only text field.
+
+The attribute is `readonly`, which is the platform's spelling for the
+text fields. */
+  readonly?: (HelixSwitch["readOnly"]) | undefined;
+  /** Whether a reader can see and focus the control and cannot change it. A
+read-only control still submits its value.
+
+React Aria's `isReadOnly`. A native checkbox has no read-only state, so
+the press is refused at the inner control, which keeps its box as it
+was, and the control says `aria-readonly`. A script can still set
+`checked`, as it can set the value of a read-only text field.
+
+The attribute is `readonly`, which is the platform's spelling for the
+text fields. */
+  readOnly?: (HelixSwitch["readOnly"]) | undefined;
   /**  */
   "aria-label"?: unknown;
   /** The validation message shown under the control. It replaces the
@@ -12018,6 +13391,9 @@ export type HelixTableColumnElementEvent<E = Event> = TypedEvent<
 /** `helix-before-resize` event type */
 export type HelixTableColumnHelixBeforeResizeElementEvent =
   HelixTableColumnElementEvent<HelixBeforeResizeEvent>;
+/** `helix-resized` event type */
+export type HelixTableColumnHelixResizedElementEvent =
+  HelixTableColumnElementEvent<HelixResizedEvent>;
 
 export type HelixTableColumnVueProps = {
   /** The key this column reads out of a row.
@@ -12059,6 +13435,22 @@ replaced with the heading text. */
   /** The accessible name of the separator that resizes the column. `{name}` is
 replaced with the heading text. */
   resizeLabel?: (HelixTableColumn["resizeLabel"]) | undefined;
+  /** Makes this column's cells the headers of their rows, in `DataTable`.
+
+A screen reader moving along a row or down a column names the row by its
+row header, so the cell that identifies a row, a file's name say, is the
+one to mark. Where no column sets it, `DataTable` makes the first column
+with a `field` the row header. A `Table`'s cells are your markup, so there
+a cell is a row header through its own `header` attribute. */
+  "row-header"?: (HelixTableColumn["rowHeader"]) | undefined;
+  /** Makes this column's cells the headers of their rows, in `DataTable`.
+
+A screen reader moving along a row or down a column names the row by its
+row header, so the cell that identifies a row, a file's name say, is the
+one to mark. Where no column sets it, `DataTable` makes the first column
+with a `field` the row header. A `Table`'s cells are your markup, so there
+a cell is a row header through its own `header` attribute. */
+  rowHeader?: (HelixTableColumn["rowHeader"]) | undefined;
   /** Whether the table can be sorted by this column.
 
 Ignored without a `field`, and silently: a column with nothing to sort by
@@ -12186,13 +13578,24 @@ correct default: the raw value is what an API sorted by. */
 export type HelixTableColumnVueEvents = {
   /** The column is about to be resized, with the requested width. Cancelable: cancel it to keep the current width. */
   "helix-before-resize": HelixTableColumnHelixBeforeResizeElementEvent;
+  /** Fired after the column is resized, with the new width. */
+  "helix-resized": HelixTableColumnHelixResizedElementEvent;
 };
 
 /** `HelixTable` component event */
 export type HelixTableElementEvent<E = Event> = TypedEvent<HelixTable, E>;
+/** `helix-select` event type */
+export type HelixTableHelixSelectElementEvent =
+  HelixTableElementEvent<HelixSelectEvent>;
+/** `helix-selected` event type */
+export type HelixTableHelixSelectedElementEvent =
+  HelixTableElementEvent<HelixSelectedEvent>;
 /** `helix-sort` event type */
 export type HelixTableHelixSortElementEvent =
   HelixTableElementEvent<HelixSortEvent>;
+/** `helix-sorted` event type */
+export type HelixTableHelixSortedElementEvent =
+  HelixTableElementEvent<HelixSortedEvent>;
 
 export type HelixTableVueProps = {
   /** The text shown and announced when there are no rows and none are loading. */
@@ -12242,6 +13645,12 @@ and a list here would be a second way to say what that says. This table's
 cells are markup, and a table written as rows of cells with no column
 declared in it has nowhere else to be sized from. */
   columns?: (HelixTable["columns"]) | undefined;
+  /** The keys selected at the start, separated by commas. Used until `selected`
+is set. */
+  "default-selected"?: (HelixTable["defaultSelected"]) | undefined;
+  /** The keys selected at the start, separated by commas. Used until `selected`
+is set. */
+  defaultSelected?: (HelixTable["defaultSelected"]) | undefined;
   /** The starting sort order, used until `sort` is set. */
   "default-sort"?: (HelixTable["defaultSort"]) | undefined;
   /** The starting sort order, used until `sort` is set. */
@@ -12255,6 +13664,31 @@ declared in it has nowhere else to be sized from. */
 An `aria-label` or `aria-labelledby` on the host names the table too, and
 wins over this. */
   label?: (HelixTable["label"]) | undefined;
+  /** Adds a column of checkboxes for selecting rows. Each row is known by its
+`value`, and by its place among the rows as written where it has none. */
+  selectable?: (HelixTable["selectable"]) | undefined;
+  /** The name of the checkbox in the heading that selects every row. */
+  "select-all-label"?: (HelixTable["selectAllLabel"]) | undefined;
+  /** The name of the checkbox in the heading that selects every row. */
+  selectAllLabel?: (HelixTable["selectAllLabel"]) | undefined;
+  /** The keys of the selected rows, separated by commas.
+
+A reader's press fires `helix-select` first, and refusing it leaves the
+selection as it was. `default-selected` seeds a selection this element
+then owns. */
+  selected?: (HelixTable["selected"]) | undefined;
+  /** What screen readers hear when the chosen rows change. `{count}` is how many
+rows are chosen. */
+  "selected-label"?: (HelixTable["selectedLabel"]) | undefined;
+  /** What screen readers hear when the chosen rows change. `{count}` is how many
+rows are chosen. */
+  selectedLabel?: (HelixTable["selectedLabel"]) | undefined;
+  /** The name of a row's checkbox. `{row}` is replaced with the words of the
+row's first cell. */
+  "select-row-label"?: (HelixTable["selectRowLabel"]) | undefined;
+  /** The name of a row's checkbox. `{row}` is replaced with the words of the
+row's first cell. */
+  selectRowLabel?: (HelixTable["selectRowLabel"]) | undefined;
   /** The sort order, as `field:direction`, where `field` is a sortable column's
 `field`.
 
@@ -12276,11 +13710,21 @@ column's heading and `{order}` is `ascending-label` or `descending-label`. */
 };
 
 export type HelixTableVueEvents = {
+  /** The selection is about to change. The event carries every selected key, separated by commas. Cancelable: cancel it to keep the current selection. */
+  "helix-select": HelixTableHelixSelectElementEvent;
+  /** Fired after the selection changes, with every selected key, separated by commas. */
+  "helix-selected": HelixTableHelixSelectedElementEvent;
   /** A different sort order was requested, as `field:direction`, or empty for the order the rows were written in. Cancelable: cancel it to keep the current order. */
   "helix-sort": HelixTableHelixSortElementEvent;
+  /** Fired after the sort order changes, with the new order. */
+  "helix-sorted": HelixTableHelixSortedElementEvent;
 };
 
-export type HelixTableRowVueProps = {};
+export type HelixTableRowVueProps = {
+  /** The key the table's `selected` lists this row by. Left empty, the row is
+known by its place among the rows as written. */
+  value?: (HelixTableRow["value"]) | undefined;
+};
 
 export type HelixTableRowVueEvents = {};
 
@@ -12296,10 +13740,9 @@ because it is coordination between elements rather than anything a consumer
 writes: the tab already says it.
 
 A string and not a reference: an IDREF resolves only in the tree it is
-written in, and an element reference cannot reach a sibling shadow tree
-either, so `aria-labelledby` to the tab's own id leaves the panel with no
-accessible name. `aria-label` on a `tabpanel` is how the pattern names one
-anyway. */
+written in, and the tab's control is inside the tab's shadow root, which no
+reference from the light DOM can reach. `aria-label` on a `tabpanel` is how
+the pattern names one anyway. */
   label?: (HelixTabPanel["label"]) | undefined;
 };
 
@@ -12347,6 +13790,11 @@ Automatic is the default because showing a panel is usually cheap. Set this
 where it is not, so a reader arrowing past four tabs does not load four
 panels on the way. */
   manual?: (HelixTabs["manual"]) | undefined;
+  /** The direction the tabs run. `vertical` sets them in a column beside the
+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;
   /** How the row of tabs is drawn.
 
 Unset is a raised pill on the selected tab with nothing behind the row,
@@ -12399,6 +13847,13 @@ declares in markup carries `defaultSelected` of its own to say so. */
   /** The item's value, which identifies it in its set and is what a form
 submits. */
   value?: (HelixTab["value"]) | undefined;
+  /** The URL the tab links to. Setting it renders the tab as a link, for a set
+of tabs that are pages of a site. */
+  href?: (HelixTab["href"]) | undefined;
+  /** The link's `rel`, for a tab with an `href`. */
+  rel?: (HelixTab["rel"]) | undefined;
+  /** Where the link opens, such as `_blank`, for a tab with an `href`. */
+  target?: (HelixTab["target"]) | undefined;
 };
 
 export type HelixTabVueEvents = {
@@ -12406,6 +13861,44 @@ export type HelixTabVueEvents = {
   "helix-select": HelixTabHelixSelectElementEvent;
 };
 
+/** `HelixTagGroup` component event */
+export type HelixTagGroupElementEvent<E = Event> = TypedEvent<HelixTagGroup, E>;
+/** `helix-before-change` event type */
+export type HelixTagGroupHelixBeforeChangeElementEvent =
+  HelixTagGroupElementEvent<HelixBeforeChangeEvent>;
+/** `helix-dismiss` event type */
+export type HelixTagGroupHelixDismissElementEvent =
+  HelixTagGroupElementEvent<HelixDismissEvent>;
+
+export type HelixTagGroupVueProps = {
+  /** The name of the set, such as "Filters", which a screen reader announces
+before its tags. */
+  label?: (HelixTagGroup["label"]) | undefined;
+  /** How many tags a reader can select: `single`, `multiple`, or none.
+
+Absent selects nothing, and the tags carry no selected state at all. */
+  "selection-mode"?: (HelixTagGroup["selectionMode"]) | undefined;
+  /** How many tags a reader can select: `single`, `multiple`, or none.
+
+Absent selects nothing, and the tags carry no selected state at all. */
+  selectionMode?: (HelixTagGroup["selectionMode"]) | undefined;
+  /** The selected tags' values, separated by commas, since a value may hold a
+space.
+
+Set it to start with tags selected. A tag's value is its `value`, or its
+words where it has none. */
+  value?: (HelixTagGroup["value"]) | undefined;
+};
+
+export type HelixTagGroupVueEvents = {
+  /** Fired once a press has changed which tags are selected. */
+  change: HelixTagGroupElementEvent;
+  /** Fired before a press changes which tags are selected, with the `value` it would leave. Cancelable. */
+  "helix-before-change": HelixTagGroupHelixBeforeChangeElementEvent;
+  /** A tag's remove button was pressed, or Delete or Backspace on the focused tag. Bubbles from that tag, which is its `target`; remove the tag in response. Cancelable. */
+  "helix-dismiss": HelixTagGroupHelixDismissElementEvent;
+};
+
 /** `HelixTag` component event */
 export type HelixTagElementEvent<E = Event> = TypedEvent<HelixTag, E>;
 /** `helix-dismiss` event type */
@@ -12456,6 +13949,28 @@ derive one rather than dash-casing it, so this would otherwise be
 reachable only as `dismisslabel`, which nobody would guess and no linter
 would catch. */
   dismissLabel?: (HelixTag["dismissLabel"]) | undefined;
+  /** Takes the tag out of reach: its link and its remove button stop
+answering, and in a `Tag.Group` the arrow keys pass over it and it cannot
+be selected or removed. */
+  disabled?: (HelixTag["disabled"]) | undefined;
+  /** Makes the label a link to this address. */
+  href?: (HelixTag["href"]) | undefined;
+  /** What the tag stands for in its group's `value`.
+
+Absent is the tag's own words, its category first. */
+  value?: (HelixTag["value"]) | undefined;
+  /** Whether the tag holds its group's tab stop.
+
+Written by `Tag.Group` on every tag it holds, and unset outside one, which
+is how a tag knows it is a row. No attribute: it is coordination between
+elements, the same shape `Toggle.focusable` has. */
+  focusable?: (HelixTag["focusable"]) | undefined;
+  /** Whether the tag is selected, in a `Tag.Group` that selects.
+
+Written by the group from its own `value`, and unset where nothing can be
+selected, which is what keeps `aria-selected` off a set that does not
+select. */
+  selected?: (HelixTag["selected"]) | undefined;
 };
 
 export type HelixTagVueEvents = {
@@ -12468,10 +13983,12 @@ export type HelixTextVueProps = {
 
 Decides the outline and the semantics.
 
-**`label` gives the label ramp and labels no control.** The element is in
-this one's shadow root, which neither `for` nor a wrapped control can
-reach, so a page that writes either is warned. Name a Helix field with its
-own `label`, and a native control with `<label data-text="label">`. */
+**`label` is deprecated and no longer listed.** The element is in this
+one's shadow root, which neither `for` nor a wrapped control can reach, so
+it labeled nothing. Written anyway, it still renders a `<label>` in the
+label ramp and warns. Use `variant="label"` for the look, a native
+`<label data-text="label">` to label a native control, and a Helix field's
+own `label`. */
   as?: (HelixText["as"]) | undefined;
   /** Makes the text quieter: `muted`, or the quieter `subtle`.
 
@@ -12488,6 +14005,40 @@ rather than a second one that could not be read.
 
 The resting case is the absent attribute, full strength. */
   emphasis?: (HelixText["emphasis"]) | undefined;
+  /** The most lines to show. Text past the last one is cut off with an
+ellipsis.
+
+Lays the text out as a block, because a line count needs a width to break
+against. The whole text stays in the page, so a screen reader and a search
+still read all of it. Set it as an attribute, such as `lines="1"` for a
+single line. */
+  lines?: (HelixText["lines"]) | undefined;
+  /** How the lines align, set as `text-align`.
+
+Named for the CSS property it sets. `align` alone is a legacy HTML
+attribute the browser maps to `text-align` by itself on any element, and
+it has no `start` or `end`. */
+  "text-align"?: (HelixText["textAlign"]) | undefined;
+  /** How the lines align, set as `text-align`.
+
+Named for the CSS property it sets. `align` alone is a legacy HTML
+attribute the browser maps to `text-align` by itself on any element, and
+it has no `start` or `end`. */
+  textAlign?: (HelixText["textAlign"]) | undefined;
+  /** How the lines break, set as `text-wrap`.
+
+`balance` evens out the length of every line, for a heading of a few
+lines. `pretty` avoids a last line of one short word, for a paragraph.
+`nowrap` keeps the text on one line. Absent, the lines break as the
+browser breaks them. */
+  "text-wrap"?: (HelixText["textWrap"]) | undefined;
+  /** How the lines break, set as `text-wrap`.
+
+`balance` evens out the length of every line, for a heading of a few
+lines. `pretty` avoids a last line of one short word, for a paragraph.
+`nowrap` keeps the text on one line. Absent, the lines break as the
+browser breaks them. */
+  textWrap?: (HelixText["textWrap"]) | undefined;
   /** The meaning of the text, shown by its color, such as `danger` or `success`.
 It is set separately from `variant`.
 
@@ -12596,6 +14147,12 @@ element sends two entries, and that is what this does. */
   maxlength?: (HelixTextarea["maxLength"] | `${number}`) | undefined;
   /** The most characters the value can have. */
   maxLength?: (HelixTextarea["maxLength"]) | undefined;
+  /** How many lines an `auto-grow` field grows to before it scrolls. Absent,
+it grows with all of its text. */
+  "max-rows"?: (HelixTextarea["maxRows"] | `${number}`) | undefined;
+  /** How many lines an `auto-grow` field grows to before it scrolls. Absent,
+it grows with all of its text. */
+  maxRows?: (HelixTextarea["maxRows"]) | undefined;
   /** The fewest characters the value can have.
 
 Forwarded to the real `<textarea>` rather than checked here, which is what
@@ -12695,6 +14252,20 @@ export type HelixTimeInputHelixBeforeOpenElementEvent =
   HelixTimeInputElementEvent<HelixBeforeOpenEvent>;
 
 export type HelixTimeInputVueProps = {
+  /** What a screen reader hears for a segment with nothing in it, which a
+sighted reader sees as dashes. */
+  "empty-segment-label"?: (HelixTimeInput["emptySegmentLabel"]) | undefined;
+  /** What a screen reader hears for a segment with nothing in it, which a
+sighted reader sees as dashes. */
+  emptySegmentLabel?: (HelixTimeInput["emptySegmentLabel"]) | undefined;
+  /** Whether the field is a row of segments, one for each part of the date or
+time, in place of a line of text.
+
+Each segment is set with digits or the arrow keys, in the order the
+locale writes them, so a reader types a date the way they write one and
+no format has to be read back. The picker still opens from the trigger
+and with Alt+Down. */
+  segmented?: (HelixTimeInput["segmented"]) | undefined;
   /** Whether the value is locked. A read-only control still submits its value.
 
 **Enforced by refusing every request in one place**, which is the seam this
@@ -12824,6 +14395,16 @@ a typed time, which is then invalid. */
 Handed to the list, which offers them as unavailable, and checked against
 a typed time, which is then invalid. */
   disableTimes?: (HelixTimeInput["disableTimes"]) | undefined;
+  /** The clock the times are written on: `h12` for twelve hours with a
+meridiem, `h23` for twenty-four. Absent is the locale's own.
+
+Handed to the list. The value is `HH:mm` on twenty-four hours either way. */
+  "hour-cycle"?: (HelixTimeInput["hourCycle"]) | undefined;
+  /** The clock the times are written on: `h12` for twelve hours with a
+meridiem, `h23` for twenty-four. Absent is the locale's own.
+
+Handed to the list. The value is `HH:mm` on twenty-four hours either way. */
+  hourCycle?: (HelixTimeInput["hourCycle"]) | undefined;
   /** Language tag the times are written in.
 
 Absent uses the runtime's own. */
@@ -12875,7 +14456,12 @@ removes rather than as "Remove" said once per time. */
 **The name goes in**, so a row of them is heard as which one each
 removes rather than as "Remove" said once per time. */
   removeLabel?: (HelixTimeInput["removeLabel"]) | undefined;
-  /** How far apart the offered times are, in minutes. */
+  /** Whether times carry their seconds: the value is `HH:mm:ss`, a typed time
+may give them, the field writes them, and the list's `step` counts seconds.
+See Time Picker's `seconds`. */
+  seconds?: (HelixTimeInput["seconds"]) | undefined;
+  /** How far apart the offered times are, in minutes, or in seconds with
+`seconds`. */
   step?: (HelixTimeInput["step"]) | undefined;
   /** Whether the field shows the time in the local style or as the value
 itself.
@@ -13025,6 +14611,20 @@ 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;
+  /** The clock the times are written on: `h12` for twelve hours with a
+meridiem, `h23` for twenty-four.
+
+Absent is the locale's own, which is right for a reader's own form. Set it
+where every reader must see the same clock whatever their language, as a
+timetable does. The value is `HH:mm` on twenty-four hours either way. */
+  "hour-cycle"?: (HelixTimePicker["hourCycle"]) | undefined;
+  /** The clock the times are written on: `h12` for twelve hours with a
+meridiem, `h23` for twenty-four.
+
+Absent is the locale's own, which is right for a reader's own form. Set it
+where every reader must see the same clock whatever their language, as a
+timetable does. The value is `HH:mm` on twenty-four hours either way. */
+  hourCycle?: (HelixTimePicker["hourCycle"]) | undefined;
   /** What the wheel of hours is called, read by screen readers. */
   "hour-label"?: (HelixTimePicker["hourLabel"]) | undefined;
   /** What the wheel of hours is called, read by screen readers. */
@@ -13121,7 +14721,20 @@ else set needs. */
   readOnly?: (HelixTimePicker["readOnly"]) | undefined;
   /** Stops the form from submitting while no time is chosen. */
   required?: (HelixTimePicker["required"]) | undefined;
-  /** How far apart the offered times are, in minutes.
+  /** What the wheel of seconds is called, read by screen readers. */
+  "second-label"?: (HelixTimePicker["secondLabel"]) | undefined;
+  /** What the wheel of seconds is called, read by screen readers. */
+  secondLabel?: (HelixTimePicker["secondLabel"]) | undefined;
+  /** Whether times carry their seconds.
+
+The value becomes `HH:mm:ss`, each time is written with its seconds, the
+wheels take a column of seconds, and `step` counts seconds, the unit
+`<input type="time">` counts in. A list at a step of one second is 86,400
+rows, so give `seconds` a `step` and bounds that keep it a list, or use
+the wheels. */
+  seconds?: (HelixTimePicker["seconds"]) | undefined;
+  /** How far apart the offered times are, in minutes, or in seconds with
+`seconds`.
 
 Fifteen, which is four rows an hour and ninety-six in a day: enough that a
 reader scrolls rather than hunts, and few enough that the list is a list.
@@ -13212,6 +14825,19 @@ export type HelixTimePickerVueEvents = {
   input: HelixTimePickerElementEvent;
 };
 
+export type HelixTimelineGroupVueProps = {
+  /** The level of the group's heading, from 1 to 6. */
+  "heading-level"?: (HelixTimelineGroup["headingLevel"] | `${number}`) | undefined;
+  /** The level of the group's heading, from 1 to 6. */
+  headingLevel?: (HelixTimelineGroup["headingLevel"]) | undefined;
+  /** The heading, when it is plain text, such as "Today".
+
+The fallback of the `heading` slot, so slotted content replaces it. */
+  label?: (HelixTimelineGroup["label"]) | undefined;
+};
+
+export type HelixTimelineGroupVueEvents = {};
+
 export type HelixTimelineItemVueProps = {
   /** When it happened, in machine-readable form. Setting it wraps the time in a
 `<time>` element.
@@ -13227,6 +14853,15 @@ know what instant it names. */
 export type HelixTimelineItemVueEvents = {};
 
 export type HelixTimelineVueProps = {
+  /** Where the entries sit beside the line: `opposite` puts the times on one
+side and what happened on the other, and `alternate` puts every other
+entry on the other side. Unset, the line runs down the start edge.
+
+Down the page only: across the page it is set aside. */
+  layout?: (HelixTimeline["layout"]) | undefined;
+  /** Which way time runs: `horizontal` lays the entries across the page. Unset,
+they run down it. */
+  orientation?: (HelixTimeline["orientation"]) | undefined;
   /** Accessible name for the timeline, for people who reach it out of context. */
   label?: (HelixTimeline["label"]) | undefined;
 };
@@ -13295,7 +14930,11 @@ export type HelixToastHelixDismissElementEvent =
   HelixToastElementEvent<HelixDismissEvent>;
 
 export type HelixToastVueProps = {
-  /** Accessible name for the region, such as "Notifications". */
+  /** The key that takes focus to the stack and back, such as `F8` or `Alt+T`:
+keys joined by `+`, the last one the key. Empty turns it off. */
+  hotkey?: (HelixToast["hotkey"]) | undefined;
+  /** Accessible name for the region, with `{hotkey}` filled in. Translate it with
+the rest of your interface. */
   label?: (HelixToast["label"]) | undefined;
   /** Which corner or edge the stack sits at.
 
@@ -13428,6 +15067,21 @@ reader while looking correct to everybody else. Worse, setting both draws
 it twice. One property moves the label the consumer already has to give,
 and cannot be used to remove it. */
   labelPlacement?: (HelixToggleGroup["labelPlacement"]) | undefined;
+  /** The direction the items run. `vertical` puts them in a column, and the up
+and down arrows move between them.
+
+Optional, so the attribute is absent until a consumer writes it. */
+  orientation?: (HelixToggleGroup["orientation"]) | undefined;
+  /** Whether one item is chosen, as a radio group, or several can be pressed,
+as a toolbar of buttons with `aria-pressed`.
+
+Optional, so the attribute is absent until a consumer writes it. */
+  "selection-mode"?: (HelixToggleGroup["selectionMode"]) | undefined;
+  /** Whether one item is chosen, as a radio group, or several can be pressed,
+as a toolbar of buttons with `aria-pressed`.
+
+Optional, so the attribute is absent until a consumer writes it. */
+  selectionMode?: (HelixToggleGroup["selectionMode"]) | undefined;
   /** Whether the control is disabled and cannot be used.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -13464,6 +15118,10 @@ work as before once focus is in it.
 No attribute: it is coordination between elements, and a consumer has no
 reason to set it. */
   focusable?: (HelixToggleGroup["focusable"]) | undefined;
+  /** The pressed values as a list, under `selection-mode="multiple"`, in the
+order the items are written. Written, it presses exactly those items.
+Where one item is chosen, it is that one value, or none. */
+  values?: (HelixToggleGroup["values"]) | undefined;
 };
 
 export type HelixToggleGroupVueEvents = {
@@ -13531,6 +15189,11 @@ group sits in holds the stop. No attribute: it is coordination between
 elements, and `tabindex` on a host the consumer rendered is the change a
 React consumer's hydration reports and does not patch up. */
   focusable?: (HelixToggle["focusable"]) | undefined;
+  /** Whether the item is pressed, in a group where several can be, and
+`undefined` in a group where one is chosen.
+
+Written by the group, like `selected`, so no attribute. */
+  pressed?: (HelixToggle["pressed"]) | undefined;
 };
 
 export type HelixToggleVueEvents = {
@@ -13546,6 +15209,12 @@ and wins over this. */
   label?: (HelixToolbar["label"]) | undefined;
   /** The direction the arrow keys move focus in. */
   orientation?: (HelixToolbar["orientation"]) | undefined;
+  /** Whether the arrow keys stop at the first and the last control. Unset, they
+wrap around from one end to the other. */
+  "stop-at-ends"?: (HelixToolbar["stopAtEnds"]) | undefined;
+  /** Whether the arrow keys stop at the first and the last control. Unset, they
+wrap around from one end to the other. */
+  stopAtEnds?: (HelixToolbar["stopAtEnds"]) | undefined;
 };
 
 export type HelixToolbarVueEvents = {};
@@ -13675,6 +15344,22 @@ worked. */
 
 It moves if that side does not fit. */
   placement?: (HelixTooltip["placement"]) | undefined;
+  /** What shows the bubble. Unset, it is a pointer resting on the trigger and
+keyboard focus. `focus` is keyboard focus alone, for a hint a pointer does
+not need, such as a shortcut a mouse reader has no use for. */
+  "show-on"?: (HelixTooltip["showOn"]) | undefined;
+  /** What shows the bubble. Unset, it is a pointer resting on the trigger and
+keyboard focus. `focus` is keyboard focus alone, for a hint a pointer does
+not need, such as a shortcut a mouse reader has no use for. */
+  showOn?: (HelixTooltip["showOn"]) | undefined;
+  /** How long after a tooltip hides the next one still shows at once, with no
+`delay`, in milliseconds. The same skip delay Radix uses. Zero makes every
+tooltip wait. */
+  "skip-delay"?: (HelixTooltip["skipDelay"] | `${number}`) | undefined;
+  /** How long after a tooltip hides the next one still shows at once, with no
+`delay`, in milliseconds. The same skip delay Radix uses. Zero makes every
+tooltip wait. */
+  skipDelay?: (HelixTooltip["skipDelay"]) | undefined;
   /** The id of a box to keep the bubble inside. Defaults to the viewport.
 
 Resolved the way `for` is, so an id in the same tree, which is what lets a
@@ -13768,6 +15453,14 @@ The shape is `Carousel`'s, which is the nearest thing in the library: a
   "next-label"?: (HelixTour["nextLabel"]) | undefined;
   /** Label for the control that goes on. */
   nextLabel?: (HelixTour["nextLabel"]) | undefined;
+  /** Draws each stop's place in the run in its panel, as well as saying it. */
+  progress?: (HelixTour["progress"]) | undefined;
+  /** Each stop's place in the run, with `{index}` and `{count}` filled in.
+Translate it with the rest of your text. */
+  "progress-label"?: (HelixTour["progressLabel"]) | undefined;
+  /** Each stop's place in the run, with `{index}` and `{count}` filled in.
+Translate it with the rest of your text. */
+  progressLabel?: (HelixTour["progressLabel"]) | undefined;
   /** Label for the control that leaves the tour. */
   "skip-label"?: (HelixTour["skipLabel"]) | undefined;
   /** Label for the control that leaves the tour. */
@@ -13822,6 +15515,9 @@ closed tour, a closed tour shows nothing, and nothing can disagree. */
   first?: (HelixTourStop["first"]) | undefined;
   /** The id of the element the stop points at. */
   for?: (HelixTourStop["for"]) | undefined;
+  /** The panel's name, where neither the `heading` slot nor the content holds a
+heading. */
+  label?: (HelixTourStop["label"]) | undefined;
   /** Whether the stop is the last one. Its next control then shows `doneLabel`. */
   last?: (HelixTourStop["last"]) | undefined;
   /** Label for the control that goes on. */
@@ -13834,6 +15530,15 @@ closed tour, a closed tour shows nothing, and nothing can disagree. */
   "skip-label"?: (HelixTourStop["skipLabel"]) | undefined;
   /** Label for the control that leaves the tour. */
   skipLabel?: (HelixTourStop["skipLabel"]) | undefined;
+  /** What kind of stop this is. Unset, it is a bubble pointing at its target.
+
+- `dialog`: a panel in the middle of the window, over a backdrop
+- `floating`: a panel in a corner of the window
+- `wait`: nothing shown, while the tour waits for the target to be on the page
+
+Reflected, because the styled tier places a dialog and a floating panel by
+it, and unset at rest, so no default is written onto the host. */
+  type?: (HelixTourStop["type"]) | undefined;
 };
 
 export type HelixTourStopVueEvents = {
@@ -13855,6 +15560,9 @@ export type HelixTreeItemHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixTreeItemHelixBeforeOpenElementEvent =
   HelixTreeItemElementEvent<HelixBeforeOpenEvent>;
+/** `helix-load` event type */
+export type HelixTreeItemHelixLoadElementEvent =
+  HelixTreeItemElementEvent<HelixLoadEvent>;
 
 export type HelixTreeItemVueProps = {
   /** Whether the element starts open. Ignored once `open` is written. */
@@ -13874,12 +15582,20 @@ hydration, or diffed by a framework, it comes back holding whatever the
 last reader did rather than what the author wrote. `:state(open)` carries
 the resolved state for stylesheets, which is what the mirror is for. */
   open?: (HelixTreeItem["open"]) | undefined;
+  /** Whether the item cannot be chosen, opened or followed. The arrow keys still
+reach it, so a reader knows it is there. */
+  disabled?: (HelixTreeItem["disabled"]) | undefined;
   /** The URL this node links to. Setting it makes the row a link.
 
 Unset by default, and unreflected: a tree of choosable nodes is not a tree
 of links, and an empty `href` written onto every row would be a link to the
 current page on every item a consumer never asked to be one. */
   href?: (HelixTreeItem["href"]) | undefined;
+  /** Whether the item is a branch whose children are loaded when it opens.
+
+Opening it sends `helix-load`. Add the children to its `children` slot,
+and remove `lazy` once they are in, as Web Awesome's tree item does. */
+  lazy?: (HelixTreeItem["lazy"]) | undefined;
   /** The link's `rel` value, which describes how the linked page relates to this
 one.
 
@@ -13934,6 +15650,8 @@ export type HelixTreeItemVueEvents = {
   "helix-before-close": HelixTreeItemHelixBeforeCloseElementEvent;
   /** Fired before a branch opens, and cancelable. */
   "helix-before-open": HelixTreeItemHelixBeforeOpenElementEvent;
+  /** Fired when a `lazy` item opens, so you can load its children. */
+  "helix-load": HelixTreeItemHelixLoadElementEvent;
 };
 
 /** `HelixTree` component event */
@@ -14064,6 +15782,19 @@ branch as a label; a headless consumer reads the attribute and the
 written here appears in the served markup of every tree anybody renders.
 The resting state is the absence of the attribute, which is `peer`. */
   nesting?: (HelixTree["nesting"]) | undefined;
+  /** Whether a reader can check many items. Unset, one item is chosen at a
+time.
+
+Optional, so a tree of one choice writes no attribute onto the host. */
+  "selection-mode"?: (HelixTree["selectionMode"]) | undefined;
+  /** Whether a reader can check many items. Unset, one item is chosen at a
+time.
+
+Optional, so a tree of one choice writes no attribute onto the host. */
+  selectionMode?: (HelixTree["selectionMode"]) | undefined;
+  /** The checked values, as a list, under `selection-mode="multiple"`, and the
+chosen value alone otherwise. Writing it sets `active`. */
+  values?: (HelixTree["values"]) | undefined;
 };
 
 export type HelixTreeVueEvents = {
@@ -14193,6 +15924,9 @@ export type HelixVideoPlaylistHelixActivateElementEvent =
 /** `helix-before-activate` event type */
 export type HelixVideoPlaylistHelixBeforeActivateElementEvent =
   HelixVideoPlaylistElementEvent<HelixBeforeActivateEvent>;
+/** `helix-end` event type */
+export type HelixVideoPlaylistHelixEndElementEvent =
+  HelixVideoPlaylistElementEvent<HelixEndEvent>;
 
 export type HelixVideoPlaylistVueProps = {
   /** The `value` of the current item.
@@ -14214,6 +15948,18 @@ Ignored once `active` is written. */
   defaultActive?: (HelixVideoPlaylist["defaultActive"]) | undefined;
   /** The list's name, read by screen readers. */
   label?: (HelixVideoPlaylist["label"]) | 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`.
+
+`all` also lets the next and previous controls go round, so next on the
+last entry is the first. `one` changes only what an ending does: next and
+previous still move, being a reader asking for another entry. */
+  repeat?: (HelixVideoPlaylist["repeat"]) | undefined;
+  /** Whether the entries play in a random order. The order starts from the
+entry that is current, and holds until shuffle is turned off or an entry
+arrives or leaves, so previous goes back through what has played. */
+  shuffle?: (HelixVideoPlaylist["shuffle"]) | undefined;
 };
 
 export type HelixVideoPlaylistVueEvents = {
@@ -14221,6 +15967,8 @@ export type HelixVideoPlaylistVueEvents = {
   "helix-activate": HelixVideoPlaylistHelixActivateElementEvent;
   /** The current entry is about to change. Cancelable: cancel it to keep the current entry. */
   "helix-before-activate": HelixVideoPlaylistHelixBeforeActivateElementEvent;
+  /** The last entry finished playing, and the playlist stopped there. Not sent while `repeat` is set. */
+  "helix-end": HelixVideoPlaylistHelixEndElementEvent;
 };
 
 /** `HelixVideo` component event */
@@ -14266,10 +16014,10 @@ only the departure has to be named. */
   /** Whether the video starts playing on its own. Browsers allow this only while
 it is muted.
 
-Forwarded rather than acted on. Whether an unprompted play is permitted is
-the browser's policy and not this element's, and `play()` already swallows
-the refusal: what follows a refused autoplay is a paused player showing its
-start control, which is the correct thing to be looking at. */
+Forwarded to the video, which decides. Whether an unprompted play is
+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;
   /** The name of the captions control when the video has one track. The control
 turns that track on and off.
@@ -14503,6 +16251,12 @@ bar: two of the same control is worse than either placement. */
   "pip-label"?: (HelixVideo["pipLabel"]) | undefined;
   /** What the control that floats the video over other windows is called. */
   pipLabel?: (HelixVideo["pipLabel"]) | undefined;
+  /** 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. */
+  "player-label"?: (HelixVideo["playerLabel"]) | undefined;
+  /** 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;
   /** 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. */
@@ -14552,6 +16306,14 @@ nothing in it says "press to watch".
 behind a hero, a grid of eight thumbnails, anything where the video is
 decoration rather than something to start.
 
+**It is for the pointer, and the bar's Play is for everyone else.** Both
+play the video, so a keyboard met two stops called "Play" one after the
+other and a screen reader read the same button twice. The large one is out
+of the tab order and hidden from assistive technology while the bar is
+drawn, which is whenever it is: it shows only while the video is not
+playing, and the bar does not fade then. A press on it leaves focus on the
+player, so the keys go on working once it has gone.
+
 A value rather than a boolean, so the resting state is the attribute's
 absence: a boolean defaulting to on would have to be spelled as its own
 negation. */
@@ -14569,6 +16331,14 @@ nothing in it says "press to watch".
 behind a hero, a grid of eight thumbnails, anything where the video is
 decoration rather than something to start.
 
+**It is for the pointer, and the bar's Play is for everyone else.** Both
+play the video, so a keyboard met two stops called "Play" one after the
+other and a screen reader read the same button twice. The large one is out
+of the tab order and hidden from assistive technology while the bar is
+drawn, which is whenever it is: it shows only while the video is not
+playing, and the bar does not fade then. A press on it leaves focus on the
+player, so the keys go on working once it has gone.
+
 A value rather than a boolean, so the resting state is the attribute's
 absence: a boolean defaulting to on would have to be spelled as its own
 negation. */
@@ -14603,25 +16373,78 @@ past the end is the one write the platform answers with an exception. */
 };
 
 export type HelixVideoVueEvents = {
-  /** The video reached its end. Relayed from the inner video, since the native event does not cross the shadow boundary. */
+  /** The media stopped loading before it finished, without an error. */
+  abort: HelixVideoElementEvent;
+  /** Enough has loaded to start playing. */
+  canplay: HelixVideoElementEvent;
+  /** Enough has loaded to play to the end without stopping, at the current rate. */
+  canplaythrough: HelixVideoElementEvent;
+  /** The duration changed, which it does once the metadata is in. */
+  durationchange: HelixVideoElementEvent;
+  /** The media was reset, as when `src` changes. */
+  emptied: HelixVideoElementEvent;
+  /** The video reached its end. */
   ended: HelixVideoElementEvent;
+  /** The source could not be loaded or played. The player shows `error-label` as well. */
+  error: HelixVideoElementEvent;
   /** The next video was requested. Load it in response. */
   "helix-next": HelixVideoHelixNextElementEvent;
   /** The previous video was requested. Load it in response. */
   "helix-previous": HelixVideoHelixPreviousElementEvent;
-  /** Playback paused. Relayed from the inner video. */
+  /** The frame at the current position has loaded. */
+  loadeddata: HelixVideoElementEvent;
+  /** The duration and the size of the video are known. */
+  loadedmetadata: HelixVideoElementEvent;
+  /** The video started looking for its media. */
+  loadstart: HelixVideoElementEvent;
+  /** Playback paused. */
   pause: HelixVideoElementEvent;
-  /** Playback started. Relayed from the inner video. */
+  /** Playback was asked to start. */
   play: HelixVideoElementEvent;
+  /** Playback started, or started again after waiting for data. */
+  playing: HelixVideoElementEvent;
+  /** More of the media has downloaded. */
+  progress: HelixVideoElementEvent;
+  /** The playback rate changed. Read `playbackRate`. */
+  ratechange: HelixVideoElementEvent;
+  /** The video's own width or height changed. Read `videoWidth` and `videoHeight`. */
+  resize: HelixVideoElementEvent;
+  /** A move to a new position finished. */
+  seeked: HelixVideoElementEvent;
+  /** A move to a new position started. */
+  seeking: HelixVideoElementEvent;
+  /** The browser is trying to load more data and none is arriving. */
+  stalled: HelixVideoElementEvent;
+  /** Loading paused on purpose, as when `preload` asks for no more. */
+  suspend: HelixVideoElementEvent;
+  /** The position changed. Read `currentTime`. */
+  timeupdate: HelixVideoElementEvent;
+  /** The volume or the mute changed. Read `volume` and `muted`. */
+  volumechange: HelixVideoElementEvent;
+  /** Playback stopped to wait for more data. */
+  waiting: HelixVideoElementEvent;
 };
 
+/** `HelixVirtualList` component event */
+export type HelixVirtualListElementEvent<E = Event> = TypedEvent<
+  HelixVirtualList,
+  E
+>;
+/** `helix-load-more` event type */
+export type HelixVirtualListHelixLoadMoreElementEvent =
+  HelixVirtualListElementEvent<HelixLoadMoreEvent>;
+/** `helix-range-change` event type */
+export type HelixVirtualListHelixRangeChangeElementEvent =
+  HelixVirtualListElementEvent<HelixRangeChangeEvent>;
+
 export type HelixVirtualListVueProps = {
   /** The height of one row, in pixels, used to find the row at a scroll offset.
 
 An estimate rather than a measurement while `measured` is off, which is
 right whenever the rows really are one height and is the cheaper of the two. */
   estimate?: (HelixVirtualList["estimate"]) | undefined;
-  /** The id of the script element that holds the rows as JSON. */
+  /** The id of the script element that holds the items as JSON. `items` wins
+where both are set. */
   for?: (HelixVirtualList["for"]) | undefined;
   /** The list's name, read by screen readers, because only some of its rows
 are rendered at a time.
@@ -14638,9 +16461,27 @@ disagree with itself; measuring is what a set of genuinely different
 heights needs and costs a read of each row as it renders. A list of
 one-line rows should leave this alone. */
   measured?: (HelixVirtualList["measured"]) | undefined;
+  /** The items, as an array. Set it as a property.
+
+Each item is drawn by `renderItem`, or into the row `<template>` by its
+fields. A new array draws the new rows, so replace the array to change it.
+Left unset, the list reads the script that `for` names. */
+  items?: (HelixVirtualList["items"]) | undefined;
+  /** Draws one item into its row, given the item and its index. Set it as a
+property.
+
+It returns what Lit renders: a template from `html`, a string, or a DOM
+node. The list wraps each result in a `<div>` that carries the row's role
+and place in the set. Where it is unset, the row `<template>` is used. */
+  renderItem?: (HelixVirtualList["renderItem"]) | undefined;
 };
 
-export type HelixVirtualListVueEvents = {};
+export type HelixVirtualListVueEvents = {
+  /** Fired when a reader comes within one screen of the last item, once for each length of the set. */
+  "helix-load-more": HelixVirtualListHelixLoadMoreElementEvent;
+  /** Fired when the items on screen change, with the new `first` and `last`, which `range` also holds. */
+  "helix-range-change": HelixVirtualListHelixRangeChangeElementEvent;
+};
 
 export type CustomCssProperties = {
   /** The padding of the trigger and the content. */
@@ -14683,6 +16524,14 @@ export type CustomCssProperties = {
   "--area-chart-width"?: (string) | undefined;
   /** Thickness of a band's top edge. Area Chart, Line Chart, and Bar Chart's `lines` all read this one property. `--area-chart-width` overrides it here. */
   "--chart-stroke"?: (string) | undefined;
+  /** The bright stop of the ramp. Defaults to `--helix-color-primary`. */
+  "--aura-glow"?: (string) | undefined;
+  /** The page the field fades into. Defaults to `--helix-color-background`. */
+  "--aura-ground"?: (string) | undefined;
+  /** The faint stop between the ground and the glow. Defaults to `--helix-color-primary-subtle`. */
+  "--aura-haze"?: (string) | undefined;
+  /** The hottest stop, at the center of a shape. Defaults to `--helix-color-primary-active` on a light page and `--helix-color-foreground` on a dark one. */
+  "--aura-peak"?: (string) | undefined;
   /** How far each avatar sits over the one before it. */
   "--avatar-group-overlap"?: (string) | undefined;
   /** Color of the ring that separates one avatar from the next. */
@@ -14695,6 +16544,8 @@ export type CustomCssProperties = {
   "--badge-background-color"?: (string) | undefined;
   /** The color of the count, to pair with a fill set through `--badge-background-color`. */
   "--badge-color"?: (string) | undefined;
+  /** The space between the content and the count under `placement="inline"`. */
+  "--badge-gap"?: (string) | undefined;
   /** Pulls the mark in from the corner, along both axes. */
   "--badge-offset"?: (string) | undefined;
   /** The color of the ring between the indicator and what is behind it. */
@@ -14721,16 +16572,36 @@ export type CustomCssProperties = {
   "--bar-chart-secondary"?: (string) | undefined;
   /** The gradient for a bar, named per bar so the styled tier can use it as the `fill`. It is always drawn, and used only when `wash="gradient"` is set. */
   "--chart-bar-wash"?: (string) | undefined;
+  /** The color of the attribution. */
+  "--blockquote-attribution-color"?: (string) | undefined;
+  /** The font size of the attribution. */
+  "--blockquote-attribution-size"?: (string) | undefined;
+  /** The color of the quoted passage. */
+  "--blockquote-color"?: (string) | undefined;
+  /** The typeface of the quoted passage, the display face by default. */
+  "--blockquote-font-family"?: (string) | undefined;
+  /** The space between the passage and its attribution. */
+  "--blockquote-gap"?: (string) | undefined;
   /** The font size of the quoted passage. */
   "--blockquote-size"?: (string) | undefined;
   /** Inline padding of a control slotted into a crumb, matching the steps either side of it. */
   "--breadcrumbs-control-padding-inline"?: (string) | undefined;
   /** How tall a control slotted into a crumb is. */
   "--breadcrumbs-control-size"?: (string) | undefined;
+  /** Text color of the current page's crumb. */
+  "--breadcrumbs-current-color"?: (string) | undefined;
+  /** Weight of every crumb's text. */
+  "--breadcrumbs-font-weight"?: (string) | undefined;
   /** Fill behind a step under the pointer. */
   "--breadcrumbs-hover-color"?: (string) | undefined;
+  /** Text color of a crumb that is not the current page. A link you slot inherits it unless your own styles set a color. */
+  "--breadcrumbs-link-color"?: (string) | undefined;
+  /** Corner radius of the fill behind a step under the pointer. */
+  "--breadcrumbs-radius"?: (string) | undefined;
   /** Color of the chevron. */
   "--breadcrumbs-separator-color"?: (string) | undefined;
+  /** Size of the trail's text. */
+  "--breadcrumbs-font-size"?: (string) | undefined;
   /** Space between items and separators. */
   "--breadcrumbs-gap"?: (string) | undefined;
   /** Space between the buttons, when `spaced`. */
@@ -14739,6 +16610,8 @@ export type CustomCssProperties = {
   "--button-background-color"?: (string) | undefined;
   /** Fill behind the button under the pointer. Without it, `--button-background-color` also applies on hover. */
   "--button-background-color-hover"?: (string) | undefined;
+  /** Edge color of an outlined button. The other emphases draw no edge. */
+  "--button-border-color"?: (string) | undefined;
   /** Label and icon color. */
   "--button-foreground-color"?: (string) | undefined;
   /** Space between the label and the content on either side of it. */
@@ -14763,8 +16636,20 @@ export type CustomCssProperties = {
   "--button-radius-start-start"?: (string) | undefined;
   /** Height of the control, for a row height outside the density steps. */
   "--button-size"?: (string) | undefined;
+  /** Size of the ring a pending button turns. Defaults to the size of its icons. */
+  "--button-spinner-size"?: (string) | undefined;
+  /** The color of the bar, the mark and the tint, in place of the tone's. */
+  "--callout-accent-color"?: (string) | undefined;
   /** The fill behind the callout. */
   "--callout-background-color"?: (string) | undefined;
+  /** The thickness of the bar on the inline start edge. */
+  "--callout-bar-thickness"?: (string) | undefined;
+  /** The size of the callout's text. */
+  "--callout-font-size"?: (string) | undefined;
+  /** The space between the mark and the content. */
+  "--callout-gap"?: (string) | undefined;
+  /** The inset around the content, to which the bar's width is added at the start. */
+  "--callout-padding"?: (string) | undefined;
   /** The corner radius of the callout. */
   "--callout-radius"?: (string) | undefined;
   /** The size of the corner handles that resize a selected card. */
@@ -14811,6 +16696,8 @@ export type CustomCssProperties = {
   "--card-border-color"?: (string) | undefined;
   /** Width of the surface's edge. Follows `--helix-border-surface`, which is a hairline unless your theme sets another width. The edge is what sets the surface apart. */
   "--card-border-width"?: (string) | undefined;
+  /** Space between the regions, and between a header or footer and its actions. */
+  "--card-gap"?: (string) | undefined;
   /** Height of the media region. Defaults to `auto`, which follows an image's own proportions. A chart has no height of its own, so set one here for a chart. */
   "--card-media-block-size"?: (string) | undefined;
   /** Width of the media column when horizontal. */
@@ -14889,8 +16776,12 @@ export type CustomCssProperties = {
   "--code-block-background-color"?: (string) | undefined;
   /** The line around the block and its header. */
   "--code-block-border-color"?: (string) | undefined;
+  /** The color of the line numbers. */
+  "--code-block-gutter-color"?: (string) | undefined;
   /** The background behind the name. The default is `surface-raised`. */
   "--code-block-header-background-color"?: (string) | undefined;
+  /** The tallest the code grows before it scrolls. The default is no limit. */
+  "--code-block-max-block-size"?: (string) | undefined;
   /** The corner radius of the header's top and the block's bottom, which form one shape. */
   "--code-block-radius"?: (string) | undefined;
   /** Fill behind the fragment. Defaults to the foreground color at 6%, which looks the same on a light page and a dark one. */
@@ -14917,6 +16808,10 @@ export type CustomCssProperties = {
   "--color-input-swatch-size"?: (string) | undefined;
   /** The chosen color, painted over the checkerboard that shows transparency. */
   "--color-input-swatch"?: (string) | undefined;
+  /** The color of the names above the channel number fields, in `channel-fields`. */
+  "--color-picker-field-label-color"?: (string) | undefined;
+  /** The space between the channel number fields, in `channel-fields`. */
+  "--color-picker-fields-gap"?: (string) | undefined;
   /** The corner radius of the square. */
   "--color-picker-grid-radius"?: (string) | undefined;
   /** The aspect ratio of the square. */
@@ -14963,6 +16858,8 @@ export type CustomCssProperties = {
   "--icon-button-shadow"?: (string) | undefined;
   /** Edge length of the control. */
   "--icon-button-size"?: (string) | undefined;
+  /** Size of the ring a pending button turns. */
+  "--icon-button-spinner-size"?: (string) | undefined;
   /** The height of the scrolling box while `windowed`. Ignored otherwise, where the grid is as tall as its rows. It is a fixed height, so a short result keeps the full box with space below it. */
   "--data-table-block-size"?: (string) | undefined;
   /** The text color of a cell. */
@@ -14973,6 +16870,8 @@ export type CustomCssProperties = {
   "--data-table-heading-background-color"?: (string) | undefined;
   /** The text color of a heading. */
   "--data-table-heading-color"?: (string) | undefined;
+  /** How far a tree grid's row header steps in for each level. It defaults to the width of the mark that opens a row. */
+  "--data-table-indent"?: (string) | undefined;
   /** The space above and below a cell's content. */
   "--data-table-padding-block"?: (string) | undefined;
   /** The space on either side of a cell's content. */
@@ -14983,6 +16882,8 @@ export type CustomCssProperties = {
   "--data-table-text"?: (string) | undefined;
   /** The alignment of the cell's column: `start`, `center`, or `end`. Unset when the column sets none. The component writes it on each cell it draws, and the stylesheet reads it. `Table` sets `--table-cell-align` for the same purpose. */
   "--data-table-cell-align"?: (string) | undefined;
+  /** How deep a row is in a tree grid, from 1. The component writes it on each row header cell, and the stylesheet indents by it. */
+  "--data-table-level"?: (string) | undefined;
   /** The column track list, worked out from the columns. The component writes it inline on the element that reads it, so setting it has no effect. Set a column's `width` to change it. */
   "--data-table-template"?: (string) | undefined;
   /** The fill behind the field. */
@@ -14991,12 +16892,22 @@ export type CustomCssProperties = {
   "--date-input-border-color"?: (string) | undefined;
   /** The width of the panel's border. It follows `--helix-border-floating`, which is `0`, so the panel stands out by its shadow unless a theme sets a border. */
   "--date-input-border-width"?: (string) | undefined;
+  /** The fill behind the segment with focus, in `segmented`. It follows `--helix-color-primary`. */
+  "--date-input-segment-focus-background-color"?: (string) | undefined;
+  /** The text of the segment with focus, in `segmented`. */
+  "--date-input-segment-focus-color"?: (string) | undefined;
+  /** The text the locale writes between two segments, in `segmented`. */
+  "--date-input-segment-literal-color"?: (string) | undefined;
+  /** The dashes of a segment with nothing in it, in `segmented`. It matches the text field's placeholder. */
+  "--date-input-segment-placeholder-color"?: (string) | undefined;
   /** The shadow under the panel. It follows `--helix-shadow-floating`. The panel can sit over any content, so it has a shadow by default. */
   "--date-input-shadow"?: (string) | undefined;
   /** Months per row. Two unless there is only one. */
   "--date-picker-columns"?: (string) | undefined;
   /** Width and height of a day. */
   "--date-picker-day-size"?: (string) | undefined;
+  /** Height of a month or a year in the months and years views, where `max-view` is set. */
+  "--date-picker-period-size"?: (string) | undefined;
   /** Band behind the days in a range. */
   "--date-picker-range-color"?: (string) | undefined;
   /** Height of a week row. */
@@ -15027,6 +16938,12 @@ export type CustomCssProperties = {
   "--dialog-shadow"?: (string) | undefined;
   /** The color of the line. */
   "--divider-color"?: (string) | undefined;
+  /** The color of the content set into the line. */
+  "--divider-content-color"?: (string) | undefined;
+  /** The space either side of the content set into the line. */
+  "--divider-content-gap"?: (string) | undefined;
+  /** The length of line before the content under `content-placement="start"`, or after it under `end`. */
+  "--divider-content-offset"?: (string) | undefined;
   /** The length of a vertical line. A horizontal line takes the divider's width. */
   "--divider-length"?: (string) | undefined;
   /** The space removed from both ends of the line. */
@@ -15065,12 +16982,34 @@ export type CustomCssProperties = {
   "--drawer-shadow"?: (string) | undefined;
   /** Width or height of the panel. */
   "--drawer-size"?: (string) | undefined;
+  /** How far a swipe, or a snap point, has moved the panel across, in pixels, toward the right. */
+  "--drawer-swipe-x"?: (string) | undefined;
+  /** How far a swipe, or a snap point, has moved the panel down, in pixels. */
+  "--drawer-swipe-y"?: (string) | undefined;
   /** Fill when a row is under the pointer. */
   "--drilldown-item-hover-color"?: (string) | undefined;
   /** Fill behind the pages. */
   "--drilldown-background-color"?: (string) | undefined;
   /** Width of the region. */
   "--drilldown-inline-size"?: (string) | undefined;
+  /** Space added above the actions. */
+  "--empty-actions-gap"?: (string) | undefined;
+  /** Space between the icon, the heading, the message and the actions. */
+  "--empty-gap"?: (string) | undefined;
+  /** Color of the heading. */
+  "--empty-heading-color"?: (string) | undefined;
+  /** Size of the heading. */
+  "--empty-heading-size"?: (string) | undefined;
+  /** Color of the icon. */
+  "--empty-icon-color"?: (string) | undefined;
+  /** Size of the icon. */
+  "--empty-icon-size"?: (string) | undefined;
+  /** Color of the message. */
+  "--empty-message-color"?: (string) | undefined;
+  /** Widest the message runs before it wraps. */
+  "--empty-message-measure"?: (string) | undefined;
+  /** Size of the message. */
+  "--empty-message-size"?: (string) | undefined;
   /** Space around the whole block. */
   "--empty-padding"?: (string) | undefined;
   /** Fill behind the field. */
@@ -15103,6 +17042,10 @@ export type CustomCssProperties = {
   "--filter-input-shadow"?: (string) | undefined;
   /** The height of the empty field. The field grows from this height. */
   "--filter-input-size"?: (string) | undefined;
+  /** The narrowest the growing item of a `flank` layout gets before the two stack, as a share of the row. Defaults to `50%`. */
+  "--flex-flank-min"?: (string) | undefined;
+  /** The width of the fixed item of a `flank` layout. Defaults to its own width. */
+  "--flex-flank-size"?: (string) | undefined;
   /** The color behind the drawing while it loads. */
   "--graph-background-color"?: (string) | undefined;
   /** The frame's height, as a length. */
@@ -15111,8 +17054,12 @@ export type CustomCssProperties = {
   "--graph-border-color"?: (string) | undefined;
   /** The list's width beside the drawing, or over it when opened with `no-panel`. */
   "--graph-panel-size"?: (string) | undefined;
+  /** The named areas, as `grid-template-areas` takes them, such as `"rail main"`. A child takes its area with `grid-area`. */
+  "--grid-areas"?: (string) | undefined;
   /** An explicit track list. It overrides `min` and `columns`. Use it for tracks of unequal widths, which neither attribute can set. */
   "--grid-columns"?: (string) | undefined;
+  /** An explicit row track list, such as `auto minmax(0, 1fr) auto`. Rows are sized by their content when it is unset. */
+  "--grid-rows"?: (string) | undefined;
   /** How tall a cell is. One row of tall, narrow cells looks like a status page. */
   "--heatmap-cell-height"?: (string) | undefined;
   /** How wide a cell is. The strip fits as many as the container allows. */
@@ -15165,6 +17112,12 @@ export type CustomCssProperties = {
   "--image-radius"?: (string) | undefined;
   /** Fill behind the text. */
   "--input-background-color"?: (string) | undefined;
+  /** Edge of the field at rest. Hover, focus and an error still draw their own. */
+  "--input-border-color"?: (string) | undefined;
+  /** Space between the edge of the field and what is inside it. */
+  "--input-padding-inline"?: (string) | undefined;
+  /** Corner radius of the field. */
+  "--input-radius"?: (string) | undefined;
   /** Height of the field. */
   "--input-size"?: (string) | undefined;
   /** The fill of the key. */
@@ -15173,8 +17126,14 @@ export type CustomCssProperties = {
   "--kbd-border-color"?: (string) | undefined;
   /** The direction the entries run: `row`, which wraps, or `column`. */
   "--legend-direction"?: (string) | undefined;
+  /** The space between a swatch and its name. */
+  "--legend-entry-gap"?: (string) | undefined;
   /** The space between entries. */
   "--legend-gap"?: (string) | undefined;
+  /** How strongly a hidden series' entry is drawn, under `toggles`. */
+  "--legend-hidden-opacity"?: (string) | undefined;
+  /** The corner of the color swatch. */
+  "--legend-swatch-radius"?: (string) | undefined;
   /** The size of the color swatch. */
   "--legend-swatch-size"?: (string) | undefined;
   /** The width of the edge an `outlined` or `subtle` swatch is drawn with. */
@@ -15183,6 +17142,8 @@ export type CustomCssProperties = {
   "--lightbox-item-description-color"?: (string) | undefined;
   /** Space between the content and the line under it. */
   "--lightbox-item-gap"?: (string) | undefined;
+  /** Size of the previous, next and close controls drawn with `controls`. */
+  "--lightbox-control-size"?: (string) | undefined;
   /** Color of the controls and text drawn over the content. */
   "--lightbox-foreground"?: (string) | undefined;
   /** Space between the header or footer and the content. */
@@ -15211,12 +17172,18 @@ export type CustomCssProperties = {
   "--chart-terminus-x"?: (string) | undefined;
   /** Where a series' last reading sits vertically, as a percentage. Written by the component. */
   "--chart-terminus-y"?: (string) | undefined;
+  /** The fill behind a row that is `current`. */
+  "--list-item-current-background-color"?: (string) | undefined;
+  /** The opacity of a `disabled` row. */
+  "--list-item-disabled-opacity"?: (string) | undefined;
   /** The padding inside the row. */
   "--list-item-padding"?: (string) | undefined;
   /** What the rail cell shows. The list sets it. */
   "--list-item-rail-content"?: (string) | undefined;
   /** Whether the row has a rail. The list sets it. */
   "--list-item-rail-display"?: (string) | undefined;
+  /** The fill behind a selected row, in a list that selects. */
+  "--list-item-selected-background-color"?: (string) | undefined;
   /** The font weight of a term in a description list. */
   "--list-item-term-weight"?: (string) | undefined;
   /** The space between rows. */
@@ -15227,6 +17194,10 @@ export type CustomCssProperties = {
   "--list-rail-inline-size"?: (string) | undefined;
   /** The counter style of the rail's numbers. Takes any `list-style-type`. */
   "--list-rail-style"?: (string) | undefined;
+  /** The number of the first row, written where `start` or `reversed` moves it. */
+  "--list-first"?: (string) | undefined;
+  /** What each row adds to the number before it: `1`, or `-1` where `reversed`. */
+  "--list-step"?: (string) | undefined;
   /** The panel's fill. Set it to `transparent` when the list is already inside a panel. */
   "--listbox-background-color"?: (string) | undefined;
   /** The panel's border, as a shorthand. Set it to `none` when the list is already inside a panel. */
@@ -15307,6 +17278,8 @@ export type CustomCssProperties = {
   "--megamenu-size"?: (string) | undefined;
   /** Where the panel starts, measured from the bar above it. */
   "--megamenu-top"?: (string) | undefined;
+  /** Color of the shortcut and the words in the `end` slot. */
+  "--menu-item-detail-color"?: (string) | undefined;
   /** Width of the trailing column, including the gap before it, which holds a check mark or a submenu caret. */
   "--menu-item-end"?: (string) | undefined;
   /** Fill under the pointer. */
@@ -15325,8 +17298,16 @@ export type CustomCssProperties = {
   "--menu-min-inline-size"?: (string) | undefined;
   /** Shadow under the panel. Defaults to `--helix-shadow-floating`, so the panel keeps a shadow over any content below it. */
   "--menu-shadow"?: (string) | undefined;
+  /** Color of the heading. */
+  "--menu-section-heading-color"?: (string) | undefined;
   /** The fill color. Overrides the band's tone. */
   "--meter-color"?: (string) | undefined;
+  /** The color of a slotted label. */
+  "--meter-label-color"?: (string) | undefined;
+  /** The space between a slotted label and the meter. */
+  "--meter-label-gap"?: (string) | undefined;
+  /** The type size of a slotted label. */
+  "--meter-label-size"?: (string) | undefined;
   /** The width and height of the drawing in `ring` and `arc`. */
   "--meter-ring-size"?: (string) | undefined;
   /** The thickness of the stroke in `ring` and `arc`. */
@@ -15345,10 +17326,20 @@ export type CustomCssProperties = {
   "--meter-fraction"?: (string) | undefined;
   /** How much of the circle the arc covers, as a path length. */
   "--meter-sweep"?: (string) | undefined;
+  /** Height of the bar in a row. Each destination fills it. */
+  "--navigation-block-size"?: (string) | undefined;
   /** Space between destinations. */
   "--navigation-gap"?: (string) | undefined;
   /** Fill of the marker on the current destination. */
   "--navigation-indicator-color"?: (string) | undefined;
+  /** Corner radius of the marker. */
+  "--navigation-indicator-radius"?: (string) | undefined;
+  /** Shadow under the marker, for a marker that sits raised on the bar. */
+  "--navigation-indicator-shadow"?: (string) | undefined;
+  /** Text color of a destination that is not the current one. Read by the page's stylesheet, which styles the links you slot. */
+  "--navigation-item-color"?: (string) | undefined;
+  /** Text color of the current destination, the one marked `aria-current="page"`. */
+  "--navigation-item-current-color"?: (string) | undefined;
   /** Text color in a read item. */
   "--notifications-color"?: (string) | undefined;
   /** Color of the dismiss control. It is `danger`, because dismissing an item removes it for good. */
@@ -15385,6 +17376,12 @@ export type CustomCssProperties = {
   "--notifications-media-column"?: (string) | undefined;
   /** The fill behind the number. */
   "--number-input-background-color"?: (string) | undefined;
+  /** Edge of the field at rest. Hover, focus and an error still draw their own. */
+  "--number-input-border-color"?: (string) | undefined;
+  /** Corner radius of the field. */
+  "--number-input-radius"?: (string) | undefined;
+  /** Height of the field. */
+  "--number-input-size"?: (string) | undefined;
   /** The background of the tree. */
   "--object-inspector-background-color"?: (string) | undefined;
   /** The height of the scrolling box when `windowed` is set. */
@@ -15393,6 +17390,8 @@ export type CustomCssProperties = {
   "--object-inspector-border-color"?: (string) | undefined;
   /** The background of the bar that holds the label. */
   "--object-inspector-header-background-color"?: (string) | undefined;
+  /** The background of an entry a filter matched. */
+  "--object-inspector-match-background-color"?: (string) | undefined;
   /** The corner radius of the tree. */
   "--object-inspector-radius"?: (string) | undefined;
   /** How deep a row is, from 0 at the root, for indenting it. */
@@ -15423,8 +17422,18 @@ export type CustomCssProperties = {
   "--pagination-hover-color"?: (string) | undefined;
   /** The box every control in the row takes. */
   "--pagination-size"?: (string) | undefined;
+  /** Fill behind each box. */
+  "--pin-input-cell-background-color"?: (string) | undefined;
+  /** Edge of each box at rest. Hover, focus and an error still draw their own. */
+  "--pin-input-cell-border-color"?: (string) | undefined;
+  /** Corner radius of each box. */
+  "--pin-input-cell-radius"?: (string) | undefined;
+  /** Width and height of each box. */
+  "--pin-input-cell-size"?: (string) | undefined;
   /** The space between one box and the next. */
   "--pin-input-gap"?: (string) | undefined;
+  /** Size of the point drawn with `arrow`. Tooltip's point is the same size. */
+  "--popover-arrow-size"?: (string) | undefined;
   /** Color of the panel's edge. */
   "--popover-border-color"?: (string) | undefined;
   /** Width of the panel's edge. Defaults to `--helix-border-floating`, which is `0`, so the panel stands out by its shadow unless your theme sets a width. */
@@ -15439,6 +17448,12 @@ export type CustomCssProperties = {
   "--popover-shadow"?: (string) | undefined;
   /** Fill of the part that is done. */
   "--progress-color"?: (string) | undefined;
+  /** Color of a slotted label. */
+  "--progress-label-color"?: (string) | undefined;
+  /** Space between a slotted label and the bar. */
+  "--progress-label-gap"?: (string) | undefined;
+  /** Type size of a slotted label. */
+  "--progress-label-size"?: (string) | undefined;
   /** Diameter of the ring. */
   "--progress-ring-size"?: (string) | undefined;
   /** Thickness of the ring's stroke. */
@@ -15463,6 +17478,8 @@ export type CustomCssProperties = {
   "--qr-code-size"?: (string) | undefined;
   /** Color of the quoted text. */
   "--quote-color"?: (string) | undefined;
+  /** The slant of the quoted text, `italic` by default. Set `normal` for a face whose italic is too loud, or `oblique` for one with no italic of its own. */
+  "--quote-font-style"?: (string) | undefined;
   /** The space between the choices. */
   "--radio-group-gap"?: (string) | undefined;
   /** The fill of an unselected circle. */
@@ -15549,10 +17566,20 @@ export type CustomCssProperties = {
   "--scroll-area-fade-inline-start"?: (string) | undefined;
   /** The scrollbar width, as a `scrollbar-width` keyword. */
   "--scroll-area-scrollbar"?: (string) | undefined;
+  /** The thickness of each scrollbar drawn under `scrollbars`, and the size of the corner. */
+  "--scroll-area-scrollbar-size"?: (string) | undefined;
   /** The color of the scrollbar's thumb. */
   "--scroll-area-thumb-color"?: (string) | undefined;
+  /** The color of a thumb drawn under `scrollbars` while the pointer is over it. */
+  "--scroll-area-thumb-hover-color"?: (string) | undefined;
+  /** The shortest a thumb drawn under `scrollbars` gets, however long the content. */
+  "--scroll-area-thumb-min-size"?: (string) | undefined;
   /** The color of the scrollbar's track. */
   "--scroll-area-track-color"?: (string) | undefined;
+  /** How far along its axis the content is scrolled, from 0 at the start to 1 at the end. Written on each `scrollbar` part, so its thumb inherits it. Counted from the right on a right-to-left page. */
+  "--scroll-area-scroll-fraction"?: (string) | undefined;
+  /** The share of the track the thumb covers, from 0 to 1, which is how much of the content is in view. Written on each `scrollbar` part. */
+  "--scroll-area-thumb-fraction"?: (string) | undefined;
   /** Color of the panel's edge. */
   "--select-border-color"?: (string) | undefined;
   /** Width of the panel's edge. Defaults to `--helix-border-floating`, which is `0`, so the panel stands out by its shadow unless your theme sets a width. */
@@ -15563,12 +17590,36 @@ export type CustomCssProperties = {
   "--select-surface-max-block-size"?: (string) | undefined;
   /** The height of the block shape, which is the shape when `shape` is unset. Defaults to the control height. */
   "--skeleton-block-size"?: (string) | undefined;
+  /** The placeholder's fill. */
+  "--skeleton-color"?: (string) | undefined;
+  /** How long one sweep or one pulse takes. */
+  "--skeleton-duration"?: (string) | undefined;
+  /** The corner of the block shape. */
+  "--skeleton-radius"?: (string) | undefined;
+  /** The highlight the sweep carries across the fill. */
+  "--skeleton-sheen-color"?: (string) | undefined;
   /** The diameter of the circle shape. */
   "--skeleton-size"?: (string) | undefined;
+  /** The background of the link while it is shown. */
+  "--skip-link-background-color"?: (string) | undefined;
   /** The border color of the link while it is shown. */
   "--skip-link-border-color"?: (string) | undefined;
   /** The border width of the link while it is shown. Follows `--helix-border-floating`, which is `0`, so the link is set apart by its shadow unless a theme sets a border. */
   "--skip-link-border-width"?: (string) | undefined;
+  /** The text color of the link while it is shown. */
+  "--skip-link-color"?: (string) | undefined;
+  /** The size of the link's text. */
+  "--skip-link-font-size"?: (string) | undefined;
+  /** How far the shown link sits from the top of the viewport. */
+  "--skip-link-inset-block"?: (string) | undefined;
+  /** How far the shown link sits from the start edge of the viewport. */
+  "--skip-link-inset-inline"?: (string) | undefined;
+  /** The space above and below the link's text. */
+  "--skip-link-padding-block"?: (string) | undefined;
+  /** The space either side of the link's text. */
+  "--skip-link-padding-inline"?: (string) | undefined;
+  /** The corner radius of the link. */
+  "--skip-link-radius"?: (string) | undefined;
   /** The shadow under the link while it is shown. Follows `--helix-shadow-floating`, because the link sits over the corner of the page. */
   "--skip-link-shadow"?: (string) | undefined;
   /** The color of the filled part of the track, behind the thumb. */
@@ -15615,10 +17666,22 @@ export type CustomCssProperties = {
   "--sparkline-inline-size"?: (string) | undefined;
   /** Thickness of the line, overriding `weight`. */
   "--sparkline-width"?: (string) | undefined;
+  /** Fill of the round icon. */
+  "--speed-dial-item-background-color"?: (string) | undefined;
+  /** Color of the icon. */
+  "--speed-dial-item-color"?: (string) | undefined;
   /** Edge length of the icon. */
   "--speed-dial-item-size"?: (string) | undefined;
+  /** Fill of the chip holding the action's name. */
+  "--speed-dial-label-background-color"?: (string) | undefined;
+  /** Color of the action's name. */
+  "--speed-dial-label-color"?: (string) | undefined;
   /** Space between the actions. */
   "--speed-dial-gap"?: (string) | undefined;
+  /** The wait between one action arriving and the next. */
+  "--speed-dial-stagger"?: (string) | undefined;
+  /** How far each action moves as it arrives. */
+  "--speed-dial-travel"?: (string) | undefined;
   /** Color of the line between the panes. */
   "--splitter-color"?: (string) | undefined;
   /** Width of the handle where two dividers cross. */
@@ -15641,6 +17704,18 @@ export type CustomCssProperties = {
   "--stat-group-columns"?: (string) | undefined;
   /** Space between figures. */
   "--stat-group-gap"?: (string) | undefined;
+  /** Space between the label and the value, and between the value and the unit in a row. */
+  "--stat-gap"?: (string) | undefined;
+  /** Color of the label. */
+  "--stat-label-color"?: (string) | undefined;
+  /** Size of the label. */
+  "--stat-label-size"?: (string) | undefined;
+  /** Color of the unit. */
+  "--stat-unit-color"?: (string) | undefined;
+  /** Size of the unit. */
+  "--stat-unit-size"?: (string) | undefined;
+  /** Color of the figure. */
+  "--stat-value-color"?: (string) | undefined;
   /** Size of the figure. */
   "--stat-value-size"?: (string) | undefined;
   /** Color of the mark on a finished step. */
@@ -15657,6 +17732,8 @@ export type CustomCssProperties = {
   "--steps-marker-size"?: (string) | undefined;
   /** Height of the track. The width follows it. */
   "--switch-block-size"?: (string) | undefined;
+  /** Color of the icon on the thumb. Without it, the icon is muted while off and takes the on color while on. */
+  "--switch-icon-color"?: (string) | undefined;
   /** Length of the track. Set it to override the length derived from the height. */
   "--switch-inline-size"?: (string) | undefined;
   /** Fill when the switch is on. */
@@ -15667,6 +17744,12 @@ export type CustomCssProperties = {
   "--table-cell-align"?: (string) | undefined;
   /** Track list for the columns. It overrides the track list worked out from the columns. */
   "--table-columns"?: (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. */
+  "--table-title-gap"?: (string) | undefined;
+  /** The font size of the words in the `heading` slot. */
+  "--table-title-text"?: (string) | undefined;
   /** The column track list the table works out from its columns. The component writes it inline on the element that reads it, so setting it has no effect. Set `columns` to change the tracks. */
   "--table-template"?: (string) | undefined;
   /** The space between the tab row and the panel's content. */
@@ -15687,22 +17770,52 @@ export type CustomCssProperties = {
   "--tabs-tab-padding-inline"?: (string) | undefined;
   /** The label color of the current tab. */
   "--tabs-tab-selected-color"?: (string) | undefined;
+  /** The space between tags, across and between rows. */
+  "--tag-group-gap"?: (string) | undefined;
   /** The fill behind the tag. */
   "--tag-background-color"?: (string) | undefined;
   /** The color of the tag's edge. */
   "--tag-border-color"?: (string) | undefined;
+  /** How strongly a `disabled` tag is drawn. */
+  "--tag-disabled-opacity"?: (string) | undefined;
   /** The label color. */
   "--tag-foreground-color"?: (string) | undefined;
   /** The corner radius of the tag. */
   "--tag-radius"?: (string) | undefined;
+  /** The typeface. Overrides the ramp's. */
+  "--text-font-family"?: (string) | undefined;
+  /** The size. Overrides the ramp's. */
+  "--text-font-size"?: (string) | undefined;
+  /** The weight. Overrides the ramp's. */
+  "--text-font-weight"?: (string) | undefined;
+  /** The tracking. Overrides the ramp's. */
+  "--text-letter-spacing"?: (string) | undefined;
+  /** The leading. Overrides the ramp's. */
+  "--text-line-height"?: (string) | undefined;
   /** Fill behind the text. */
   "--textarea-background-color"?: (string) | undefined;
+  /** Edge of the field at rest. Hover, focus and an error still draw their own. */
+  "--textarea-border-color"?: (string) | undefined;
+  /** Space between the edge of the field and the text. */
+  "--textarea-padding"?: (string) | undefined;
+  /** Corner radius of the field. */
+  "--textarea-radius"?: (string) | undefined;
+  /** Which way a reader can drag the field: `vertical` by default, `none`, `both` or `horizontal`. A field under `auto-grow` has nothing to drag. */
+  "--textarea-resize"?: (string) | undefined;
   /** Fill behind the field. */
   "--time-input-background-color"?: (string) | undefined;
   /** Color of the panel's edge. */
   "--time-input-border-color"?: (string) | undefined;
   /** Width of the panel's edge. Defaults to `--helix-border-floating`, which is `0`, so the panel stands out by its shadow unless your theme sets a width. */
   "--time-input-border-width"?: (string) | undefined;
+  /** The fill behind the segment with focus, in `segmented`. It follows `--helix-color-primary`. */
+  "--time-input-segment-focus-background-color"?: (string) | undefined;
+  /** The text of the segment with focus, in `segmented`. */
+  "--time-input-segment-focus-color"?: (string) | undefined;
+  /** The text the locale writes between two segments, in `segmented`. */
+  "--time-input-segment-literal-color"?: (string) | undefined;
+  /** The dashes of a segment with nothing in it, in `segmented`. It matches the text field's placeholder. */
+  "--time-input-segment-placeholder-color"?: (string) | undefined;
   /** Shadow under the panel. Defaults to `--helix-shadow-floating`, because the panel can sit over any content. */
   "--time-input-shadow"?: (string) | undefined;
   /** How tall the list is before it scrolls. */
@@ -15715,6 +17828,8 @@ export type CustomCssProperties = {
   "--time-picker-selected-color"?: (string) | undefined;
   /** How tall a wheel is. Five rows by default. */
   "--time-picker-wheel-block-size"?: (string) | undefined;
+  /** The color of the heading. */
+  "--timeline-group-heading-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. */
@@ -15733,6 +17848,8 @@ export type CustomCssProperties = {
   "--toast-shadow"?: (string) | undefined;
   /** How long this message stays, in milliseconds, for a progress hint. */
   "--toast-duration"?: (string) | undefined;
+  /** How far a swipe has moved the message across, in pixels, toward the right. */
+  "--toast-swipe-x"?: (string) | undefined;
   /** Space between one message and the next. */
   "--toast-gap"?: (string) | undefined;
   /** Width of a message. */
@@ -15741,8 +17858,14 @@ export type CustomCssProperties = {
   "--toast-inset"?: (string) | undefined;
   /** The fill of the moving marker. */
   "--toggle-group-indicator-color"?: (string) | undefined;
+  /** The fill behind the controls. Transparent unless set. */
+  "--toolbar-background-color"?: (string) | undefined;
   /** The space between controls. */
   "--toolbar-gap"?: (string) | undefined;
+  /** The space between the toolbar's edge and its controls. */
+  "--toolbar-padding"?: (string) | undefined;
+  /** The corner radius of the toolbar's fill. */
+  "--toolbar-radius"?: (string) | undefined;
   /** The size of the arrow on the bubble's edge. */
   "--tooltip-arrow-size"?: (string) | undefined;
   /** The blur behind a `frosted` or `glass` bubble. */
@@ -15767,6 +17890,14 @@ export type CustomCssProperties = {
   "--tour-shadow"?: (string) | undefined;
   /** The color of the panel's surface. */
   "--tour-surface-color"?: (string) | undefined;
+  /** Fill of the check mark's box. */
+  "--tree-checkbox-background-color"?: (string) | undefined;
+  /** Border of the check mark's box. */
+  "--tree-checkbox-border-color"?: (string) | undefined;
+  /** Color of the check, and of the bar of a partly checked branch. */
+  "--tree-checkbox-mark-color"?: (string) | undefined;
+  /** Size of the check mark's box. Follows the chevron's size. */
+  "--tree-checkbox-size"?: (string) | undefined;
   /** Size of the chevron, and the gutter a leaf reserves. */
   "--tree-chevron-size"?: (string) | undefined;
   /** Space between rows. */
@@ -15781,10 +17912,20 @@ export type CustomCssProperties = {
   "--tree-chevron-gap"?: (string) | undefined;
   /** The chevron's order in the row. Set from `chevron-placement` and read by each item. */
   "--tree-chevron-order"?: (string) | undefined;
+  /** Color of a move that `good` says is an improvement. */
+  "--trend-better-color"?: (string) | undefined;
   /** Color of the arrow. Setting it overrides the color that `good` sets. */
   "--trend-color"?: (string) | undefined;
-  /** Size of the arrow. */
+  /** Space between the arrow, the metric and the label. */
+  "--trend-gap"?: (string) | undefined;
+  /** Size of the arrow, or of a glyph in the `icon` slot. */
   "--trend-icon-size"?: (string) | undefined;
+  /** Color of the label. */
+  "--trend-label-color"?: (string) | undefined;
+  /** Color of a trend that `good` does not judge, or one that did not move. */
+  "--trend-neutral-color"?: (string) | undefined;
+  /** Color of a move that `good` says is a setback. */
+  "--trend-worse-color"?: (string) | undefined;
   /** The fill behind a row. */
   "--video-playlist-item-background-color"?: (string) | undefined;
   /** The width of the thumbnail column. */
@@ -15857,7 +17998,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixAreaChartVueProps,
     HelixAreaChartVueEvents
   >;
-  /** One fragment shader draws over a full-screen triangle, and its palette comes from the tokens. A background built on '--helix-color-primary' changes when your brand color changes.  Every shape ramps through four token stops, and the token layer inverts each one: the page background, 'primary-subtle', 'primary', and a peak. The peak is the foreground on a dark page and 'primary-active' on a light one, because mixing a saturated hue toward near-black removes its chroma. The component reads which way the page runs from the background's luminance, because the mode is a private token.  The geometry is three vertices derived from 'gl_VertexID'. There is no dependency, scene graph, attribute, buffer, or upload.  The shader stops drawing in these cases: - The element is off screen or in a background tab. - 'prefers-reduced-motion' is set. The element shows one still frame. - The browser takes back the drawing context, on a GPU reset or past its   limit of about sixteen contexts. The gradient shows until the context   returns.  On a renderer that draws on the CPU, such as a headless browser or a machine with no usable GPU, the element shows the gradient. There the shader costs about 450ms for the first frame of each element, against 2ms on a GPU.  Aura is styled only and has behavior, which the tier split does not otherwise allow. Its behavior is drawing to a canvas, so there is no structure for you to restyle and nothing for a headless version to hold. */
+  /** One fragment shader draws over a full-screen triangle, and its palette comes from the tokens. A background built on '--helix-color-primary' changes when your brand color changes.  Every shape ramps through four token stops, and the token layer inverts each one: the page background, 'primary-subtle', 'primary', and a peak. The peak is the foreground on a dark page and 'primary-active' on a light one, because mixing a saturated hue toward near-black removes its chroma. The component reads which way the page runs from the background's luminance, because the mode is a private token.  The geometry is three vertices derived from 'gl_VertexID'. There is no dependency, scene graph, attribute, buffer, or upload.  The shader stops drawing in these cases: - The element is off screen or in a background tab. - 'prefers-reduced-motion' is set. The element shows one still frame. - The browser takes back the drawing context, on a GPU reset or past its   limit of about sixteen contexts. The gradient shows until the context   returns.  On a renderer that draws on the CPU, such as a headless browser or a machine with no usable GPU, the element shows the gradient. There the shader costs about 450ms for the first frame of each element, against 2ms on a GPU.  Aura is styled only and has behavior, which the tier split does not otherwise allow. Its behavior is drawing to a canvas, so there is no structure for you to restyle and nothing for a headless version to hold.  **Content placed inside sits over the field**, in a 'content' part that covers the aura, so an interactive aura answers the pointer over the content too. Clicks still reach the content. Style '::part(content)' to place it, such as centering a hero's heading.  **The colors are the theme's, and each has a hook**: '--aura-ground', '--aura-haze', '--aura-glow' and '--aura-peak', read by the shader and by the fallback gradient alike, from wherever on the page you set them.  Where the gradient shows in place of the shader, the aura matches ':state(fallback)' and sends 'helix-aura-fallback' with the reason. */
   "helix-aura": DefineCustomElement<
     HelixAura,
     HelixAuraVueProps,
@@ -15875,7 +18016,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixAvatarVueProps,
     HelixAvatarVueEvents
   >;
-  /** The indicator has a ring in the page background color, so it stays legible where it overlaps the element it is pinned to, such as a dark badge on a dark icon. */
+  /** The indicator has a ring in the page background color, so it stays legible where it overlaps the element it is pinned to, such as a dark badge on a dark icon.  'placement' pins it to another corner, or puts it in the line with 'inline'. **Inside a control, 'inline' puts the count in the control's name**: '<button>Inbox <helix-badge placement="inline" value="8" label="8 unread"></helix-badge></button>' is the button "Inbox 8 unread", kept current by the badge with no label of yours to update. */
   "helix-badge": DefineCustomElement<
     HelixBadge,
     HelixBadgeVueProps,
@@ -15905,7 +18046,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixBreadcrumbsVueProps,
     HelixBreadcrumbsVueEvents
   >;
-  /** Joins the buttons into one shape: the outer corners keep their radius, the inner corners lose it, and adjacent borders collapse into one line.  The joining rule is in the base layer, paired with 'data-button' like the button's own box, because the corner is on the control inside each button's shadow root, where this component's styles cannot reach. The same rule works for your own anchor styled as a button. */
+  /** Joins the buttons into one shape: the outer corners keep their radius, the inner corners lose it, and adjacent borders collapse into one line.  The joining rule is in the base layer, paired with 'data-button' like the button's own box, because the corner is on the control inside each button's shadow root, where this component's styles cannot reach. The same rule works for your own anchor styled as a button.  The buttons take their height from the region, so set 'data-density' on the group to make every button in it smaller or larger together. */
   "helix-button-group": DefineCustomElement<
     HelixButtonGroup,
     HelixButtonGroupVueProps,
@@ -15917,7 +18058,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixButtonVueProps,
     HelixButtonVueEvents
   >;
-  /** The background is a tint of the tone's color, mixed with 'color-mix'. A 'neutral' callout is drawn in the muted ink, for a note that reports no status, so it keeps to the palette whatever the brand. A bar on the inline start edge also marks the tone, so it still shows in grayscale and for people who do not distinguish the hues.  This tier has no treatment property. 'tone' is set on the headless tier and carries the meaning, and this tier draws it. */
+  /** The background is a tint of the tone's color, mixed with 'color-mix'. A 'neutral' callout is drawn in the muted ink, for a note that reports no status, so it keeps to the palette whatever the brand. A bar on the inline start edge also marks the tone, so it still shows in grayscale and for people who do not distinguish the hues.  'tone' is set on the headless tier and carries the meaning, and this tier draws it. 'separation' is where the box ends: absent is the tint with the bar, 'outlined' an edge with no fill, and 'plain' the bar and the mark alone. */
   "helix-callout": DefineCustomElement<
     HelixCallout,
     HelixCalloutVueProps,
@@ -15941,7 +18082,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixCanvasVueProps,
     HelixCanvasVueEvents
   >;
-  /** The regions are the 'media', 'header', and 'footer' slots and the default slot for content. None of them has a wrapper element. A region you leave out takes no space, so a card with only content needs no extra markup. Style slotted content directly: a header is the element you slotted, so there is no part to target.  'media' runs edge to edge and clips to the card's corners, so an image needs no inset. Set 'orientation="horizontal"' to put the media beside the header, content, and footer. Set 'media-placement="end"' to put it below the content, for example for a chart that ends a card. */
+  /** The regions are the 'media', 'header', and 'footer' slots and the default slot for content. None of them has a wrapper element. A region you leave out takes no space, so a card with only content needs no extra markup. Style slotted content directly: a header is the element you slotted, so there is no part to target.  'header-actions' and 'footer-actions' put controls at the end of the header's and the footer's line; the footer then moves to the start of its line. Put a header of more than one element in one wrapper, since the header and its actions share a line.  'media' runs edge to edge and clips to the card's corners, so an image needs no inset. Set 'orientation="horizontal"' to put the media beside the header, content, and footer. Set 'media-placement="end"' to put it below the content, for example for a chart that ends a card. */
   "helix-card": DefineCustomElement<
     HelixCard,
     HelixCardVueProps,
@@ -15983,7 +18124,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixCheckboxVueProps,
     HelixCheckboxVueEvents
   >;
-  /** The header sits above the code with the copy button at its end, so the button never covers the first line. A block with no name has no header. The button then sits beside the code in space the block keeps clear: an end gutter for code, and a band above the first hunk for a diff.  A diff draws one block per file in the same frame. Each changed line is tinted in its tone at Tag's resting strength, with its '+' or '-' in the tone's ink color, so you can see the change without comparing two pale backgrounds. A split diff stacks its two versions when the file is narrower than about 40rem. */
+  /** The header sits above the code with the copy button at its end, so the button never covers the first line. A block with no name has no header. The button then sits beside the code in space the block keeps clear: an end gutter for code, and a band above the first hunk for a diff.  A diff draws one block per file in the same frame. Each changed line is tinted in its tone at Tag's resting strength, with its '+' or '-' in the tone's ink color, so you can see the change without comparing two pale backgrounds. A split diff stacks its two versions when the file is narrower than about 40rem.  Long lines scroll by default. Set 'wrap' to wrap them instead, for prose-like code such as a long command, and set '--code-block-max-block-size' to cap the height of a long file, which then scrolls. */
   "helix-code-block": DefineCustomElement<
     HelixCodeBlock,
     HelixCodeBlockVueProps,
@@ -16061,7 +18202,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixDialogVueProps,
     HelixDialogVueEvents
   >;
-  /** A one-pixel rule in the border color that spans the full inline size by default. A vertical divider stretches to fit its flex parent, so it matches the height of what it sits beside. */
+  /** A one-pixel rule in the border color that spans the full inline size by default. A vertical divider stretches to fit its flex parent, so it matches the height of what it sits beside.  Content set into the line sits at its middle. 'content-placement' moves it toward the start or the end, leaving a short length of line before or after it, the way a section label sits in a form. */
   "helix-divider": DefineCustomElement<
     HelixDivider,
     HelixDividerVueProps,
@@ -16133,7 +18274,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixFilterInputVueProps,
     HelixFilterInputVueEvents
   >;
-  /** The host is the flex container and its only child is a slot, so '<helix-flex>' adds no box beyond the '<div>' it replaces.  There is no separate Stack component. For a stack, set 'direction="column"'.  'gap' takes a space token name, so spacing stays on the scale.  Flex is presentation only, so it has no headless tier. */
+  /** The host is the flex container and its only child is a slot, so '<helix-flex>' adds no box beyond the '<div>' it replaces.  There is no separate Stack component. For a stack, set 'direction="column"'.  'gap' takes a space token name, so spacing stays on the scale. 'row-gap' and 'column-gap' set one axis each and win over 'gap' on theirs.  'layout' sets up one of three common patterns, and any attribute you also write wins over the pattern's own value:  - 'cluster': items in a wrapping row, centered on one line, such as tags. - 'split': the first item at the start and the rest pushed to the end, such   as a title and its actions. Wraps when there is no room. - 'flank' and 'flank-end': a fixed item beside one that takes the rest, such   as an icon and its text, or a field and its button. The item that takes   the rest stays at least '--flex-flank-min' wide, and the pair stacks once   it cannot.  Flex is presentation only, so it has no headless tier. */
   "helix-flex": DefineCustomElement<
     HelixFlex,
     HelixFlexVueProps,
@@ -16151,7 +18292,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixGraphVueProps,
     HelixGraphVueEvents
   >;
-  /** Set columns in one of two ways:  - 'columns' sets a fixed count. - 'min' fits as many equal columns as there is room for at that width, so the   layout responds with no breakpoints to maintain.  If you set both, 'min' wins. The grid is presentation only, so there is no headless tier. */
+  /** Set columns in one of two ways:  - 'columns' sets a fixed count. - 'min' fits as many equal columns as there is room for at that width, so the   layout responds with no breakpoints to maintain.  If you set both, 'min' wins. The grid is presentation only, so there is no headless tier.  'row-gap' and 'column-gap' set one axis each and win over 'gap' on theirs. '--grid-rows' and '--grid-areas' set the rows and named areas, and a child takes its place with 'grid-area' in your own stylesheet.  **A child can span columns with 'data-grid-span'.** 'data-grid-span="full"' runs from the first column to the last, such as a heading across a set of cards, and a number from '2' to '6' spans that many columns. */
   "helix-grid": DefineCustomElement<
     HelixGrid,
     HelixGridVueProps,
@@ -16193,7 +18334,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixKbdVueProps,
     HelixKbdVueEvents
   >;
-  /** Entries are laid out in a row that wraps, because a legend under a chart is as wide as the chart, and its names have to fit any width. Set '--legend-direction' to 'column' when the legend sits beside a chart.  Series colors are mapped in this tier. The headless tier carries the index and holds no tokens. The mapping is in 'shared/chart/series.css', because an index in markup cannot select a token, and an inline custom property would put a color in the headless tier. Charts and legends share the file, so both use the same twenty-four color names. */
+  /** Entries are laid out in a row that wraps, because a legend under a chart is as wide as the chart, and its names have to fit any width. Set '--legend-direction' to 'column' when the legend sits beside a chart.  Series colors are mapped in this tier. The headless tier carries the index and holds no tokens. The mapping is in 'shared/chart/series.css', because an index in markup cannot select a token, and an inline custom property would put a color in the headless tier. Charts and legends share the file, so both use the same twenty-four color names.  Under 'toggles', each name is a button. A hidden series' entry fades and its swatch empties to an outline, so the color stays readable. */
   "helix-legend": DefineCustomElement<
     HelixLegend,
     HelixLegendVueProps,
@@ -16235,7 +18376,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixListboxVueProps,
     HelixListboxVueEvents
   >;
-  /** Sized from the loader size tokens, so a loader is the same size wherever it is placed and follows the density region it sits in. Set '--loader-size: 1em' to match the text beside it, as inside a button. The color is 'currentColor', so it matches the text color around it, including inside a primary button. */
+  /** Sized from the loader size tokens, so a loader is the same size wherever it is placed and follows the density region it sits in. Set '--loader-size: 1em' to match the text beside it, as inside a button. The color is 'currentColor', so it matches the text color around it, including inside a primary button.  While 'delay' runs, the loader keeps its size and draws nothing, so the line it sits in does not move when it appears. */
   "helix-loader": DefineCustomElement<
     HelixLoader,
     HelixLoaderVueProps,
@@ -16325,6 +18466,12 @@ export interface WcToolkitVueGlobalComponents {
     HelixMenuVueProps,
     HelixMenuVueEvents
   >;
+  /** The heading is set in the menu's small type, quieter than the rows, with the rows' own inset, so it reads as the name of what follows. */
+  "helix-menu-section": DefineCustomElement<
+    HelixMenuSection,
+    HelixMenuSectionVueProps,
+    HelixMenuSectionVueEvents
+  >;
   /** Draws the same bar as 'Progress', at twice the height, with the library's standard corner radius in place of the pill shape.  The extra height makes a meter easy to tell apart from a progress bar and keeps the tick at each threshold visible. At eight pixels the ticks are hairlines. At sixteen they are clear. The ticks cut the fill into segments, which is why the corners are square: a pill-shaped bar would have round outer ends and square inner ends.  Once you set thresholds, the fill takes the success, warning, or danger tone of the band the reading falls in. A meter with no thresholds is neutral. A tick marks each threshold, so the reading can be placed against the bands without relying on color.  A reading past either end squares the corner on that side, the convention for a quantity that continues past its frame. The bar stops at the end, and the text and the accessible value give the actual reading. */
   "helix-meter": DefineCustomElement<
     HelixMeter,
@@ -16361,7 +18508,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixNumberInputVueProps,
     HelixNumberInputVueEvents
   >;
-  /** The styled tier draws the tree in the Code Block frame. Keys and each type of value take their colors from the syntax colors code blocks use. Each row is one line, and a long string ends in an ellipsis, so every row has the same height and a windowed tree does not measure rows one by one. */
+  /** The styled tier draws the tree in the Code Block frame. Keys and each type of value take their colors from the syntax colors code blocks use. Each row is one line, and a long string ends in an ellipsis, so every row has the same height and a windowed tree does not measure rows one by one. A filter's matches take a tinted ground, and the filter field is a band of the same frame, under the label. */
   "helix-object-inspector": DefineCustomElement<
     HelixObjectInspector,
     HelixObjectInspectorVueProps,
@@ -16379,13 +18526,13 @@ export interface WcToolkitVueGlobalComponents {
     HelixOptionVueProps,
     HelixOptionVueEvents
   >;
-  /** A cloud of dots drawn to a canvas, with one shape per state:  - 'connecting' and 'thinking': the same leaning sash, differing in how   agitated it is. - 'waiting' and 'done': the same settled ball at different tempos. - 'fetching': a globe with a light moving around it. - 'listening': a closed sphere with a ripple crossing it. - 'working': a ring.  Every state is the same banded grid with different parameters. Changing state interpolates the parameters, so every frame in between is a complete shape. A small change gets less time than a large one, such as a sash becoming a ring. The outline changes first, so the light starts orbiting only after the shape is round.  The cloud does not rotate, and all movement happens inside it. The exception is the light, which travels because a ring of evenly spaced dots looks the same when rotated, so a turning state needs something fixed passing over it.  Colors come from '--orb-color' and '--orb-ground'. Each dot's color is mixed toward the ground color by its depth, so depth holds when the theme changes.  The animation stops when the orb is off screen or in a background tab. With 'prefers-reduced-motion', it draws one still frame.  The orb is styled only and has behavior, which the tier split does not otherwise allow. Its role, name and busy state follow 'state', and the rest is drawing dots to a canvas, so there is no structure to restyle. For a drawing of your own, the headless 'Loader' holds the same busy progress bar and its name. */
+  /** A cloud of dots drawn to a canvas, with one shape per state:  - 'connecting' and 'thinking': the same leaning sash, differing in how   agitated it is. - 'waiting' and 'done': the same settled ball at different tempos. - 'fetching': a globe with a light moving around it. - 'listening': a closed sphere with a ripple crossing it. - 'working': a ring.  Every state is the same banded grid with different parameters. Changing state interpolates the parameters, so every frame in between is a complete shape. A small change gets less time than a large one, such as a sash becoming a ring. The outline changes first, so the light starts orbiting only after the shape is round.  The cloud does not rotate, and all movement happens inside it. The exception is the light, which travels because a ring of evenly spaced dots looks the same when rotated, so a turning state needs something fixed passing over it.  Colors come from '--orb-color' and '--orb-ground'. Each dot's color is mixed toward the ground color by its depth, so depth holds when the theme changes.  The animation stops when the orb is off screen or in a background tab. With 'prefers-reduced-motion', it draws one still frame.  The orb is styled only and has behavior, which the tier split does not otherwise allow. Its role, name and busy state follow 'state', and the rest is drawing dots to a canvas, so there is no structure to restyle. For a drawing of your own, the headless 'Loader' holds the same busy progress bar and its name.  Each state is also a custom state, such as ':state(thinking)' or ':state(done)', so a page can style what sits around an orb by what it shows, whether the state was written as an attribute or set from script. */
   "helix-orb": DefineCustomElement<
     HelixOrb,
     HelixOrbVueProps,
     HelixOrbVueEvents
   >;
-  /** A rule runs down the leading edge, and the current section is highlighted along it.  Set nesting with 'data-level' on each link, using the heading levels: '2' through '6' each add one step of '--outline-indent', and a link without 'data-level' is at the top level. The outline does not read heading levels from the document, because the headings are not always in the document. */
+  /** A rule runs down the leading edge, and the current section is highlighted along it.  Set nesting with 'data-level' on each link, using the heading levels: '2' through '6' each add one step of '--outline-indent', and a link without 'data-level' is at the top level. The outline does not read heading levels from the document, because the headings are not always in the document.  Links in a nested '<ul>' take their indentation from your own stylesheet: the outline's styles reach the elements slotted into it and nothing inside them. Write the links flat with 'data-level' for the indentation drawn here, and screen readers still hear them as nested lists.  A heading slotted into 'heading' is set above the links, lined up with them. */
   "helix-outline": DefineCustomElement<
     HelixOutline,
     HelixOutlineVueProps,
@@ -16481,7 +18628,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixSandboxStatusBarVueProps,
     HelixSandboxStatusBarVueEvents
   >;
-  /** The sandbox receives 'helix-console' events from the preview and passes them to the terminal. The preview is a separate document, so messages cross 'postMessage' and arrive as text.  **Repeats collapse.** Consecutive identical lines show as one line with a count, so an example with a render loop does not fill the panel with the same warning. Only consecutive repeats collapse, so the order of messages is kept.  The panel has 'role="log"', the role for an append-only stream. Screen readers announce new output without reading the whole panel again. A line's level is read before it, except a plain 'log', so an error does not sound like any other line. */
+  /** The sandbox receives 'helix-console' events from the preview and passes them to the terminal. The preview is a separate document, so messages cross 'postMessage' and arrive as text.  **Repeats collapse.** Consecutive identical lines show as one line with a count, so an example with a render loop does not fill the panel with the same warning. Only consecutive repeats collapse, so the order of messages is kept.  The panel has 'role="log"', the role for an append-only stream. Screen readers announce new output without reading the whole panel again. A line's level is read before it, except a plain 'log', so an error does not sound like any other line.  **'controls' adds a clear button and a level filter** above the log. Both are also yours to drive without them: 'clear()' empties the log, and 'level' hides the quieter lines. */
   "helix-sandbox-terminal": DefineCustomElement<
     HelixSandboxTerminal,
     HelixSandboxTerminalVueProps,
@@ -16499,7 +18646,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixScatterChartVueProps,
     HelixScatterChartVueEvents
   >;
-  /** Presentation only: fades on the edges the base class reports, and a scrollbar styled to match the design system. The base class measures which edges have content past them. */
+  /** Presentation only: fades on the edges the base class reports, and a scrollbar styled to match the design system. The base class measures which edges have content past them.  Under 'scrollbars', the browser's scrollbar is hidden and the component's own are drawn over the content at the edge, in the same colors. */
   "helix-scroll-area": DefineCustomElement<
     HelixScrollArea,
     HelixScrollAreaVueProps,
@@ -16511,7 +18658,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixSelectVueProps,
     HelixSelectVueEvents
   >;
-  /** Animates a highlight sweeping across the block, which reads as work in progress. A block fading in and out can look broken. */
+  /** Animates a highlight sweeping across the block, which reads as work in progress. A block fading in and out can look broken, so 'effect="pulse"' is a choice rather than the default.  Around content with 'loading', the skeleton takes the content's box and paints over it, and the content is hidden until 'loading' is taken off. */
   "helix-skeleton": DefineCustomElement<
     HelixSkeleton,
     HelixSkeletonVueProps,
@@ -16576,7 +18723,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixStepVueProps,
     HelixStepVueEvents
   >;
-  /** A thumb moves along a track. The switch is the one place in Helix where color means "on". A checkbox has a tick, and a switch has no mark, so the fill is what tells the two states apart.  The input is the hit target. It is stretched over the track and made invisible, so the press, the focus, and the label forwarding come from the platform.  The height is '--helix-size-switch', one step above the checkbox's at every density. At the checkbox's height the thumb has two pixels of track around it, and the control looks like a small dash. The width follows the height, so setting '--switch-block-size' widens the switch too and keeps the proportion. */
+  /** A thumb moves along a track. The switch is the one place in Helix where color means "on". A checkbox has a tick, and a switch has no mark, so the fill is what tells the two states apart.  The input is the hit target. It is stretched over the track and made invisible, so the press, the focus, and the label forwarding come from the platform.  The height is '--helix-size-switch', one step above the checkbox's at every density. At the checkbox's height the thumb has two pixels of track around it, and the control looks like a small dash. The width follows the height, so setting '--switch-block-size' widens the switch too and keeps the proportion.  The thumb is an element, the 'thumb' part, and holds an icon for each state: one in the 'on' slot shows while the switch is on, and one in the 'off' slot while it is off. */
   "helix-switch": DefineCustomElement<
     HelixSwitch,
     HelixSwitchVueProps,
@@ -16624,13 +18771,19 @@ export interface WcToolkitVueGlobalComponents {
     HelixTabVueProps,
     HelixTabVueEvents
   >;
+  /** The tags sit in a row that wraps. A selected tag is filled with its tone, as 'emphasis="solid"' draws one, and the focused tag takes the focus ring round its whole box. */
+  "helix-tag-group": DefineCustomElement<
+    HelixTagGroup,
+    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. */
   "helix-tag": DefineCustomElement<
     HelixTag,
     HelixTagVueProps,
     HelixTagVueEvents
   >;
-  /** 'as' sets the element, which decides the document outline and what a screen reader announces. 'variant' sets the type ramp, which decides size, weight, leading, and tracking together.  The two match by default, so usually you set only 'as', such as 'as="h2"'. Set 'variant' when the look and the element differ, such as a heading that looks smaller or a '<p>' styled as a caption.  The pairing is resolved in CSS, so the element writes nothing to its host. 'as="h2"' picks up the heading ramp through a selector, and setting 'variant' overrides the pairing. Do not derive it in 'willUpdate', because that adds a host attribute the server markup does not have, which causes a hydration mismatch in React.  Size, weight, and leading are not separate properties. Choose a named ramp with 'variant'.  'tone' and 'emphasis' are separate from 'variant', because color carries state. Combining them would need a variant for every pair, such as 'caption-danger' and 'label-muted'. */
+  /** 'as' sets the element, which decides the document outline and what a screen reader announces. 'variant' sets the type ramp, which decides size, weight, leading, and tracking together.  The two match by default, so usually you set only 'as', such as 'as="h2"'. Set 'variant' when the look and the element differ, such as a heading that looks smaller or a '<p>' styled as a caption.  The pairing is resolved in CSS, so the element writes nothing to its host. 'as="h2"' picks up the heading ramp through a selector, and setting 'variant' overrides the pairing. Do not derive it in 'willUpdate', because that adds a host attribute the server markup does not have, which causes a hydration mismatch in React.  Size, weight, and leading are not separate properties. Choose a named ramp with 'variant'.  'tone' and 'emphasis' are separate from 'variant', because color carries state. Combining them would need a variant for every pair, such as 'caption-danger' and 'label-muted'.  'lines' cuts the text off after that many lines and ends it with an ellipsis. 'text-wrap' balances or tidies the line breaks, and 'text-align' sets the alignment. Each '--text-*' property overrides one value of the ramp, for a text or for every text inside an element.  **To label a control, write a native '<label data-text="label">'.** The base layer gives it the label ramp. A Helix field takes its own 'label'. */
   "helix-text": DefineCustomElement<
     HelixText,
     HelixTextVueProps,
@@ -16654,13 +18807,19 @@ export interface WcToolkitVueGlobalComponents {
     HelixTimePickerVueProps,
     HelixTimePickerVueEvents
   >;
+  /** The heading sits at the start edge, over the entries, in the small heavy type of a section label, and the space under one group is the space between two entries. */
+  "helix-timeline-group": DefineCustomElement<
+    HelixTimelineGroup,
+    HelixTimelineGroupVueProps,
+    HelixTimelineGroupVueEvents
+  >;
   /** Draws the rail down the side, the mark on it, and the line that arrives from the previous entry. */
   "helix-timeline-item": DefineCustomElement<
     HelixTimelineItem,
     HelixTimelineItemVueProps,
     HelixTimelineItemVueEvents
   >;
-  /** Sets the direction time runs in and the spacing between events. Each entry draws its own mark and line. */
+  /** 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. */
   "helix-timeline": DefineCustomElement<
     HelixTimeline,
     HelixTimelineVueProps,
@@ -16750,13 +18909,13 @@ export interface WcToolkitVueGlobalComponents {
     HelixVideoPlaylistVueProps,
     HelixVideoPlaylistVueEvents
   >;
-  /** The player comes from the headless tier. This tier adds the control bar: where it sits, when it shows, and how the two ranges look.  The bar sits over the picture, so the video keeps its own size and nothing below it moves.  The bar hides once a playing video has gone 'idle-delay' without input. It shows again when the pointer moves, and whenever anything inside it has focus, so you can reach it with the keyboard. A paused video keeps its bar. */
+  /** The player comes from the headless tier. This tier adds the control bar: where it sits, when it shows, and how the two ranges look.  The bar sits over the picture, so the video keeps its own size and nothing below it moves.  The bar hides once a playing video has gone 'idle-delay' without input. It shows again when the pointer moves, and whenever anything inside it has focus, so you can reach it with the keyboard. A paused video keeps its bar.  An icon put in one of the '-icon' slots is drawn at the size of the glyph it replaces, and in the control's color. */
   "helix-video": DefineCustomElement<
     HelixVideo,
     HelixVideoVueProps,
     HelixVideoVueEvents
   >;
-  /** The styled tier styles only the scrolling box. Rows are your markup in the light DOM, so your stylesheet styles them the same as any other content, and this tier sets no rules for them. */
+  /** The styled tier styles the scrolling box and draws the focus ring on the row holding focus. Rows are your markup in the light DOM, so your stylesheet styles them the same as any other content, and a rule of yours on a row wins over the ring. */
   "helix-virtual-list": DefineCustomElement<
     HelixVirtualList,
     HelixVirtualListVueProps,