@fusion.dev/helix-headless 0.172.0 → 0.174.0

package/types/vue.d.ts

@@ -1284,6 +1284,9 @@ export type HelixHeadlessButtonGroupHelixBeforeChangeElementEvent =
   HelixHeadlessButtonGroupElementEvent<HelixBeforeChangeEvent>;
 
 export type HelixHeadlessButtonGroupVueProps = {
+  /** Disables every button in the group, and says so on the group with
+`aria-disabled`. Reflected, so a stylesheet can select on it. */
+  disabled?: (HelixHeadlessButtonGroup["disabled"]) | undefined;
   /** Keeps at least one button pressed once one is, as React Aria's
 `disallowEmptySelection`: a press that would leave none pressed is
 refused. */
@@ -1333,6 +1336,9 @@ A button's own `value` names it, so a value holds no comma.
 The attribute is the seed, and a press changes the property, which does
 not reflect, as a native control's `value` does not. */
   value?: (HelixHeadlessButtonGroup["value"]) | undefined;
+  /** The pressed values as a list, in a selection mode, and an empty list
+otherwise. Written, it presses exactly those buttons. */
+  values?: (HelixHeadlessButtonGroup["values"]) | undefined;
 };
 
 export type HelixHeadlessButtonGroupVueEvents = {
@@ -1885,6 +1891,9 @@ Third", rather than with a comma this component chose. */
   /** The text read with a card that has connections both ways. `{leadsTo}` is
 `leads-to-label` and `{comesFrom}` is `comes-from-label`, each filled in. */
   linkedLabel?: (HelixHeadlessCanvas["linkedLabel"]) | undefined;
+  /** Marks the board as busy while its document arrives: the board is
+`aria-busy`, and the `loading` slot is shown. */
+  loading?: (HelixHeadlessCanvas["loading"]) | undefined;
   /** What screen readers hear after a key moves a card, with `{name}` for the
 card and `{x}` and `{y}` for where it now is, in the document's units.
 
@@ -4709,6 +4718,24 @@ Defaulted rather than left empty. An icon-only control must be named, and
 the name of this one is not a judgment call: every copy button in the
 world is called Copy. A consumer with a better word still sets it. */
   label?: (HelixHeadlessCopyButton["label"]) | undefined;
+  /** Draws the name as words beside the icon, and the result in their place
+after a press. The button stays as wide as the longest of them. */
+  "show-label"?: (HelixHeadlessCopyButton["showLabel"]) | undefined;
+  /** Draws the name as words beside the icon, and the result in their place
+after a press. The button stays as wide as the longest of them. */
+  showLabel?: (HelixHeadlessCopyButton["showLabel"]) | undefined;
+  /** When the tooltip shows: `full` on hover and focus and after a press,
+`copy` only after a press, to show the result, and `none` never, for a
+button whose result shows another way, such as under `show-label`.
+
+Unset is `full`, and the attribute stays absent until you write it. */
+  tooltip?: (HelixHeadlessCopyButton["tooltip"]) | undefined;
+  /** The side the tooltip prefers. It moves to another side where this one
+does not fit. */
+  "tooltip-placement"?: (HelixHeadlessCopyButton["tooltipPlacement"]) | undefined;
+  /** The side the tooltip prefers. It moves to another side where this one
+does not fit. */
+  tooltipPlacement?: (HelixHeadlessCopyButton["tooltipPlacement"]) | undefined;
   /** The text copied to the clipboard.
 
 It replaces `Button.value`, the submit value: a copy button never submits,
@@ -7614,6 +7641,13 @@ or hides its notes. Drawn where the notes have two groups or more. */
   "links-to-label"?: (HelixHeadlessGraph["linksToLabel"]) | undefined;
   /** How a note that links to the selected one is described, with `{note}`. */
   linksToLabel?: (HelixHeadlessGraph["linksToLabel"]) | undefined;
+  /** Marks the graph as busy while its notes arrive: the list is `aria-busy`,
+and the panel says so where it holds no notes yet. */
+  loading?: (HelixHeadlessGraph["loading"]) | undefined;
+  /** What the panel says while `loading` is set and the list holds no notes. */
+  "loading-label"?: (HelixHeadlessGraph["loadingLabel"]) | undefined;
+  /** What the panel says while `loading` is set and the list holds no notes. */
+  loadingLabel?: (HelixHeadlessGraph["loadingLabel"]) | undefined;
   /** What screen readers hear once the drawing has moved down, after `moved()`. */
   "moved-down-label"?: (HelixHeadlessGraph["movedDownLabel"]) | undefined;
   /** What screen readers hear once the drawing has moved down, after `moved()`. */
@@ -7835,6 +7869,16 @@ Ignored once `active` is written. */
   links?: (HelixHeadlessGraph["links"]) | undefined;
   /** The notes. A property, never an attribute. */
   nodes?: (HelixHeadlessGraph["nodes"]) | undefined;
+  /** What each note's row in the list shows in place of its name: a function
+given the note that returns text, an element or a Lit template.
+
+For an icon by its kind, or a date under its name, as React Aria's
+`ListBoxItem` takes children. The row is still named by the note's name,
+which typeahead and the search find it by, and described by how it stands
+to the selected note. Return the name with your content where it should
+still show. A property only, there being no way to write a function in
+markup. */
+  noteContent?: (HelixHeadlessGraph["noteContent"]) | undefined;
 };
 
 export type HelixHeadlessGraphVueEvents = {
@@ -9470,7 +9514,8 @@ itself. */
   type?: (HelixHeadlessList["type"]) | undefined;
   /** The selected rows' values, separated by commas with no spaces, such as `a,c`, in a list that selects.
 
-Set it to start with rows selected. A row's value is its `value`, or its
+A press or a key writes it in row order, as Data Table does, whatever
+order the rows were chosen in. Set it to start with rows selected. A row's value is its `value`, or its
 words where it has none. */
   value?: (HelixHeadlessList["value"]) | undefined;
 };
@@ -12168,6 +12213,10 @@ box the sections scroll in. */
   /** The navigation's name, read by screen readers. A heading in the `heading`
 slot names it in place of this. */
   label?: (HelixHeadlessOutline["label"]) | undefined;
+  /** Which links are marked. `reading` marks the one section being read, the
+last whose heading has passed the reading line. `visible` marks every
+section with part of it on screen, and the mark runs across their links. */
+  marks?: (HelixHeadlessOutline["marks"]) | 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
 scroll in.
@@ -14482,6 +14531,13 @@ that should survive its own collapse says how much of itself to keep, and
 only whoever put it there knows that, which is the same reason `min` is a
 consumer's to set. */
   collapsedSize?: (HelixHeadlessSplitter["collapsedSize"]) | undefined;
+  /** Which panes can be collapsed, as Zag's panels each take `collapsible`:
+`start`, `end`, `both`, or `none`. A pane that cannot be collapsed stops
+at the edge without shutting. `Enter` collapses the end pane where only
+the end pane can be collapsed, and the start pane otherwise.
+
+Unset is `both`, and the attribute stays absent until you write it. */
+  collapsible?: (HelixHeadlessSplitter["collapsible"]) | undefined;
   /** The name of the handle where two dividers cross, read by screen readers. */
   "corner-label"?: (HelixHeadlessSplitter["cornerLabel"]) | undefined;
   /** The name of the handle where two dividers cross, read by screen readers. */
@@ -14510,6 +14566,18 @@ these words are the whole of where it is. */
   "default-position"?: (HelixHeadlessSplitter["defaultPosition"] | `${number}`) | undefined;
   /** Where the divider starts, when `position` is not set. */
   defaultPosition?: (HelixHeadlessSplitter["defaultPosition"]) | undefined;
+  /** The least the end pane keeps, in the units `min` takes: a percentage, or
+a CSS length such as `16rem` resolved against the splitter's box. The
+divider stops that far from the end, whatever `max` allows, so `min` and
+`end-min` hold a minimum for each pane, as Zag's panels each take
+`minSize`. */
+  "end-min"?: (HelixHeadlessSplitter["endMin"]) | undefined;
+  /** The least the end pane keeps, in the units `min` takes: a percentage, or
+a CSS length such as `16rem` resolved against the splitter's box. The
+divider stops that far from the end, whatever `max` allows, so `min` and
+`end-min` hold a minimum for each pane, as Zag's panels each take
+`minSize`. */
+  endMin?: (HelixHeadlessSplitter["endMin"]) | undefined;
   /** The divider's name, read by screen readers.
 
 An `aria-label` or `aria-labelledby` on the host names the divider too,
@@ -16744,6 +16812,18 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixHeadlessTimePicker["name"]) | undefined;
+  /** What each time in the list shows: a function given the time as `HH:mm`,
+or `HH:mm:ss` with `seconds`, and the time as the row writes it, that
+returns text, an element or a Lit template.
+
+For the seats left at a time, or a caption under it, as React Aria's
+`ListBoxItem` takes children. Content with `slot="start"`, `slot="end"`
+or `slot="description"` goes to that slot of the row, and a description
+is read after the time. The row is still named by the written time, and
+typeahead still finds it by that. Return the written time with your
+content where it should still show. A property only, there being no way
+to write a function in markup. The wheels draw their own figures. */
+  timeContent?: (HelixHeadlessTimePicker["timeContent"]) | undefined;
   /** The value as a `Date` on 1 January 1970 UTC, or `null` while there is no time.
 
 The platform's own pair on `<input type="time">`, epoch day included: a time
@@ -16822,6 +16902,13 @@ export type HelixHeadlessTimelineItemVueEvents = {};
 export type HelixHeadlessTimelineVueProps = {
   /** Accessible name for the timeline, for people who reach it out of context. */
   label?: (HelixHeadlessTimeline["label"]) | undefined;
+  /** Marks the timeline as busy fetching more entries, and draws an entry
+after the last that says so. */
+  loading?: (HelixHeadlessTimeline["loading"]) | undefined;
+  /** The text of the entry drawn while `loading` is set, where the `loading` slot is empty. */
+  "loading-label"?: (HelixHeadlessTimeline["loadingLabel"]) | undefined;
+  /** The text of the entry drawn while `loading` is set, where the `loading` slot is empty. */
+  loadingLabel?: (HelixHeadlessTimeline["loadingLabel"]) | undefined;
 };
 
 export type HelixHeadlessTimelineVueEvents = {};
@@ -18643,12 +18730,18 @@ export type HelixHeadlessVirtualListElementEvent<E = Event> = TypedEvent<
 /** `helix-before-change` event type */
 export type HelixHeadlessVirtualListHelixBeforeChangeElementEvent =
   HelixHeadlessVirtualListElementEvent<HelixBeforeChangeEvent>;
+/** `helix-before-reorder` event type */
+export type HelixHeadlessVirtualListHelixBeforeReorderElementEvent =
+  HelixHeadlessVirtualListElementEvent<HelixBeforeReorderEvent>;
 /** `helix-load-more` event type */
 export type HelixHeadlessVirtualListHelixLoadMoreElementEvent =
   HelixHeadlessVirtualListElementEvent<HelixLoadMoreEvent>;
 /** `helix-range-change` event type */
 export type HelixHeadlessVirtualListHelixRangeChangeElementEvent =
   HelixHeadlessVirtualListElementEvent<HelixRangeChangeEvent>;
+/** `helix-reorder` event type */
+export type HelixHeadlessVirtualListHelixReorderElementEvent =
+  HelixHeadlessVirtualListElementEvent<HelixReorderEvent>;
 
 export type HelixHeadlessVirtualListVueProps = {
   /** How many items a line holds. One, the default, is a list; more lays the
@@ -18728,6 +18821,13 @@ and scrolls it sideways: Left and Right move between items, the other
 way round on a right-to-left page, and `estimate` is an item's width. A
 grid always runs down. */
   orientation?: (HelixHeadlessVirtualList["orientation"]) | undefined;
+  /** Lets a reader move items, once `@fusion.dev/helix/virtual-list/reorder`
+(or `@fusion.dev/helix-headless/virtual-list/reorder`) is imported: Alt
+with an arrow moves the row the keys are on, and a pointer drags a row.
+The list moves no item itself: you move your `items` on `helix-reorder`.
+Without that import it does nothing, so a list that never moves items
+carries none of the code. A list of one column, without sections. */
+  reorderable?: (HelixHeadlessVirtualList["reorderable"]) | undefined;
   /** The field of each item that names its section, as a key or a path of
 keys. Set, the items are drawn in sections: a header, then the items, in
 an element with the `group` role that the header names. A section starts
@@ -18793,10 +18893,14 @@ export type HelixHeadlessVirtualListVueEvents = {
   change: HelixHeadlessVirtualListElementEvent;
   /** Fired before a press or a key changes which items are selected, with the `value` it would leave. Cancelable. */
   "helix-before-change": HelixHeadlessVirtualListHelixBeforeChangeElementEvent;
+  /** Fired when an item is dropped at a new place, in a `reorderable` list with `@fusion.dev/helix/virtual-list/reorder` imported, with every key in the new order. Cancelable: cancel it to keep the item where it is. */
+  "helix-before-reorder": HelixHeadlessVirtualListHelixBeforeReorderElementEvent;
   /** Fired when a reader comes within one screen of the last item, once for each length of the set. */
   "helix-load-more": HelixHeadlessVirtualListHelixLoadMoreElementEvent;
   /** Fired when the items on screen change, with the new `first` and `last`, which `range` also holds. */
   "helix-range-change": HelixHeadlessVirtualListHelixRangeChangeElementEvent;
+  /** Fired after `helix-before-reorder` when nobody canceled it. Set `items` to the order in `keys`. Cancelable: cancel it to say the move did not happen. */
+  "helix-reorder": HelixHeadlessVirtualListHelixReorderElementEvent;
 };
 
 export type CustomCssProperties = {
@@ -19070,7 +19174,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessBreadcrumbsVueProps,
     HelixHeadlessBreadcrumbsVueEvents
   >;
-  /** Sets 'role="group"' on the host through internals, and 'label' names the group. Without a name, a screen reader announces the buttons as separate controls, and a development build warns once with the kind 'missing-name'.  The group does not manage focus, so each button keeps its own tab stop. For one tab stop with arrow keys between a mix of controls, the APG toolbar pattern, use Toolbar.  Buttons are slotted, so they stay your own elements and keep their own appearance and size.  **Buttons that stay pressed.** With 'selection-mode', each button with a 'value' is a toggle button: a press presses or releases it. 'multiple' lets any number be pressed, and each button says so with 'aria-pressed'. 'single' keeps one pressed at a time: the group is a 'radiogroup' and each button a 'radio' that says so with 'aria-checked', as React Aria's toggle button group is. A press on the pressed one releases it, unless 'disallow-empty-selection' keeps one pressed. 'value' is the pressed values, comma separated. A press sends a cancelable 'helix-before-change' with the value it would leave, then 'change'. A pressed Helix button has ':state(pressed)' on its own element.  The pressed state is written on the control inside each button's shadow root, so the markup you rendered is never changed and a framework hydrating it sees what its server sent. That is also why only Helix buttons are toggles: a native '<button>' or a button without a 'value' stays a plain action button in the group, and a native one without its own 'aria-pressed' warns once, with the runtime kind 'untold-toggle'. The inner control also carries '--button-group-pressed', '1' or '0', for a '::part(button)' rule of yours.  Use Toggle Group instead for a choice that belongs in a form, or one where the arrow keys choose as they move: it is a 'radiogroup' of options with a form value, 'required' and validation. A Button Group in a selection mode is a set of actions that stay on, such as bold and italic, or a view that a press switches, and it submits nothing.  **Keyboard.** In a selection mode the group is one tab stop: the button focus was last on, then the first pressed one, then the first one.  | Key | What it does | |---|---| | Right, Down | Moves to the next button, from the last back to the first. | | Left, Up | Moves to the button before, from the first round to the last. | | Home, End | Moves to the first or the last button. | | Space, Enter | Presses or releases the focused button. |  Left and Right swap on a right-to-left page, and a disabled button is passed over. Under 'multiple' the group is a 'toolbar', with 'aria-orientation' under 'orientation="vertical"'. Inside a toolbar it stays a named 'group', and the toolbar's own arrow keys walk its buttons, so a reader meets one toolbar. Under 'single' it is a 'radiogroup' either way. */
+  /** Sets 'role="group"' on the host through internals, and 'label' names the group. Without a name, a screen reader announces the buttons as separate controls, and a development build warns once with the kind 'missing-name'.  The group does not manage focus, so each button keeps its own tab stop. For one tab stop with arrow keys between a mix of controls, the APG toolbar pattern, use Toolbar.  Buttons are slotted, so they stay your own elements and keep their own appearance and size.  **Buttons that stay pressed.** With 'selection-mode', each button with a 'value' is a toggle button: a press presses or releases it. 'multiple' lets any number be pressed, and each button says so with 'aria-pressed'. 'single' keeps one pressed at a time: the group is a 'radiogroup' and each button a 'radio' that says so with 'aria-checked', as React Aria's toggle button group is. A press on the pressed one releases it, unless 'disallow-empty-selection' keeps one pressed. 'value' is the pressed values, comma separated. A press sends a cancelable 'helix-before-change' with the value it would leave, then 'change'. A pressed Helix button has ':state(pressed)' on its own element.  The pressed state is written on the control inside each button's shadow root, so the markup you rendered is never changed and a framework hydrating it sees what its server sent. That is also why only Helix buttons are toggles: a native '<button>' or a button without a 'value' stays a plain action button in the group, and a native one without its own 'aria-pressed' warns once, with the runtime kind 'untold-toggle'. The inner control also carries '--button-group-pressed', '1' or '0', for a '::part(button)' rule of yours.  Use Toggle Group instead for a choice that belongs in a form, or one where the arrow keys choose as they move: it is a 'radiogroup' of options with a form value, 'required' and validation. A Button Group in a selection mode is a set of actions that stay on, such as bold and italic, or a view that a press switches, and it submits nothing.  **Keyboard.** In a selection mode the group is one tab stop: the button focus was last on, then the first pressed one, then the first one.  | Key | What it does | |---|---| | Right, Down | Moves to the next button, from the last back to the first. | | Left, Up | Moves to the button before, from the first round to the last. | | Home, End | Moves to the first or the last button. | | Space, Enter | Presses or releases the focused button. |  Left and Right swap on a right-to-left page, and a disabled button is passed over. Under 'multiple' the group is a 'toolbar', with 'aria-orientation' under 'orientation="vertical"'. Inside a toolbar it stays a named 'group', and the toolbar's own arrow keys walk its buttons, so a reader meets one toolbar. Under 'single' it is a 'radiogroup' either way.  **Disabled.** 'disabled' on the group disables every button in it, Helix and native alike, and says so on the group with 'aria-disabled', as React Aria's 'isDisabled' does. A button disabled on its own stays disabled when the group is enabled again, and a button that leaves the group gets back what it said for itself. */
   "helix-headless-button-group": DefineCustomElement<
     HelixHeadlessButtonGroup,
     HelixHeadlessButtonGroupVueProps,
@@ -19184,7 +19288,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessCommandVueProps,
     HelixHeadlessCommandVueEvents
   >;
-  /** Copies text to the clipboard and confirms the copy. The platform gives no feedback for a clipboard write, so without a confirmation a press that copies looks the same as one that fails.  The confirmation and the event wait for the write to finish. The browser can refuse a clipboard write, for example on an insecure origin, in a document that is not focused, or after a gesture that does not qualify. A refused write, or nothing to copy, names the button with 'error-label' for the same moment a copy shows 'copied-label', draws a cross, and sends 'helix-copy-error'.  'from' copies from another element on the page: its text, an attribute written 'id[attribute]', or a property written 'id.property', read at the press. It takes the place of 'value'.  It replaces Button's render and its press, so it never submits a form or sends a command: 'type', 'command', 'commandfor' and the 'form*' overrides have no effect, and the 'start' and 'end' slots and the 'text' part are not rendered. An 'aria-label' on the element names it before a copy, in place of 'label'.  **Keyboard.** Enter and Space copy, as they press a native button.  The button is named 'label', or the host's 'aria-label', and its name changes to 'copied-label' or 'error-label' for the moment after a press. The same words are said in a live region, so a screen reader hears the result, and the tooltip shows them. */
+  /** Copies text to the clipboard and confirms the copy. The platform gives no feedback for a clipboard write, so without a confirmation a press that copies looks the same as one that fails.  The confirmation and the event wait for the write to finish. The browser can refuse a clipboard write, for example on an insecure origin, in a document that is not focused, or after a gesture that does not qualify. A refused write, or nothing to copy, names the button with 'error-label' for the same moment a copy shows 'copied-label', draws a cross, and sends 'helix-copy-error'.  'from' copies from another element on the page: its text, an attribute written 'id[attribute]', or a property written 'id.property', read at the press. It takes the place of 'value'.  It replaces Button's render and its press, so it never submits a form or sends a command: 'type', 'command', 'commandfor' and the 'form*' overrides have no effect, and the 'start' and 'end' slots and the 'text' part are not rendered. An 'aria-label' on the element names it before a copy, in place of 'label'.  **Keyboard.** Enter and Space copy, as they press a native button.  The button is named 'label', or the host's 'aria-label', and its name changes to 'copied-label' or 'error-label' for the moment after a press. The same words are said in a live region, so a screen reader hears the result, and the tooltip shows them. The tooltip does not also describe the button, since its words are the button's name.  **The tooltip.** It shows the name on hover and focus and the result after a press. 'tooltip="copy"' shows it only for the result, and 'tooltip="none"' draws none, as Web Awesome's copy button offers. 'tooltip-placement' is the side it prefers, and it moves to another side where that one does not fit.  **Words on the button.** 'show-label' draws the name beside the icon, and the result in its place after a press. The button is as wide as the longest of the three, so a press does not resize it. */
   "helix-headless-copy-button": DefineCustomElement<
     HelixHeadlessCopyButton,
     HelixHeadlessCopyButtonVueProps,
@@ -19544,7 +19648,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessOptionSeparatorVueProps,
     HelixHeadlessOptionSeparatorVueEvents
   >;
-  /** Outline is a table of contents for a document. 'Navigation' does the same job for a site.  The links are your own anchors. A router renders its own '<a>' and cannot render one inside the outline's shadow root, and the hrefs are fragments on the same page.  Write the anchors flat, with 'data-level' for their depth, or nested in lists, '<ul><li><a>'. A screen reader hears the levels either way: the outline puts a flat run into lists inside list items of its own, nested by 'data-level', and leaves the links where they are. A link without 'data-level' is at the top level.  A heading slotted into 'heading' names the navigation, in place of 'label'.  In a contents rail with a scrollbar of its own, 'follow' keeps the link of the section in view showing as the reader scrolls the page.  **Keyboard.** The links are your anchors, in the tab order as you wrote them, so the outline adds no keys of its own: Tab moves through the links and Enter follows one. Following a link moves focus to its section, so the next Tab goes on from the heading, also with 'behavior' set.  **What a screen reader hears.** A navigation landmark named by 'label', "On this page", or by the slotted heading. The links are lists, nested by level, so a reader hears how many links a level holds and where each one is. The link to the section in view carries 'aria-current="location"', read as "current location", and it moves as the page scrolls without announcing, which would interrupt the reading it follows.  The current section is decided by the headings' positions. An 'IntersectionObserver' with a band near the top fails both ways: when headings are far apart, none is in the band and no section is marked, and when they are close together, several are in the band at once. */
+  /** Outline is a table of contents for a document. 'Navigation' does the same job for a site.  The links are your own anchors. A router renders its own '<a>' and cannot render one inside the outline's shadow root, and the hrefs are fragments on the same page.  Write the anchors flat, with 'data-level' for their depth, or nested in lists, '<ul><li><a>'. A screen reader hears the levels either way: the outline puts a flat run into lists inside list items of its own, nested by 'data-level', and leaves the links where they are. A link without 'data-level' is at the top level.  A heading slotted into 'heading' names the navigation, in place of 'label'.  In a contents rail with a scrollbar of its own, 'follow' keeps the link of the section in view showing as the reader scrolls the page.  **Keyboard.** The links are your anchors, in the tab order as you wrote them, so the outline adds no keys of its own: Tab moves through the links and Enter follows one. Following a link moves focus to its section, so the next Tab goes on from the heading, also with 'behavior' set.  **What a screen reader hears.** A navigation landmark named by 'label', "On this page", or by the slotted heading. The links are lists, nested by level, so a reader hears how many links a level holds and where each one is. The link to the section in view carries 'aria-current="location"', read as "current location", and it moves as the page scrolls without announcing, which would interrupt the reading it follows.  The current section is decided by the headings' positions. An 'IntersectionObserver' with a band near the top fails both ways: when headings are far apart, none is in the band and no section is marked, and when they are close together, several are in the band at once.  **Several sections at once.** 'marks="visible"' marks the link of every section with part of it on screen, from the reading line to the bottom of what the sections scroll in, as Zag's table of contents marks its active ids. The mark then runs from the first of those links to the last, and 'marked' lists their ids in page order.  **Going to a section from code.** 'scrollToSection(id)' scrolls to the section as a press on its link does, with 'behavior', and marks its link at once.  **Styling a link by its state.** Each link the outline finds carries 'data-depth', its depth in the outline from '1', nested lists and 'data-level' alike, and 'aria-current="location"' while its section is marked, so 'a[aria-current]' and 'a[data-depth="2"]' are the hooks for a rule of yours. */
   "helix-headless-outline": DefineCustomElement<
     HelixHeadlessOutline,
     HelixHeadlessOutlineVueProps,
@@ -19676,7 +19780,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessSpeedDialVueProps,
     HelixHeadlessSpeedDialVueEvents
   >;
-  /** A splitter has one axis. Nest splitters to get two axes and three-pane or four-pane layouts.  When a splitter is slotted into a pane of another at a right angle, a corner handle appears where the dividers cross. It shows the 'move' cursor, responds to both arrow axes, and a drag moves both dividers at once. The corner is added at 'firstUpdated' and is not in the server markup. Before it appears, both dividers work on their own.  The divider has 'role="separator"' and 'aria-valuenow', with 'aria-valuetext' saying the start pane's share as a percentage in the nearest 'lang', or in the reader's locale where no 'lang' is set, and 'aria-controls' names the start pane. Drag it with a pointer or move it with the arrow keys, press 'Home' or 'End' to move it to its bounds, and press 'Enter' to collapse the start pane and open it again. A drag in progress is tracked as a state, so both dividers a corner moves stay lit for as long as they move.  By default, 'min' and 'max' let the divider reach either edge, so you can drag a pane fully closed. Set them to limit the range.  A pane can be collapsed, which is a separate state from a divider at the edge. 'collapsed' names the shut pane, 'start' or 'end', and the pane opens back to the position where the collapsing gesture began. A drag records that position on press, and every other way of collapsing records it in 'settle'. 'collapsed-size' keeps a sliver of the pane visible, such as a tab strip. Collapsing overrides 'min' and 'max'.  Set 'primary' to the pane that keeps its size when the splitter's own size changes, such as a sidebar beside a window being resized. The other pane takes all of the change, as Web Awesome's split panel does. Without it, both panes keep their share.  **Three or more panes along one axis are splitters nested on that axis**, a splitter in the 'end' pane of another for three columns. The nested one keeps the pane on its far side the size it was while the outer divider moves, so a divider resizes only the two panes beside it, as Zag's splitter does with any number of panels. Where the whole row is resized, every pane keeps its share, unless 'primary' says otherwise.  **Keyboard.** The divider is one tab stop.  | Key | What it does | |---|---| | Left, Right | Moves a side-by-side divider by 'step'. On a right-to-left page, Left moves it toward the end. | | Up, Down | Moves a stacked divider by 'step'. | | Home, End | Moves the divider to its bounds. | | Enter | Collapses the start pane, and opens it again. | | F6 | Moves focus from one pane to the first control in the other, and from the divider to the start pane. | */
+  /** A splitter has one axis. Nest splitters to get two axes and three-pane or four-pane layouts.  When a splitter is slotted into a pane of another at a right angle, a corner handle appears where the dividers cross. It shows the 'move' cursor, responds to both arrow axes, and a drag moves both dividers at once. The corner is added at 'firstUpdated' and is not in the server markup. Before it appears, both dividers work on their own.  The divider has 'role="separator"' and 'aria-valuenow', with 'aria-valuetext' saying the start pane's share as a percentage in the nearest 'lang', or in the reader's locale where no 'lang' is set, and 'aria-controls' names the start pane. Drag it with a pointer or move it with the arrow keys, press 'Home' or 'End' to move it to its bounds, and press 'Enter' to collapse the start pane and open it again. A drag in progress is tracked as a state, so both dividers a corner moves stay lit for as long as they move.  By default, 'min' and 'max' let the divider reach either edge, so you can drag a pane fully closed. Set them to limit the range.  A pane can be collapsed, which is a separate state from a divider at the edge. 'collapsed' names the shut pane, 'start' or 'end', and the pane opens back to the position where the collapsing gesture began. A drag records that position on press, and every other way of collapsing records it in 'settle'. 'collapsed-size' keeps a sliver of the pane visible, such as a tab strip. Collapsing overrides 'min' and 'max'. 'collapsible' says which panes can be collapsed at all, as Zag's panels each say.  'min' is the least the start pane keeps and 'end-min' the least the end pane keeps, each a percentage or a CSS length such as '16rem'.  Set 'primary' to the pane that keeps its size when the splitter's own size changes, such as a sidebar beside a window being resized. The other pane takes all of the change, as Web Awesome's split panel does. Without it, both panes keep their share.  **Three or more panes along one axis are splitters nested on that axis**, a splitter in the 'end' pane of another for three columns. The nested one keeps the pane on its far side the size it was while the outer divider moves, so a divider resizes only the two panes beside it, as Zag's splitter does with any number of panels. Where the whole row is resized, every pane keeps its share, unless 'primary' says otherwise.  **Keyboard.** The divider is one tab stop.  | Key | What it does | |---|---| | Left, Right | Moves a side-by-side divider by 'step'. On a right-to-left page, Left moves it toward the end. | | Up, Down | Moves a stacked divider by 'step'. | | Home, End | Moves the divider to its bounds. | | Enter | Collapses the start pane, or the end pane where 'collapsible="end"', and opens it again. | | F6 | Moves focus from one pane to the first control in the other, and from the divider to the start pane. | */
   "helix-headless-splitter": DefineCustomElement<
     HelixHeadlessSplitter,
     HelixHeadlessSplitterVueProps,
@@ -19754,13 +19858,13 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessTabVueProps,
     HelixHeadlessTabVueEvents
   >;
-  /** A part of 'Tag' that holds tags as one control: a grid of rows, one tab stop for the whole set. The arrow keys move between tags, Home and End go to the first and the last, and a typed letter goes to the next tag starting with it. Delete or Backspace removes the focused tag where it is 'dismissible', by sending its 'helix-dismiss': remove it from your list in the handler, and focus moves to the next tag, or the previous one after the last.  'selection-mode' lets a reader select tags, with Space, Enter or a press: 'single' selects one at a time and 'multiple' any number. In 'multiple', Shift with an arrow, Home or End selects the range from the tag last pressed to the tag focus moves to, Shift with a press or Space selects the range to that tag, and Control or Command with A selects every tag that is not disabled. 'selection-behavior="replace"' selects the tag a reader presses or moves to alone, as a file list does, and Control or Command with a press or Space adds or takes out one tag. 'disallow-empty-selection' keeps one tag selected once one is. 'value' holds the selected tags' values, separated by commas, and a change asks with 'helix-before-change' and tells with 'change'. Enter on a tag with an 'href' follows its link. A 'disabled' tag is passed over. A selected tag that is removed leaves 'value', which then sends 'change'.  Name the set with 'label'. Each tag is named by its words alone, without its remove button. 'value' takes an array of values on the property as well, as React sets 'value={['Apple']}'; a press writes it back as a string.  **Removing the last tag keeps focus in the group.** With no tags left the set is a 'group', and focus moves to its 'empty' part, which holds the 'empty' slot: put words there such as "No filters" for a reader to hear. With nothing slotted it says 'empty-label', "No tags". Where only disabled tags are left, the first of them holds the tab stop and takes focus, so the reader stays in the set. */
+  /** A part of 'Tag' that holds tags as one control: a grid of rows, one tab stop for the whole set. The arrow keys move between tags, Home and End go to the first and the last, and a typed letter goes to the next tag starting with it. Delete or Backspace removes the focused tag where it is 'dismissible', by sending its 'helix-dismiss': remove it from your list in the handler, and focus moves to the next tag, or the previous one after the last.  'selection-mode' lets a reader select tags, with Space, Enter or a press: 'single' selects one at a time and 'multiple' any number. In 'multiple', Shift with an arrow, Home or End selects the range from the tag last pressed to the tag focus moves to, Shift with a press or Space selects the range to that tag, and Control or Command with A selects every tag that is not disabled. 'selection-behavior="replace"' selects the tag a reader presses or moves to alone, as a file list does, and Control or Command with a press or Space adds or takes out one tag. 'disallow-empty-selection' keeps one tag selected once one is, and Escape lets go of the selection otherwise. 'value' holds the selected tags' values, separated by commas, and a change asks with 'helix-before-change' and tells with 'change'. Enter on a tag with an 'href' follows its link. A 'disabled' tag is passed over. A selected tag that is removed leaves 'value', which then sends 'change'.  Name the set with 'label'. Each tag is named by its words alone, without its remove button. 'value' takes an array of values on the property as well, as React sets 'value={['Apple']}'; a press writes it back as a string.  **Removing the last tag keeps focus in the group.** With no tags left the set is a 'group', and focus moves to its 'empty' part, which holds the 'empty' slot: put words there such as "No filters" for a reader to hear. With nothing slotted it says 'empty-label', "No tags". Where only disabled tags are left, the first of them holds the tab stop and takes focus, so the reader stays in the set.  **Typing new tags.** A field where people type tags and press Enter to add each one is Combobox with 'multiple' and 'allows-custom-value', or 'creatable' to ask first with 'helix-create'. It draws each value as a tag, Backspace on the empty field removes the last one, and the arrow keys move between them. */
   "helix-headless-tag-group": DefineCustomElement<
     HelixHeadlessTagGroup,
     HelixHeadlessTagGroupVueProps,
     HelixHeadlessTagGroupVueEvents
   >;
-  /** A label that people can optionally remove. 'dismissible' is the difference from a badge: a badge shows a state that people cannot change, and a tag names something they can remove.  The remove button sends 'helix-dismiss'. The tag does not remove itself, because your code owns the list it is in, so remove it in your handler. A listener can cancel 'helix-dismiss', and 'dismiss()' then returns 'false'. When the handler removes a tag whose remove button has focus, focus moves to the next tag's remove button, or to the previous one's after the last tag.  The remove button is named for its tag, such as "Remove Apple", so a list of buttons says which tag each one removes. Write '{label}' in 'dismiss-label' to put the tag's words somewhere else, such as 'dismiss-label="{label} entfernen"'.  'href' makes the label a link, and 'disabled' takes the tag out of reach: its link and its remove button stop answering.  **In a 'Tag.Group' a tag is a row of a grid.** The group gives it its role, its place in the one tab stop and, where the group selects, whether it is selected. Its remove button leaves the tab order there, Delete and Backspace doing its job from the row. */
+  /** A label that people can optionally remove. 'dismissible' is the difference from a badge: a badge shows a state that people cannot change, and a tag names something they can remove.  The remove button sends 'helix-dismiss'. The tag does not remove itself, because your code owns the list it is in, so remove it in your handler. A listener can cancel 'helix-dismiss', and 'dismiss()' then returns 'false'. When the handler removes a tag whose remove button has focus, focus moves to the next tag's remove button, or to the previous one's after the last tag.  The remove button is named for its tag, such as "Remove Apple", so a list of buttons says which tag each one removes. Write '{label}' in 'dismiss-label' to put the tag's words somewhere else, such as 'dismiss-label="{label} entfernen"'.  'href' makes the label a link, and 'disabled' takes the tag out of reach: its link and its remove button stop answering.  **In a 'Tag.Group' a tag is a row of a grid.** The group gives it its role, its place in the one tab stop and, where the group selects, whether it is selected. Its remove button leaves the tab order there, Delete and Backspace doing its job from the row.  **Styling a tag by what is happening to it.** ':state(selected)' while it is selected, ':state(focus-visible)' while its cell shows keyboard focus, '[disabled]' while it is out of reach, and the host's own ':hover' and ':active' under the pointer, as React Aria's 'data-hovered' and 'data-pressed' are. */
   "helix-headless-tag": DefineCustomElement<
     HelixHeadlessTag,
     HelixHeadlessTagVueProps,
@@ -19790,13 +19894,13 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessTimelineGroupVueProps,
     HelixHeadlessTimelineGroupVueEvents
   >;
-  /** Given 'datetime', the label you write is wrapped in a '<time>' element, so a machine-readable value such as "2026-08-19" travels with a label such as "yesterday". Without 'datetime', the label is a '<span>'.  **'relative' writes the time for you** as how long ago it was, such as "3 hours ago", from 'datetime', where the 'time' slot is empty. The words move on as they go stale, "3 hours ago" becoming "4 hours ago", with one wakeup shared by every reading on the page, as 'FormatDate' keeps its own. They are in the language of the page, or of the nearest 'lang'.  Each entry draws the connector line that arrives at it and hides it when it is the first entry, using ':host(:first-child)'. This needs no index, no counting parent, and no script. 'Steps' and 'Breadcrumbs' work the same way.  'tone' sets the kind of event and is the only thing that colors the mark. It uses the same values as 'Announcement'. **A screen reader hears the tone as a word**, from 'tone-labels': the mark is an image named "Error", "Information", "Success" or "Warning", so the color is not the only place the meaning is. 'neutral' and 'primary' say nothing unless you name them.  **'pending' marks an event that has not happened yet**, such as one that is scheduled. The mark is the open circle, and a screen reader hears 'pending-label', "Scheduled", with the tone's word. */
+  /** Given 'datetime', the label you write is wrapped in a '<time>' element, so a machine-readable value such as "2026-08-19" travels with a label such as "yesterday". Without 'datetime', the label is a '<span>'.  **'relative' writes the time for you** as how long ago it was, such as "3 hours ago", from 'datetime', where the 'time' slot is empty. The words move on as they go stale, "3 hours ago" becoming "4 hours ago", with one wakeup shared by every reading on the page, as 'FormatDate' keeps its own. They are in the language of the page, or of the nearest 'lang'. The whole date and time is the reading's 'title', so a pointer resting on "3 hours ago" shows when it was, and a screen reader reads it as the description.  Each entry draws the connector line that arrives at it and hides it when it is the first entry, using ':host(:first-child)'. This needs no index, no counting parent, and no script. 'Steps' and 'Breadcrumbs' work the same way.  'tone' sets the kind of event and is the only thing that colors the mark. It uses the same values as 'Announcement'. **A screen reader hears the tone as a word**, from 'tone-labels': the mark is an image named "Error", "Information", "Success" or "Warning", so the color is not the only place the meaning is. 'neutral' and 'primary' say nothing unless you name them.  **'pending' marks an event that has not happened yet**, such as one that is scheduled. The mark is the open circle, and a screen reader hears 'pending-label', "Scheduled", with the tone's word. */
   "helix-headless-timeline-item": DefineCustomElement<
     HelixHeadlessTimelineItem,
     HelixHeadlessTimelineItemVueProps,
     HelixHeadlessTimelineItemVueEvents
   >;
-  /** A timeline is a record of events that happened or are scheduled. Each entry carries a time, and no entry is current or complete. For a process you move through, with a current stage and 'active' and 'complete' states, use 'Steps'.  Each entry draws the connector line that arrives at it and hides it when it is first, using ':host(:first-child)'. This resolves at layout with no script, so the server markup is correct before anything runs.  The host has 'role="list"', because the entries are your elements in the light DOM. 'Steps' does the same.  **Group entries by date with 'Timeline.Group'**, which puts a heading such as "Today" over its entries. The group is an entry of the timeline, and its entries are a list of their own named by the heading.  **The reading order is the order you write the entries in**, in every layout the styled tier draws: down the page, either side of a line down the middle, or across the page. Inside each entry the time is read before what happened. Write the entries in the order the events happened, oldest or newest first, and the layout only moves where they are drawn. */
+  /** A timeline is a record of events that happened or are scheduled. Each entry carries a time, and no entry is current or complete. For a process you move through, with a current stage and 'active' and 'complete' states, use 'Steps'.  Each entry draws the connector line that arrives at it and hides it when it is first, using ':host(:first-child)'. This resolves at layout with no script, so the server markup is correct before anything runs.  The host has 'role="list"', because the entries are your elements in the light DOM. 'Steps' does the same.  **Group entries by date with 'Timeline.Group'**, which puts a heading such as "Today" over its entries. The group is an entry of the timeline, and its entries are a list of their own named by the heading.  **The reading order is the order you write the entries in**, in every layout the styled tier draws: down the page, either side of a line down the middle, or across the page. Inside each entry the time is read before what happened. Write the entries in the order the events happened, oldest or newest first, and the layout only moves where they are drawn.  **A feed that loads more entries sets 'loading' while it fetches.** The timeline is busy, and an entry after the last says "Loading more" ('loading-label', or your own content in the 'loading' slot). Put a button that asks for more after the timeline, and move focus to the first new entry when they arrive. */
   "helix-headless-timeline": DefineCustomElement<
     HelixHeadlessTimeline,
     HelixHeadlessTimelineVueProps,
@@ -19832,7 +19936,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessToolbarVueProps,
     HelixHeadlessToolbarVueEvents
   >;
-  /** The trigger stays your own element. The bubble renders in the top layer through the popover API, so an ancestor with 'overflow: hidden' does not clip it and no 'z-index' is needed. 'FloatingController' positions it and flips it to another side when the preferred side does not fit.  **Place the tooltip beside its trigger, name the trigger with 'for', and name the tooltip in the trigger's 'aria-describedby'.** The description is then in your own markup, so it is in the server's HTML and in the accessibility tree at rest, in every browser, before anyone points at the trigger or focuses it:  '''html <helix-headless-button aria-describedby="save-tip" id="save">Save</helix-headless-button> <helix-headless-tooltip content="Save your work" for="save" id="save-tip"></helix-headless-tooltip> '''  Without the attribute, the tooltip links itself through an element reference on the control that takes focus, and it never writes into your markup before you act, so hydration stays intact. A trigger that is a Helix component is described at once, inside its own shadow root. A plain element in your markup is described when you first point at it or focus it, so a screen reader in reading mode meets it with no description until then. Where the browser has no element references, nothing links the two, and the tooltip warns once on first open. The tooltip can also wrap its trigger, which describes a Helix component and leaves a plain element undescribed. In the 'for' form the tooltip itself is out of the accessibility tree while its bubble is down, so you meet its words once, as the trigger's description.  The tooltip shows on hover and on focus. It hides on pointer leave, on blur, on Escape, and when the trigger is activated. The pointer can move from the trigger onto the bubble and the bubble stays, unless you set 'hoverable="false"'. 'delay' is how long the pointer rests before it shows, and 'delay-out' how long it stays once the pointer leaves.  Once one tooltip is showing, moving to another trigger shows its tooltip with no 'delay', and the first one hides. The same holds for 'skip-delay' milliseconds after a tooltip hides, 300 unless you set it. 'show-on="focus"' shows the tooltip on keyboard focus only, for a hint a pointer does not need. */
+  /** The trigger stays your own element. The bubble renders in the top layer through the popover API, so an ancestor with 'overflow: hidden' does not clip it and no 'z-index' is needed. 'FloatingController' positions it and flips it to another side when the preferred side does not fit.  **Place the tooltip beside its trigger, name the trigger with 'for', and name the tooltip in the trigger's 'aria-describedby'.** The description is then in your own markup, so it is in the server's HTML and in the accessibility tree at rest, in every browser, before anyone points at the trigger or focuses it:  '''html <helix-headless-button aria-describedby="save-tip" id="save">Save</helix-headless-button> <helix-headless-tooltip content="Save your work" for="save" id="save-tip"></helix-headless-tooltip> '''  Without the attribute, the tooltip links itself through an element reference on the control that takes focus, and it never writes into your markup before you act, so hydration stays intact. A trigger that is a Helix component is described at once, inside its own shadow root. A plain element in your markup is described when you first point at it or focus it, so a screen reader in reading mode meets it with no description until then. Where the browser has no element references, nothing links the two, and the tooltip warns once on first open. The tooltip can also wrap its trigger, which describes a Helix component and leaves a plain element undescribed. In the 'for' form the tooltip itself is out of the accessibility tree while its bubble is down, so you meet its words once, as the trigger's description. A trigger whose name is already the tooltip's words, such as an icon button named Settings under a tooltip reading Settings, is not described by them again.  The tooltip shows on hover and on focus. It hides on pointer leave, on blur, on Escape, and when the trigger is activated. The pointer can move from the trigger onto the bubble and the bubble stays, unless you set 'hoverable="false"'. 'delay' is how long the pointer rests before it shows, and 'delay-out' how long it stays once the pointer leaves.  Once one tooltip is showing, moving to another trigger shows its tooltip with no 'delay', and the first one hides. The same holds for 'skip-delay' milliseconds after a tooltip hides, 300 unless you set it. 'show-on="focus"' shows the tooltip on keyboard focus only, for a hint a pointer does not need. */
   "helix-headless-tooltip": DefineCustomElement<
     HelixHeadlessTooltip,
     HelixHeadlessTooltipVueProps,
@@ -19892,7 +19996,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessVideoVueProps,
     HelixHeadlessVideoVueEvents
   >;
-  /** The items arrive as data, in one of two ways:  - 'items' takes an array. A framework sets it as a property, and React   hydration keeps it. - 'for' names a '<script type="application/json">' that holds an array, which   a server sends as markup.  Each item is drawn into a row in one of two ways:  - 'renderItem' is a function from an item and its index to the row's   content: a Lit template, a string, or a DOM node. - A '<template>' child defines one row. 'data-field="name"' fills an element   with the item's 'name' as text, and 'data-field-href="url"' writes the   item's 'url' into 'href', the same for any attribute. A field may be a path   of keys, such as 'author.name'.  Rows are your markup in the light DOM, so your stylesheet styles them.  **A grid.** 'columns' lays the items out that many to a line, as a grid of equal columns, and windows the set a line at a time, as React Aria's grid layout does. Each item draws one element, a cell of the grid, and 'estimate' is the height of a line. 'min-column-width' lays out as many columns as fit the box instead, as React Aria's grid layout does with its smallest item size, and follows the box as it resizes. 'gap' spaces the rows, and the columns of a grid, by a number of pixels the list counts in each row's place.  **Across.** 'orientation="horizontal"' lays the items out along a line and scrolls it sideways, as a strip of cards does, windowed the same way: 'estimate' is then an item's width, and the box needs an inline size.  **Sections.** 'section-field' names the field of each item that says which section it is in, and the list draws a header before each section's items, as React Aria's list box sections do. Each section is an element with the 'group' role, named by its header, which is its first child and carries 'data-header', so your stylesheet styles it, such as with 'position: sticky'. A section starts wherever the field changes, so give the items in order. The window counts the headers with the items, and a section the window starts inside is drawn with its header. 'renderSection' draws a header of your own.  **Keyboard.** The list is one tab stop.  | Key | What it does | |---|---| | Down, Up | Moves to the next or the previous item, or in a grid to the item in the same column on the next or the previous line. | | Right, Left | In a grid, moves to the next or the previous item along the line, the other way round on a right-to-left page. In a list that runs across, moves to the next or the previous item the same way, and Down and Up are left to the row. | | Home, End | Moves to the first or the last item. | | Page Down, Page Up | Moves by the number of items, or of lines in a grid, on screen. | | A letter or a word | Moves to the next item whose text starts with what you typed. | | Escape | Lets go of every chosen item, in a list with 'selection-mode'. | | Tab | Moves into the focused row's own links and buttons, then out of the list. |  An item that is not drawn is scrolled into view and focused, so a keyboard reaches the whole set. When the row holding the tab stop scrolls away, the stop moves to the first row on screen. Typing matches each item's 'text-field', which is the first 'data-field' of the row template by default, or the item itself when it is a string or a number.  Each row says its place in the whole set with 'aria-posinset' and 'aria-setsize', so a screen reader says "4,000 of 10,000". The row holding focus stays drawn when it scrolls out.  **Selecting.** 'selection-mode' makes the list a list box a reader chooses from: 'single' selects one item and 'multiple' any number. Space or a press selects an item, Shift with Space, an arrow, Home, End or a press takes in the items from the last one chosen, and Control or Command with A selects them all, in 'multiple'. Escape lets go of every chosen item, and keeps the key from the dialog or menu around the list while there was something to let go of. 'value' holds the chosen items' keys, separated by commas, in the order of the set: 'key-field' names each item's key, and a string or a number item is its own key. A change asks with 'helix-before-change' and tells with 'change'. Each row is an 'option' marked 'aria-selected', so a row's own links and buttons are not reached there: keep those to a list without 'selection-mode'.  'selection-behavior="replace"' selects the item pressed alone, as a file list does, and the arrow keys carry the selection with them. Control or Command with a press or with Space adds or takes out one item, and with an arrow moves without selecting.  **Disabled items.** 'disabled-keys' names items by their keys, separated by commas. Their rows carry 'aria-disabled', the keys and typing pass over them, and a press, Space, or Control with A does not select them.  **Rows a stylesheet can tell apart.** A chosen row carries 'data-selected', a disabled one 'data-disabled', as React Aria's rows do, and the row the keys are on, which holds the tab stop, 'data-active', whether or not the list has focus.  **Loading more.** 'helix-range-change' fires as the items on screen change, and 'range' holds them. 'helix-load-more' fires once a reader is within one screen of the end, once for each length of the set: add to 'items' and it can fire again. While you fetch, set 'loading': the list is busy, and a row after the last item says "Loading more" ('loading-label', or your own content in the 'loading' slot). 'scrollToIndex' takes a reader to an item.  **An empty list.** Set 'empty-label', or put your own content in the 'empty' slot, for a row shown when there are no items and none are loading, such as "No messages yet" and a link to write one. Without either, an empty list shows nothing, since a list whose items have not arrived yet has not said it has none.  The list takes the 'empty' state while it has read its items and holds none, and the 'loading' state while 'loading' is set, so your stylesheet can change the box around it for either. A list with no name is reported once in a development build. Name it with 'label' or 'aria-label'.  **Row height.** Rows are placed by 'estimate' until they are drawn. Then the list reads the drawn rows' height once and places every row by it, so a wrong estimate still reaches the last item. Set 'measured' for rows of different heights. Once the list draws rows of different heights, such as rows that wrap on a narrow screen, it places each row by its own height whether 'measured' is set or not.  The list follows its source. A new 'items' array, an edit to the script's text, or a script replaced under the same id draws the new rows. A row that stays in view keeps its element as the list scrolls.  The viewport scrolls on this tier. It carries 'data-scroller', and 'core' ships '[data-scroller] { overflow: auto }' into every shadow root, so 'scrollTop' works with no stylesheet. You still need to set a block size. */
+  /** The items arrive as data, in one of two ways:  - 'items' takes an array. A framework sets it as a property, and React   hydration keeps it. - 'for' names a '<script type="application/json">' that holds an array, which   a server sends as markup.  Each item is drawn into a row in one of two ways:  - 'renderItem' is a function from an item and its index to the row's   content: a Lit template, a string, or a DOM node. - A '<template>' child defines one row. 'data-field="name"' fills an element   with the item's 'name' as text, and 'data-field-href="url"' writes the   item's 'url' into 'href', the same for any attribute. A field may be a path   of keys, such as 'author.name'.  Rows are your markup in the light DOM, so your stylesheet styles them.  **A grid.** 'columns' lays the items out that many to a line, as a grid of equal columns, and windows the set a line at a time, as React Aria's grid layout does. Each item draws one element, a cell of the grid, and 'estimate' is the height of a line. 'min-column-width' lays out as many columns as fit the box instead, as React Aria's grid layout does with its smallest item size, and follows the box as it resizes. 'gap' spaces the rows, and the columns of a grid, by a number of pixels the list counts in each row's place.  **Across.** 'orientation="horizontal"' lays the items out along a line and scrolls it sideways, as a strip of cards does, windowed the same way: 'estimate' is then an item's width, and the box needs an inline size.  **Sections.** 'section-field' names the field of each item that says which section it is in, and the list draws a header before each section's items, as React Aria's list box sections do. Each section is an element with the 'group' role, named by its header, which is its first child and carries 'data-header', so your stylesheet styles it, such as with 'position: sticky'. A section starts wherever the field changes, so give the items in order. The window counts the headers with the items, and a section the window starts inside is drawn with its header. 'renderSection' draws a header of your own.  **Keyboard.** The list is one tab stop.  | Key | What it does | |---|---| | Down, Up | Moves to the next or the previous item, or in a grid to the item in the same column on the next or the previous line. | | Right, Left | In a grid, moves to the next or the previous item along the line, the other way round on a right-to-left page. In a list that runs across, moves to the next or the previous item the same way, and Down and Up are left to the row. | | Home, End | Moves to the first or the last item. | | Page Down, Page Up | Moves by the number of items, or of lines in a grid, on screen. | | A letter or a word | Moves to the next item whose text starts with what you typed. | | Escape | Lets go of every chosen item, in a list with 'selection-mode'. | | Alt with Up or Down | In a 'reorderable' list, moves the item a place. Alt with Home or End moves it to either end. | | Tab | Moves into the focused row's own links and buttons, then out of the list. |  An item that is not drawn is scrolled into view and focused, so a keyboard reaches the whole set. The row a reader last focused keeps the tab stop and stays drawn when it scrolls away, so Tab and Shift+Tab come back to it, as React Aria's collections do. In a list nobody has focused yet, the stop moves to the first row on screen. Typing matches each item's 'text-field', which is the first 'data-field' of the row template by default, or the item itself when it is a string or a number.  Each row says its place in the whole set with 'aria-posinset' and 'aria-setsize', so a screen reader says "4,000 of 10,000". The row holding focus stays drawn when it scrolls out.  **Selecting.** 'selection-mode' makes the list a list box a reader chooses from: 'single' selects one item and 'multiple' any number. Space or a press selects an item, Shift with Space, an arrow, Home, End or a press takes in the items from the last one chosen, and Control or Command with A selects them all, in 'multiple'. Escape lets go of every chosen item, and keeps the key from the dialog or menu around the list while there was something to let go of. 'value' holds the chosen items' keys, separated by commas, in the order of the set: 'key-field' names each item's key, and a string or a number item is its own key. A change asks with 'helix-before-change' and tells with 'change'. Each row is an 'option' marked 'aria-selected', so a row's own links and buttons are not reached there: keep those to a list without 'selection-mode'.  'selection-behavior="replace"' selects the item pressed alone, as a file list does, and the arrow keys carry the selection with them. Control or Command with a press or with Space adds or takes out one item, and with an arrow moves without selecting.  **Disabled items.** 'disabled-keys' names items by their keys, separated by commas. Their rows carry 'aria-disabled', the keys and typing pass over them, and a press, Space, or Control with A does not select them.  **Rows a stylesheet can tell apart.** A chosen row carries 'data-selected', a disabled one 'data-disabled', as React Aria's rows do, and the row the keys are on, which holds the tab stop, 'data-active', whether or not the list has focus.  **Loading more.** 'helix-range-change' fires as the items on screen change, and 'range' holds them. 'helix-load-more' fires once a reader is within one screen of the end, once for each length of the set: add to 'items' and it can fire again. While you fetch, set 'loading': the list is busy, and a row after the last item says "Loading more" ('loading-label', or your own content in the 'loading' slot). 'scrollToIndex' takes a reader to an item.  **Moving items** is a separate import, '@fusion.dev/helix/virtual-list/reorder', as React Aria's drag and drop is. With it imported, 'reorderable' lets a reader move items in a list of one column without sections:  - Alt with Up or Down moves the item the keys are on a place, and Alt with   Home or End to either end, as the APG's rearrangeable listbox does. - A pointer drags a whole row. A press that does not travel is still a   press. The list scrolls near an edge, and an item far down a long set is   reached by dragging to the edge. - A drop sends 'helix-before-reorder', which you can refuse, and then   'helix-reorder', whose 'keys' hold every item's key in the new order.   **You move the items**: set 'items' to them in that order. The keys stay   on the item that moved. - Each move is said in a region screen readers announce. The row being   dragged carries 'data-dragging', and the row a drop would land beside   'data-drop-before' or 'data-drop-after'.  **An empty list.** Set 'empty-label', or put your own content in the 'empty' slot, for a row shown when there are no items and none are loading, such as "No messages yet" and a link to write one. Without either, an empty list shows nothing, since a list whose items have not arrived yet has not said it has none.  The list takes the 'empty' state while it has read its items and holds none, and the 'loading' state while 'loading' is set, so your stylesheet can change the box around it for either. A list with no name is reported once in a development build. Name it with 'label' or 'aria-label'.  **Row height.** Rows are placed by 'estimate' until they are drawn. Then the list reads the drawn rows' height once and places every row by it, so a wrong estimate still reaches the last item. Set 'measured' for rows of different heights. Once the list draws rows of different heights, such as rows that wrap on a narrow screen, it places each row by its own height whether 'measured' is set or not.  The list follows its source. A new 'items' array, an edit to the script's text, or a script replaced under the same id draws the new rows. A row that stays in view keeps its element as the list scrolls.  The viewport scrolls on this tier. It carries 'data-scroller', and 'core' ships '[data-scroller] { overflow: auto }' into every shadow root, so 'scrollTop' works with no stylesheet. You still need to set a block size. */
   "helix-headless-virtual-list": DefineCustomElement<
     HelixHeadlessVirtualList,
     HelixHeadlessVirtualListVueProps,

package/types/words.d.ts

@@ -1641,6 +1641,12 @@ declare module '@fusion.dev/helix-core' {
        * English: `Links to {note}`
        */
       linksToLabel: Message
+      /**
+       * What the panel says while `loading` is set and the list holds no notes.
+       *
+       * English: `Loading notes`
+       */
+      loadingLabel: Message
       /**
        * What screen readers hear once the drawing has moved down, after `moved()`.
        *
@@ -3348,6 +3354,14 @@ declare module '@fusion.dev/helix-core' {
        */
       valueMissingMessage: Message
     }
+    'helix-timeline': {
+      /**
+       * The text of the entry drawn while `loading` is set, where the `loading` slot is empty.
+       *
+       * English: `Loading more`
+       */
+      loadingLabel: Message
+    }
     'helix-timeline-item': {
       /**
        * What a screen reader hears for an entry that is `pending`.