@fusion.dev/helix 0.23.0 → 0.24.0

package/types/vue.d.ts

@@ -3,6 +3,7 @@ import type {
   HelixAccordion,
   HelixAnnouncement,
   HelixAppHeader,
+  HelixAreaChart,
   HelixAura,
   HelixAvatarGroup,
   HelixAvatar,
@@ -31,6 +32,8 @@ import type {
   HelixDataTable,
   HelixDateInput,
   HelixDatePicker,
+  HelixDescriptionListItem,
+  HelixDescriptionList,
   HelixDialog,
   HelixDivider,
   HelixDonutChart,
@@ -39,6 +42,10 @@ import type {
   HelixDrilldown,
   HelixEmpty,
   HelixFileInput,
+  HelixFilterChip,
+  HelixFilterField,
+  HelixFilterMenu,
+  HelixFilterOperator,
   HelixFilterInput,
   HelixFlex,
   HelixFormatDate,
@@ -60,9 +67,11 @@ import type {
   HelixMenu,
   HelixMeter,
   HelixNavigation,
+  HelixNotificationGroup,
   HelixNotification,
   HelixNotifications,
   HelixNumberInput,
+  HelixObjectInspector,
   HelixOptionGroup,
   HelixOption,
   HelixOrb,
@@ -84,9 +93,11 @@ import type {
   HelixSandboxStatusBar,
   HelixSandboxTerminal,
   HelixSandboxToolbar,
+  HelixScatterChart,
   HelixScrollArea,
   HelixSelect,
   HelixSkeleton,
+  HelixSkipLink,
   HelixSlider,
   HelixSparkline,
   HelixSpeedDialItem,
@@ -134,6 +145,7 @@ import type {
   HelixSelectEvent,
   HelixSendEvent,
   HelixBeforePinEvent,
+  HelixHistoryEvent,
   HelixBeforeChangeEvent,
   HelixBeforeToggleEvent,
   HelixCopyEvent,
@@ -142,16 +154,18 @@ import type {
   HelixCreateEvent,
   HelixFilterEvent,
   HelixNavigateEvent,
+  HelixReorderEvent,
   HelixSortEvent,
+  HelixFacetEvent,
   HelixResizeEvent,
   HelixShortcutEvent,
   HelixReadEvent,
   HelixBeforeActivateEvent,
   HelixCompleteEvent,
   HelixConsoleEvent,
+  HelixBeforeEditEvent,
   HelixBeforePanelResizeEvent,
   HelixBeforeSplitEvent,
-  HelixBeforeEditEvent,
   HelixCaretEvent,
   HelixBeforeCollapseEvent,
   HelixBeforeResizeEvent,
@@ -320,6 +334,21 @@ export type HelixAnnouncementHelixDismissElementEvent =
   HelixAnnouncementElementEvent<HelixDismissEvent>;
 
 export type HelixAnnouncementVueProps = {
+  /** Which rung of the surface ladder the band rides.
+
+`filled` is the resting one, a well sunk below the page. `elevated` brings
+it up to the surface step, for a band that reads as part of the furniture
+rather than as a slot cut into it.
+
+**This was `tone="surface"`**, which put an elevation on the axis that says
+what a thing means. The band's own doc admitted it, calling `surface` the
+one value that was not a color. A band can be `info` and elevated at the
+same time, and two values that can both be true are two axes.
+
+Styled and not headless, because a rung of a ladder is paint: the headless
+tier has no stylesheet to sit a band on. `tone` crosses because meaning
+survives having nothing to paint with, and it is the only axis that does. */
+  separation?: (HelixAnnouncement["separation"]) | undefined;
   /** Whether it offers a control to take it away. */
   dismissible?: (HelixAnnouncement["dismissible"]) | undefined;
   /** Accessible name for that control.
@@ -339,10 +368,24 @@ would catch. */
   /** Which color the band wears.
 
 Paint only: unlike `Callout`, no value here draws a mark, changes the label,
-or moves the live region off polite. The set matches `Tag`'s. `neutral` is
-the resting value, said out loud so a consumer can put a band back to it
-from markup, and `surface` is the one value that is not a color: it lifts
-the band onto the surface step instead of the sunken one. */
+or moves the live region off polite. `neutral` is the resting value, said
+out loud so a consumer can put a band back to it from markup.
+
+**The set is `Tag`'s and `Badge`'s, and now actually is.** This doc claimed
+to match `Tag` while differing from it in both directions: it carried
+`surface`, which `Tag` does not, and lacked `accent`, which `Tag` has. Three
+components saying what a thing means, in three vocabularies, one of which
+described itself as a fourth.
+
+`accent` is the second emphasis, a rotation off the brand seed rather than a
+color of its own, so it stays in relation when somebody rethemes. `primary`
+is the seed itself.
+
+**`surface` was never a color and has moved to `separation`**, which is the
+axis that owns where a box sits relative to the page. It said the band rode
+the surface step instead of the sunken one, which is an elevation, and a
+band can be `info` and elevated at once: two values true together are two
+axes, which is the test the registry answers to. */
   tone?: (HelixAnnouncement["tone"]) | undefined;
 };
 
@@ -448,6 +491,47 @@ export type HelixAppHeaderVueEvents = {
   "helix-scrolled": HelixAppHeaderHelixScrolledElementEvent;
 };
 
+export type HelixAreaChartVueProps = {
+  /** The id of the table to read.
+
+Resolved through `getRootNode()`, so a chart inside another component's
+shadow root names a table in that root rather than in the document. A
+`<table>` or anything built from grid roles, including `helix-table`.
+
+**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?: (HelixAreaChart["for"]) | undefined;
+  /** The drawing's name, for a pointer resting on it.
+
+Absent falls back to the table's own caption, which is usually the right
+words and is already written. */
+  label?: (HelixAreaChart["label"]) | undefined;
+  /** How a band's edge gets from one reading to the next.
+
+Absent is `straight`, for the reason the class doc gives, and absent rather
+than defaulted because a reflecting property with a default writes its
+attribute onto every host, including the ones nobody configured. */
+  curve?: (HelixAreaChart["curve"]) | undefined;
+  /** Which rules are drawn across the plot, if any.
+
+The same three values `LineChart` takes, with the same fallback: a bare
+`gridlines`, or anything unrecognized, rules the levels. Drawn over the bands
+rather than under them, because the bands are opaque and a rule under one is
+a rule nobody sees. */
+  gridlines?: (HelixAreaChart["gridlines"]) | undefined;
+  /** Whether each reading is drawn as a hundred percent.
+
+Absent stacks the amounts, so the top edge is the total. Set, every reading
+fills the height and the bands are shares of it. */
+  share?: (HelixAreaChart["share"]) | undefined;
+  /** What to call the sum of the parts, in the tooltip and the summary. */
+  "total-label"?: (HelixAreaChart["totalLabel"]) | undefined;
+  /** What to call the sum of the parts, in the tooltip and the summary. */
+  totalLabel?: (HelixAreaChart["totalLabel"]) | undefined;
+};
+
+export type HelixAreaChartVueEvents = {};
+
 export type HelixAuraVueProps = {
   /** How soft the falloff is, `0` tight and `1` diffuse. */
   bloom?: (HelixAura["bloom"]) | undefined;
@@ -935,8 +1019,11 @@ Three and an accent, not the full status set. A tag reports a state and a
 button performs an action: a success button and a warning button are not
 things anybody writes, and offering them invites a page where the color
 of a control means nothing in particular. `accent` is the second
-emphasis, a rotation off the brand seed rather than a color of its own,
-so it stays in relation when somebody rethemes. */
+emphasis: the second color a theme names, and the brand itself until one
+is named. It used to be a rotation off the brand seed whether or not
+anybody asked for a second color, which handed every theme a complement
+it had not chosen, 3 degrees off `warning` and sometimes too pale to
+read. */
   tone?: (HelixButton["tone"]) | undefined;
   /** What to send when the button is activated, and what to send it to.
 
@@ -1551,6 +1638,12 @@ export type HelixChatElementEvent<E = Event> = TypedEvent<HelixChat, E>;
 /** `helix-before-pin` event type */
 export type HelixChatHelixBeforePinElementEvent =
   HelixChatElementEvent<HelixBeforePinEvent>;
+/** `helix-history` event type */
+export type HelixChatHelixHistoryElementEvent =
+  HelixChatElementEvent<HelixHistoryEvent>;
+/** `helix-send` event type */
+export type HelixChatHelixSendElementEvent =
+  HelixChatElementEvent<HelixSendEvent>;
 
 export type HelixChatVueProps = {
   /** What is said where there are none, and none are coming. */
@@ -1571,6 +1664,17 @@ say that without the component knowing what a row looks like. */
   "default-pinned"?: (HelixChat["defaultPinned"]) | undefined;
   /** Whether to open pinned, where nothing declared it. */
   defaultPinned?: (HelixChat["defaultPinned"]) | undefined;
+  /** Whether there are older turns than the ones here, and whether they are coming.
+
+`more` makes reaching the top fire `helix-history`, once per arrival;
+`loading` draws `history-text` above the oldest turn and fires nothing; empty
+says this is the start of the conversation. The consumer owns it, because
+only the consumer knows whether the server has anything older. */
+  history?: (HelixChat["history"]) | undefined;
+  /** What to say while older turns are on their way. */
+  "history-text"?: (HelixChat["historyText"]) | undefined;
+  /** What to say while older turns are on their way. */
+  historyText?: (HelixChat["historyText"]) | undefined;
   /** Accessible name for the conversation. */
   label?: (HelixChat["label"]) | undefined;
   /** Whether the transcript follows new turns to the bottom.
@@ -1595,13 +1699,27 @@ it. Measured rather than assumed: `label, pinned` after upgrade against
 A hook rather than a constant, because the right number depends on how tall
 a turn is: a transcript of one-line replies wants a smaller threshold than
 one of paragraphs, and a reader who has scrolled up by half a message has
-not left. */
+not left. The same distance from the top is what counts as reaching the
+history. */
   threshold?: (HelixChat["threshold"]) | undefined;
+  /** The turns as data, for a transcript too long to hold as elements.
+
+Drawn a window at a time, so the log needs a block size. Set it or declare
+children, not both: while it holds anything the children are not drawn.
+
+**Read, never written**, and replaced rather than mutated: a streamed turn
+is a new array with the last turn's text longer, which is what tells this
+element to look again. */
+  turns?: (HelixChat["turns"]) | undefined;
 };
 
 export type HelixChatVueEvents = {
   /** Fired when the reader pins or unpins the transcript by scrolling. Cancelable. */
   "helix-before-pin": HelixChatHelixBeforePinElementEvent;
+  /** Fired when the reader reaches the oldest turn while `history` is `more`, reporting where they are rather than asking. */
+  "helix-history": HelixChatHelixHistoryElementEvent;
+  /** A turn offered from the composer, or a failed one asked to go again, dispatched inside and heard here because the conversation is what a consumer holds. Cancelable: refusing it takes the decision and nothing is sent. */
+  "helix-send": HelixChatHelixSendElementEvent;
 };
 
 /** `HelixCheckboxGroup` component event */
@@ -1748,7 +1866,15 @@ export type HelixCheckboxVueEvents = {
 };
 
 export type HelixCodeBlockVueProps = {
-  /** What to call this block, usually a file name or a language. */
+  /** Whether the content is a unified diff, drawn as the lines it changed.
+
+Reflected, because the stylesheet paints a diff differently from code, and
+`false` reflects as no attribute at all. */
+  diff?: (HelixCodeBlock["diff"]) | undefined;
+  /** What to call this block, usually a file name or a language.
+
+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 to leave the copy button off.
 
@@ -1790,6 +1916,12 @@ A false boolean reflects as the attribute's absence, so this costs no
 reflected property taking no default is satisfied by the default being
 `false`. */
   noCopy?: (HelixCodeBlock["noCopy"]) | undefined;
+  /** How a diff's two versions are arranged; nothing without `diff`.
+
+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;
 };
 
 export type HelixCodeBlockVueEvents = {};
@@ -2338,8 +2470,11 @@ Three and an accent, not the full status set. A tag reports a state and a
 button performs an action: a success button and a warning button are not
 things anybody writes, and offering them invites a page where the color
 of a control means nothing in particular. `accent` is the second
-emphasis, a rotation off the brand seed rather than a color of its own,
-so it stays in relation when somebody rethemes. */
+emphasis: the second color a theme names, and the brand itself until one
+is named. It used to be a rotation off the brand seed whether or not
+anybody asked for a second color, which handed every theme a complement
+it had not chosen, 3 degrees off `warning` and sometimes too pale to
+read. */
   tone?: (HelixCopyButton["tone"]) | undefined;
   /** What it is called, and says, after one.
 
@@ -2522,6 +2657,12 @@ export type HelixDataTableHelixFilterElementEvent =
 /** `helix-navigate` event type */
 export type HelixDataTableHelixNavigateElementEvent =
   HelixDataTableElementEvent<HelixNavigateEvent>;
+/** `helix-reorder` event type */
+export type HelixDataTableHelixReorderElementEvent =
+  HelixDataTableElementEvent<HelixReorderEvent>;
+/** `helix-select` event type */
+export type HelixDataTableHelixSelectElementEvent =
+  HelixDataTableElementEvent<HelixSelectEvent>;
 /** `helix-sort` event type */
 export type HelixDataTableHelixSortElementEvent =
   HelixDataTableElementEvent<HelixSortEvent>;
@@ -2545,6 +2686,10 @@ say that without the component knowing what a row looks like. */
   "default-filter"?: (HelixDataTable["defaultFilter"]) | undefined;
   /** Query to open with, where nothing declared one. */
   defaultFilter?: (HelixDataTable["defaultFilter"]) | undefined;
+  /** Column order to open with, where nothing declared one. */
+  "default-order"?: (HelixDataTable["defaultOrder"]) | undefined;
+  /** Column order to open with, where nothing declared one. */
+  defaultOrder?: (HelixDataTable["defaultOrder"]) | undefined;
   /** Page to open on, where nothing declared one. */
   "default-page"?: (HelixDataTable["defaultPage"]) | undefined;
   /** Page to open on, where nothing declared one. */
@@ -2553,6 +2698,10 @@ say that without the component knowing what a row looks like. */
   "default-page-size"?: (HelixDataTable["defaultPageSize"]) | undefined;
   /** Page size to open with, where nothing declared one. */
   defaultPageSize?: (HelixDataTable["defaultPageSize"]) | undefined;
+  /** Keys to open with selected, comma separated, where nothing declared any. */
+  "default-selected"?: (HelixDataTable["defaultSelected"]) | undefined;
+  /** Keys to open with selected, comma separated, where nothing declared any. */
+  defaultSelected?: (HelixDataTable["defaultSelected"]) | undefined;
   /** Order to open on, where nothing declared one. */
   "default-sort"?: (HelixDataTable["defaultSort"]) | undefined;
   /** Order to open on, where nothing declared one. */
@@ -2571,29 +2720,14 @@ Set it and this element defers: a reader's click fires `helix-sort` and
 changes nothing until a new value arrives. `default-sort` seeds an order this
 element then owns. */
   sort?: (HelixDataTable["sort"]) | undefined;
-  /** The field naming a row's stable identity.
-
-**Needed before selection exists, not after.** Lit keys the rendered rows by
-it, so a sort moves a row's element rather than rewriting every cell in
-place, which is what keeps focus inside a cell and keeps a CSS transition
-attached to the row it belongs to. Left unset the index is the key, which is
-correct only while nothing reorders: it is why this defaults to something
-that works and is worth setting anyway. */
-  key?: (HelixDataTable["key"]) | undefined;
+  /** Accessible name for the grid. */
+  label?: (HelixDataTable["label"]) | undefined;
   /** What the rows are narrowed to, as one query across every column.
 
 One query rather than a predicate per column, which is what a reader means
 by a search box above a table. It matches on each column's ordering value,
 so search and sort cannot disagree about what a column holds. */
   filter?: (HelixDataTable["filter"]) | undefined;
-  /** Accessible name for the grid. */
-  label?: (HelixDataTable["label"]) | undefined;
-  /** The page on show, from 1.
-
-Clamped on the way out, so what this reports is the page it drew: a
-bookmarked link to page 99 of a result that has since shrunk reads back as
-the last page rather than as 99. */
-  page?: (HelixDataTable["page"]) | undefined;
   /** Whether this element does the work or asks the consumer to.
 
 `client` filters, sorts and pages `rows` itself. `server` applies none of
@@ -2603,6 +2737,64 @@ the client cannot hold the data, so this is not an optimization, it is the
 only mode that works, and it is here from the start because adding it later
 inverts the data flow. */
   mode?: (HelixDataTable["mode"]) | undefined;
+  /** The page on show, from 1.
+
+Clamped on the way out, so what this reports is the page it drew: a
+bookmarked link to page 99 of a result that has since shrunk reads back as
+the last page rather than as 99. */
+  page?: (HelixDataTable["page"]) | undefined;
+  /** Whether a reader may move the columns.
+
+Each heading with a `field` gets a grip, dragged along the header or moved a
+place at a time with the arrow keys once it has focus. */
+  reorderable?: (HelixDataTable["reorderable"]) | undefined;
+  /** The columns' order, as their fields separated by spaces.
+
+A reader's move fires `helix-reorder` first, and refusing it leaves the
+columns where they were, which is how a consumer who stores the order takes
+the decision. `default-order` seeds an order this element then owns. A field not named
+keeps its place after the named ones, and a column with no field never
+moves. */
+  order?: (HelixDataTable["order"]) | undefined;
+  /** The field naming a row's stable identity.
+
+**Needed before selection exists, not after.** Lit keys the rendered rows by
+it, so a sort moves a row's element rather than rewriting every cell in
+place, which is what keeps focus inside a cell and keeps a CSS transition
+attached to the row it belongs to. Left unset the index is the key, which is
+correct only while nothing reorders: it is why this defaults to something
+that works and is worth setting anyway.
+
+**`row-key` and not `key`**, which is what it was called until selection
+needed it from React: `key` is reserved there, and a JSX `key` never reaches
+the element, so a React page could not tell the table which field a row is. */
+  "row-key"?: (HelixDataTable["rowKey"]) | undefined;
+  /** The field naming a row's stable identity.
+
+**Needed before selection exists, not after.** Lit keys the rendered rows by
+it, so a sort moves a row's element rather than rewriting every cell in
+place, which is what keeps focus inside a cell and keeps a CSS transition
+attached to the row it belongs to. Left unset the index is the key, which is
+correct only while nothing reorders: it is why this defaults to something
+that works and is worth setting anyway.
+
+**`row-key` and not `key`**, which is what it was called until selection
+needed it from React: `key` is reserved there, and a JSX `key` never reaches
+the element, so a React page could not tell the table which field a row is. */
+  rowKey?: (HelixDataTable["rowKey"]) | undefined;
+  /** Whether a reader may select rows, with a column of checkboxes.
+
+Wants `row-key`: a selection is a set of identities, and without one the rows
+are known by their place in the result, which a sort changes. */
+  selectable?: (HelixDataTable["selectable"]) | undefined;
+  /** The keys of the selected rows, comma separated.
+
+A string rather than an array, so it is an attribute a server writes and a
+framework's hydration keeps, and the shape a multiple Listbox already uses.
+A key holding a comma cannot be told apart from two keys, which is the
+price of the shape. A reader's choice fires `helix-select` first, and
+refusing it leaves the selection as it was. */
+  selected?: (HelixDataTable["selected"]) | undefined;
   /** How many rows a page holds. Zero is every row, which is what "no paging" means.
 
 **It announces nothing, and that is not an omission.** Nothing in this
@@ -2668,6 +2860,10 @@ export type HelixDataTableVueEvents = {
   "helix-filter": HelixDataTableHelixFilterElementEvent;
   /** Fired when a reader asks for another page, and cancelable. */
   "helix-navigate": HelixDataTableHelixNavigateElementEvent;
+  /** Fired when a reader asks for the columns in another order, with every field in the new one, and cancelable. */
+  "helix-reorder": HelixDataTableHelixReorderElementEvent;
+  /** Fired when a reader changes which rows are selected, with every selected key comma separated, and cancelable. */
+  "helix-select": HelixDataTableHelixSelectElementEvent;
   /** Fired when a reader asks for a different order, and cancelable. */
   "helix-sort": HelixDataTableHelixSortElementEvent;
 };
@@ -3085,6 +3281,56 @@ export type HelixDatePickerVueEvents = {
   "helix-navigate": HelixDatePickerHelixNavigateElementEvent;
 };
 
+export type HelixDescriptionListItemVueProps = {
+  /** What the value is, for the common case of plain text.
+
+The fallback of the `label` slot, so slotted content replaces it rather than
+appearing beside it. */
+  label?: (HelixDescriptionListItem["label"]) | undefined;
+};
+
+export type HelixDescriptionListItemVueEvents = {};
+
+export type HelixDescriptionListVueProps = {
+  /** Where the values sit, beside their labels.
+
+Absent, each value starts right after the label column. `between` sets it on
+the end edge instead, with the label on the start one, and in figures of one
+width so a column of numbers lines up by its digits. Only with
+`direction="row"`: stacked, a label and its value share one edge already.
+
+Flex's word for the same thing, and a grid rather than a flex row
+underneath, so the labels still share one column while the values share an
+end. */
+  justify?: (HelixDescriptionList["justify"]) | undefined;
+  /** How wide the list is.
+
+Absent, it fills the row it is in. `auto` is as wide as its widest pair,
+which is what a summary beside other content wants.
+
+**At `auto` the list does not stack when narrow.** The fallback measures the
+list's own width, and a list sized by its content has no width of its own to
+measure: containment would size it to nothing. It is capped at its container
+instead, and a long value wraps inside its column. */
+  width?: (HelixDescriptionList["width"]) | undefined;
+  /** Whether each label sits over its value or beside it.
+
+Absent is a column, the label over the value, which fits any width and is
+how a narrow panel reads. `row` puts every label in one column and every
+value in the next, which is how a wide panel is scanned: down the labels to
+the one wanted, then across.
+
+On the list rather than on each item, because beside only reads when the
+labels line up, and lining up is a fact about all of them.
+
+**Optional rather than defaulted to `column`**, for the reason `Stat` gives:
+a reflecting default writes an attribute onto markup the consumer rendered,
+and React reports that as a hydration mismatch. */
+  direction?: (HelixDescriptionList["direction"]) | undefined;
+};
+
+export type HelixDescriptionListVueEvents = {};
+
 /** `HelixDialog` component event */
 export type HelixDialogElementEvent<E = Event> = TypedEvent<HelixDialog, E>;
 /** `helix-before-close` event type */
@@ -3575,6 +3821,171 @@ export type HelixFileInputVueEvents = {
   "helix-before-change": HelixFileInputHelixBeforeChangeElementEvent;
 };
 
+/** `HelixFilterChip` component event */
+export type HelixFilterChipElementEvent<E = Event> = TypedEvent<
+  HelixFilterChip,
+  E
+>;
+/** `helix-dismiss` event type */
+export type HelixFilterChipHelixDismissElementEvent =
+  HelixFilterChipElementEvent<HelixDismissEvent>;
+
+export type HelixFilterChipVueProps = {
+  /** Whether it offers a control to take it away. */
+  dismissible?: (HelixFilterChip["dismissible"]) | undefined;
+  /** Accessible name for that control.
+
+`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"?: (HelixFilterChip["dismissLabel"]) | undefined;
+  /** Accessible name for that control.
+
+`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?: (HelixFilterChip["dismissLabel"]) | undefined;
+  /** The field this filter is on, as a reader sees it.
+
+The slot's fallback rather than the slot's replacement: a consumer who wants
+a mark beside the name slots `field` and this goes unused. */
+  label?: (HelixFilterChip["label"]) | undefined;
+  /** The field this filter is on, as the consumer's model calls it.
+
+Never shown. Reflected, because a consumer removing one filter from a list
+of them selects on this, and so undefaulted for the reason `operator` gives.
+
+**A chip built in script should be given the attribute, not the property**,
+if the next thing to happen might select on it. Reflection is written on
+this element's next update rather than during the assignment, so a second
+`helix-facet` for the same field arriving in the same frame selects nothing,
+builds a second chip, and leaves the row holding two of one filter. The
+lookup then finds whichever came first, so dismissing one chip takes the
+other away. `setAttribute('name', field)` is true immediately and costs
+nothing; the property is for markup and for frameworks that write both. */
+  name?: (HelixFilterChip["name"]) | undefined;
+  /** What the consumer's own model calls the comparison in force.
+
+Never shown, and it is what a consumer matches on when the chip comes back
+to them. `label` translates; this does not.
+
+Reflected and so undefaulted: a reflected property with a default writes an
+attribute on upgrade that the server never wrote, and the two markups differ
+before a reader has touched anything. */
+  operator?: (HelixFilterChip["operator"]) | undefined;
+  /** The comparison, as a reader sees it, and empty for the field's usual one.
+
+**Empty is the whole design and not an oversight.** A chip drawn for the
+comparison a field is normally filtered by says the field and the values and
+nothing between them, because a word every chip carries is a word nobody
+reads. The moment somebody picks a different comparison it appears, which
+makes an unusual filter look unusual. */
+  "operator-label"?: (HelixFilterChip["operatorLabel"]) | undefined;
+  /** The comparison, as a reader sees it, and empty for the field's usual one.
+
+**Empty is the whole design and not an oversight.** A chip drawn for the
+comparison a field is normally filtered by says the field and the values and
+nothing between them, because a word every chip carries is a word nobody
+reads. The moment somebody picks a different comparison it appears, which
+makes an unusual filter look unusual. */
+  operatorLabel?: (HelixFilterChip["operatorLabel"]) | undefined;
+};
+
+export type HelixFilterChipVueEvents = {
+  /** Fired when the reader asks to remove the filter. Cancelable: refusing it takes the decision and nothing moves. */
+  "helix-dismiss": HelixFilterChipHelixDismissElementEvent;
+};
+
+export type HelixFilterFieldVueProps = {
+  /** What a reader is shown, in the menu and on every chip built from this field. */
+  label?: (HelixFilterField["label"]) | undefined;
+  /** What the consumer's own model calls this field.
+
+Never shown, and what arrives in the filter this helps build.
+
+Reflected and so undefaulted: a reflected property with a default writes an
+attribute on upgrade that the server never wrote. */
+  name?: (HelixFilterField["name"]) | undefined;
+};
+
+export type HelixFilterFieldVueEvents = {};
+
+/** `HelixFilterMenu` component event */
+export type HelixFilterMenuElementEvent<E = Event> = TypedEvent<
+  HelixFilterMenu,
+  E
+>;
+/** `helix-facet` event type */
+export type HelixFilterMenuHelixFacetElementEvent =
+  HelixFilterMenuElementEvent<HelixFacetEvent>;
+
+export type HelixFilterMenuVueProps = {
+  /** Accessible name for the menu. */
+  label?: (HelixFilterMenu["label"]) | undefined;
+};
+
+export type HelixFilterMenuVueEvents = {
+  /** Fired when a field's values change. Cancelable: refusing it takes the decision and nothing moves. */
+  "helix-facet": HelixFilterMenuHelixFacetElementEvent;
+};
+
+export type HelixFilterOperatorVueProps = {
+  /** How many values this comparison takes.
+
+`none` is a comparison that is complete on its own, which is what `is empty`
+and `is set` are: a chip drawn for one shows no values because there are
+none to show, and the menu that builds it offers nothing to pick.
+
+`one` takes a single value, which is every scalar comparison: `is after` a
+date, `is above` a number. `many` takes a set, which is what `is any of` and
+`is none of` are, and is the only arity a multi-select panel makes sense
+for.
+
+Read rather than enforced. This element applies nothing, so the arity is a
+fact the picker uses to decide what to offer, not a rule it polices. What
+the picker does with it: `none` offers no values at all and takes back any
+that were ticked, since the comparison is the whole filter; `one` replaces
+rather than adds, and its rows announce as one of a set. The typed grammar
+reads it too, refusing a list where a scalar was declared and never writing
+a comparison that takes nothing.
+
+The arity reaches a consumer in `helix-facet`, which is what tells an empty
+filter from no filter: `values` empty means the field is no longer narrowing
+anything, unless the comparison is one that never had values to give.
+
+**Undefined reads as `many`, and takes no default**, which is the rule every
+reflected property here answers to: a default writes an attribute on upgrade
+that the server never wrote, and the two markups differ before a reader has
+touched anything. */
+  arity?: (HelixFilterOperator["arity"]) | undefined;
+  /** Whether this is the comparison the field is filtered by unless asked
+otherwise.
+
+The chip leaves a default operator unwritten, so the common filter reads as
+a field and its values and nothing else, and the word only appears once
+somebody has chosen a comparison worth noticing. */
+  default?: (HelixFilterOperator["default"]) | undefined;
+  /** What a reader is shown, in the chip and in the menu that changes it.
+
+Words rather than symbols, and the reason is that a set has more than one
+negation: `!=` cannot tell "is none of" from "is not all of", and both are
+filters somebody wants. A chip is read, so it takes the reading. The text
+grammar a consumer types is theirs and may use whatever symbols it likes. */
+  label?: (HelixFilterOperator["label"]) | undefined;
+  /** What the consumer's own model calls this comparison.
+
+Never shown. It is what arrives in the filter this element helps build, so
+a consumer matches on it rather than on the words a reader sees, and
+translating the label breaks nothing.
+
+Reflected and so undefaulted, for the reason `arity` gives above. */
+  name?: (HelixFilterOperator["name"]) | undefined;
+};
+
+export type HelixFilterOperatorVueEvents = {};
+
 /** `HelixFilterInput` component event */
 export type HelixFilterInputElementEvent<E = Event> = TypedEvent<
   HelixFilterInput,
@@ -3589,6 +4000,15 @@ export type HelixFilterInputHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixFilterInputHelixBeforeOpenElementEvent =
   HelixFilterInputElementEvent<HelixBeforeOpenEvent>;
+/** `helix-dismiss` event type */
+export type HelixFilterInputHelixDismissElementEvent =
+  HelixFilterInputElementEvent<HelixDismissEvent>;
+/** `helix-facet` event type */
+export type HelixFilterInputHelixFacetElementEvent =
+  HelixFilterInputElementEvent<HelixFacetEvent>;
+/** `helix-select` event type */
+export type HelixFilterInputHelixSelectElementEvent =
+  HelixFilterInputElementEvent<HelixSelectEvent>;
 
 export type HelixFilterInputVueProps = {
   /** Whether the element is open.
@@ -3695,6 +4115,12 @@ export type HelixFilterInputVueEvents = {
   "helix-before-close": HelixFilterInputHelixBeforeCloseElementEvent;
   /** Fired before the suggestions show, and cancelable. */
   "helix-before-open": HelixFilterInputHelixBeforeOpenElementEvent;
+  /** A token asking to go, from its close control or from Backspace on an empty field. A `FilterChip` naming a declared field is answered as `helix-facet` instead. Cancelable: refusing it takes the decision and the token stays. */
+  "helix-dismiss": HelixFilterInputHelixDismissElementEvent;
+  /** Fired when a filter changes, whether read out of the text, picked, or dismissed. Cancelable: refusing it leaves the text and the chip where they were. */
+  "helix-facet": HelixFilterInputHelixFacetElementEvent;
+  /** A suggestion was chosen: the option's own, heard here because it bubbles out of `suggestions`. Cancelable: refusing it takes the decision from any other listener, and this field never acts on a choice itself, since what it means is the page's. */
+  "helix-select": HelixFilterInputHelixSelectElementEvent;
   /** Says the panel moved, carrying `newState` and `oldState`. */
   toggle: HelixFilterInputElementEvent;
 };
@@ -3924,8 +4350,11 @@ Three and an accent, not the full status set. A tag reports a state and a
 button performs an action: a success button and a warning button are not
 things anybody writes, and offering them invites a page where the color
 of a control means nothing in particular. `accent` is the second
-emphasis, a rotation off the brand seed rather than a color of its own,
-so it stays in relation when somebody rethemes. */
+emphasis: the second color a theme names, and the brand itself until one
+is named. It used to be a rotation off the brand seed whether or not
+anybody asked for a second color, which handed every theme a complement
+it had not chosen, 3 degrees off `warning` and sometimes too pale to
+read. */
   tone?: (HelixIconButton["tone"]) | undefined;
   /** What to send when the button is activated, and what to send it to.
 
@@ -4525,10 +4954,12 @@ shadow root names a table in that root rather than in the document. A
 Absent falls back to the table's own caption, which is usually the right
 words and is already written. */
   label?: (HelixLineChart["label"]) | undefined;
-  /** Whether a wash is drawn under each line.
+  /** Whether a wash is drawn under each line, each from the floor on its own.
+The washes overlap rather than add up: for parts that make a total, use
+`Area Chart`, which stacks them.
 
 Absent is lines alone, which is what suits more than one series: washes
-stack and the lower ones are read through the upper. One series over a
+overlap and the lower ones are read through the upper. One series over a
 ground it should feel like a quantity against is the case for this. */
   area?: (HelixLineChart["area"]) | undefined;
   /** How the line gets from one reading to the next.
@@ -4951,6 +5382,17 @@ Only meaningful beside an `href`, and only for a file served from this
 origin: the attribute is ignored cross-origin, which is the browser's rule
 about who may name a file on somebody's disk rather than a gap here. */
   download?: (HelixMenuItem["download"]) | undefined;
+  /** Whether only one row of the set it belongs to can be on.
+
+Announcement and nothing else, the way `checkable` is: this element applies
+no choice and polices no group, so what it does is tell a reader which kind
+of set they are in. `menuitemcheckbox` says every row here is independent,
+which for a run of comparisons, or the values of a filter that compares
+against one, is the opposite of true.
+
+Meaningless without `checkable`, since a row that cannot be ticked is not
+one of a set of anything. */
+  exclusive?: (HelixMenuItem["exclusive"]) | undefined;
   /** Where the row goes, which makes it a real link.
 
 **The row itself becomes an `<a>`, and the role goes with it.** A
@@ -4982,13 +5424,14 @@ 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 this row's submenu is the page showing.
+  /** 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. The element that holds the
-page has to keep the slot even when it shows no row of its own. */
+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;
 };
 
@@ -5183,6 +5626,63 @@ export type HelixNavigationVueProps = {
 
 export type HelixNavigationVueEvents = {};
 
+/** `HelixNotificationGroup` component event */
+export type HelixNotificationGroupElementEvent<E = Event> = TypedEvent<
+  HelixNotificationGroup,
+  E
+>;
+/** `helix-before-close` event type */
+export type HelixNotificationGroupHelixBeforeCloseElementEvent =
+  HelixNotificationGroupElementEvent<HelixBeforeCloseEvent>;
+/** `helix-before-open` event type */
+export type HelixNotificationGroupHelixBeforeOpenElementEvent =
+  HelixNotificationGroupElementEvent<HelixBeforeOpenEvent>;
+
+export type HelixNotificationGroupVueProps = {
+  /** Whether the element is open.
+
+One property, not two, so `dialog.open` answers the question anyone
+asking it meant. Writing always applies; `<helix-dialog open>` is the
+same statement in markup.
+
+**Not reflected, and that is required rather than tidy.** Reflection
+writes the resolved state back as an attribute, so an element that opened
+itself would put `open` on its own host: cloned, serialized for
+hydration, or diffed by a framework, it comes back holding whatever the
+last reader did rather than what the author wrote. `:state(open)` carries
+the resolved state for stylesheets, which is what the mirror is for. */
+  open?: (HelixNotificationGroup["open"]) | undefined;
+  /** Initial open state for uncontrolled use, where nothing declared one. */
+  "default-open"?: (HelixNotificationGroup["defaultOpen"]) | undefined;
+  /** Initial open state for uncontrolled use, where nothing declared one. */
+  defaultOpen?: (HelixNotificationGroup["defaultOpen"]) | undefined;
+  /** Whether the group can be collapsed to its first row.
+
+Off by default, because a group is a heading before it is a control: a feed
+cut by day wants its days named and rarely wants them folded, and a control
+that does nothing anybody asked for is still a tab stop. */
+  collapsible?: (HelixNotificationGroup["collapsible"]) | undefined;
+  /** How many notifications this group stands for.
+
+**Not the number of rows, and that is the point.** A group saying five with
+one row under it and a link to the rest is the ordinary shape of a feed that
+has been trimmed, and deriving this from the children would make it
+unsayable. Left off, it is the number of rows. */
+  count?: (HelixNotificationGroup["count"]) | undefined;
+  /** What the group is called: a day, a subject, a person.
+
+The slot's fallback rather than its replacement, so a consumer who wants a
+mark beside the name slots `label` and this goes unused. */
+  label?: (HelixNotificationGroup["label"]) | undefined;
+};
+
+export type HelixNotificationGroupVueEvents = {
+  /** Fired before the group folds, and cancelable. */
+  "helix-before-close": HelixNotificationGroupHelixBeforeCloseElementEvent;
+  /** Fired before the group unfolds. Cancelable: refusing it takes the decision and nothing moves. */
+  "helix-before-open": HelixNotificationGroupHelixBeforeOpenElementEvent;
+};
+
 /** `HelixNotification` component event */
 export type HelixNotificationElementEvent<E = Event> = TypedEvent<
   HelixNotification,
@@ -5196,6 +5696,24 @@ export type HelixNotificationHelixReadElementEvent =
   HelixNotificationElementEvent<HelixReadEvent>;
 
 export type HelixNotificationVueProps = {
+  /** How a row is told apart from the one above it.
+
+`plain` is the resting one and is a hairline and nothing else: the row has
+no box of its own, and what separates it is a line the list draws between
+them. It is sayable rather than only reachable by leaving the attribute off,
+which is the reason `Announcement` gives for spelling out its own neutral.
+
+`outlined` and `filled` make each row a box: an edge, a corner, and a gap
+where the hairline was. A feed of boxes is a different reading of the same
+content, and which one is right depends on whether the rows are a list to
+scan or a set of things to act on. The reference this came from draws cards
+because every row in it has a control.
+
+**On the row and not on the feed, because the row is the box being
+separated.** A consumer wanting the whole feed carded says so once, in a
+document rule on the element, rather than on every item: this is a styled
+axis and a stylesheet is where it is set. */
+  separation?: (HelixNotification["separation"]) | undefined;
   /** When it happened, as anything `Date` parses.
 
 An ISO string is what an API sends and what `<time datetime>` takes, so it
@@ -5245,6 +5763,9 @@ export type HelixNotificationsElementEvent<E = Event> = TypedEvent<
   HelixNotifications,
   E
 >;
+/** `helix-dismiss` event type */
+export type HelixNotificationsHelixDismissElementEvent =
+  HelixNotificationsElementEvent<HelixDismissEvent>;
 /** `helix-read` event type */
 export type HelixNotificationsHelixReadElementEvent =
   HelixNotificationsElementEvent<HelixReadEvent>;
@@ -5277,6 +5798,8 @@ say that without the component knowing what a row looks like. */
 };
 
 export type HelixNotificationsVueEvents = {
+  /** A row asking to be removed, dispatched by the row and heard here because the feed is what a consumer holds. Cancelable: refusing it takes the decision and the row stays. */
+  "helix-dismiss": HelixNotificationsHelixDismissElementEvent;
   /** Fired by an item, and by this element when everything is marked read. Cancelable. */
   "helix-read": HelixNotificationsHelixReadElementEvent;
 };
@@ -5407,6 +5930,65 @@ export type HelixNumberInputVueEvents = {
   "helix-before-change": HelixNumberInputHelixBeforeChangeElementEvent;
 };
 
+/** `HelixObjectInspector` component event */
+export type HelixObjectInspectorElementEvent<E = Event> = TypedEvent<
+  HelixObjectInspector,
+  E
+>;
+/** `helix-copy` event type */
+export type HelixObjectInspectorHelixCopyElementEvent =
+  HelixObjectInspectorElementEvent<HelixCopyEvent>;
+
+export type HelixObjectInspectorVueProps = {
+  /** How many levels start open.
+
+One by default: the root is open and everything under it closed, so a
+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. */
+  "default-depth"?: (HelixObjectInspector["defaultDepth"]) | undefined;
+  /** How many levels start open.
+
+One by default: the root is open and everything under it closed, so a
+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;
+  /** The id of a `<script type="application/json">` holding the value.
+
+Read once the document exists, and again whenever this changes. Text that
+does not parse leaves the inspector empty rather than throwing, since a
+page's markup should not take the page down over a comma. */
+  for?: (HelixObjectInspector["for"]) | undefined;
+  /** Accessible name for the tree, and the text of the header where there is one. */
+  label?: (HelixObjectInspector["label"]) | undefined;
+  /** Whether to leave the copy button off.
+
+Negative for the reason Code Block's is: a boolean attribute defaulting to
+true could never be turned off from markup. */
+  "no-copy"?: (HelixObjectInspector["noCopy"]) | undefined;
+  /** Whether to leave the copy button off.
+
+Negative for the reason Code Block's is: a boolean attribute defaulting to
+true could never be turned off from markup. */
+  noCopy?: (HelixObjectInspector["noCopy"]) | undefined;
+  /** Whether to draw only the rows in view.
+
+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 value itself, for a page that already holds it.
+
+Takes precedence over `for`. Anything JSON can say is drawn; anything else
+is shown as its string. */
+  value?: (HelixObjectInspector["value"]) | undefined;
+};
+
+export type HelixObjectInspectorVueEvents = {
+  /** A value was put on the clipboard, from the copy button or the keyboard. */
+  "helix-copy": HelixObjectInspectorHelixCopyElementEvent;
+};
+
 export type HelixOptionGroupVueProps = {
   /** The heading over the run. */
   label?: (HelixOptionGroup["label"]) | undefined;
@@ -5574,7 +6156,8 @@ JavaScript rather than CSS decides. */
   behavior?: (HelixOutline["behavior"]) | undefined;
   /** Accessible name for the navigation. */
   label?: (HelixOutline["label"]) | undefined;
-  /** How far below the top of the window a heading counts as reached, in pixels.
+  /** How far below the top of what scrolls a heading counts as reached, in
+pixels: the window, or the panel the sections scroll in.
 
 The reading line. A page with a sticky masthead sets this to its height, or
 a little more: without it the current section changes as a heading slides
@@ -6120,6 +6703,9 @@ export type HelixRadioGroupElementEvent<E = Event> = TypedEvent<
 /** `helix-before-change` event type */
 export type HelixRadioGroupHelixBeforeChangeElementEvent =
   HelixRadioGroupElementEvent<HelixBeforeChangeEvent>;
+/** `helix-select` event type */
+export type HelixRadioGroupHelixSelectElementEvent =
+  HelixRadioGroupElementEvent<HelixSelectEvent>;
 
 export type HelixRadioGroupVueProps = {
   /** The value the markup declared, which is where a reset returns to. */
@@ -6185,6 +6771,8 @@ export type HelixRadioGroupVueEvents = {
   change: HelixRadioGroupElementEvent;
   /** Fired when the answer changes, and cancelable. */
   "helix-before-change": HelixRadioGroupHelixBeforeChangeElementEvent;
+  /** Fired when an answer is chosen. Dispatched by the radio and listened for here, because the group is what a consumer holds. Cancelable: refusing it takes the decision and nothing moves. */
+  "helix-select": HelixRadioGroupHelixSelectElementEvent;
 };
 
 /** `HelixRadio` component event */
@@ -6482,12 +7070,24 @@ export type HelixSandboxPreviewVueEvents = {
 
 /** `HelixSandbox` component event */
 export type HelixSandboxElementEvent<E = Event> = TypedEvent<HelixSandbox, E>;
+/** `helix-before-edit` event type */
+export type HelixSandboxHelixBeforeEditElementEvent =
+  HelixSandboxElementEvent<HelixBeforeEditEvent>;
 /** `helix-before-panel-resize` event type */
 export type HelixSandboxHelixBeforePanelResizeElementEvent =
   HelixSandboxElementEvent<HelixBeforePanelResizeEvent>;
 /** `helix-before-split` event type */
 export type HelixSandboxHelixBeforeSplitElementEvent =
   HelixSandboxElementEvent<HelixBeforeSplitEvent>;
+/** `helix-caret` event type */
+export type HelixSandboxHelixCaretElementEvent =
+  HelixSandboxElementEvent<HelixCaretEvent>;
+/** `helix-console` event type */
+export type HelixSandboxHelixConsoleElementEvent =
+  HelixSandboxElementEvent<HelixConsoleEvent>;
+/** `helix-resize` event type */
+export type HelixSandboxHelixResizeElementEvent =
+  HelixSandboxElementEvent<HelixResizeEvent>;
 
 export type HelixSandboxVueProps = {
   /** Accessible name for the divider that moves both at once. */
@@ -6573,10 +7173,18 @@ and only whoever slotted it knows how tall that is. */
 };
 
 export type HelixSandboxVueEvents = {
+  /** Fired before the source is edited, by the source pane and heard here. Cancelable: refusing it takes the decision and nothing moves. */
+  "helix-before-edit": HelixSandboxHelixBeforeEditElementEvent;
   /** Fired before the panel's divider is let go, with its height in pixels. Cancelable: refusing it takes the decision and nothing moves. */
   "helix-before-panel-resize": HelixSandboxHelixBeforePanelResizeElementEvent;
   /** Fired before the panes' divider is let go, with the lead pane's share. Cancelable: refusing it takes the decision and nothing moves. */
   "helix-before-split": HelixSandboxHelixBeforeSplitElementEvent;
+  /** Fired when the cursor moves in the source, by the source pane and heard here. */
+  "helix-caret": HelixSandboxHelixCaretElementEvent;
+  /** Relayed from the frame by the preview pane, one per console call. */
+  "helix-console": HelixSandboxHelixConsoleElementEvent;
+  /** How tall the frame's content is, from the preview pane, whenever it changes. */
+  "helix-resize": HelixSandboxHelixResizeElementEvent;
 };
 
 /** `HelixSandboxSource` component event */
@@ -6648,6 +7256,40 @@ export type HelixSandboxToolbarVueProps = {};
 
 export type HelixSandboxToolbarVueEvents = {};
 
+export type HelixScatterChartVueProps = {
+  /** The id of the table to read.
+
+Resolved through `getRootNode()`, so a chart inside another component's
+shadow root names a table in that root rather than in the document. A
+`<table>` or anything built from grid roles, including `helix-table`.
+
+**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?: (HelixScatterChart["for"]) | undefined;
+  /** The drawing's name, for a pointer resting on it.
+
+Absent falls back to the table's own caption, which is usually the right
+words and is already written. */
+  label?: (HelixScatterChart["label"]) | undefined;
+  /** What to call the strength of the relation in the summary. */
+  "correlation-label"?: (HelixScatterChart["correlationLabel"]) | undefined;
+  /** What to call the strength of the relation in the summary. */
+  correlationLabel?: (HelixScatterChart["correlationLabel"]) | undefined;
+  /** Which rules are drawn across the plot, if any.
+
+Both axes are measured, so the values name an axis rather than a role:
+`x` rules the levels across, `y` the levels up. A bare `gridlines`, or
+anything unrecognized, means `both`, since neither axis is the one a scatter
+is read along. */
+  gridlines?: (HelixScatterChart["gridlines"]) | undefined;
+  /** What to call a row in the summary, which counts them. */
+  "points-label"?: (HelixScatterChart["pointsLabel"]) | undefined;
+  /** What to call a row in the summary, which counts them. */
+  pointsLabel?: (HelixScatterChart["pointsLabel"]) | undefined;
+};
+
+export type HelixScatterChartVueEvents = {};
+
 export type HelixScrollAreaVueProps = {
   /** Names the region, for a reader arriving at it out of context.
 
@@ -6818,6 +7460,23 @@ Unset is a block, which is what most missing things are. */
 
 export type HelixSkeletonVueEvents = {};
 
+export type HelixSkipLinkVueProps = {
+  /** Where the reader is sent, as an in-page fragment.
+
+`#main` by default, because that is the id the content region almost always
+has; a page whose content is somewhere else says so. Anything that is not a
+fragment naming an element on the page is left to the browser, as a plain
+link. */
+  href?: (HelixSkipLink["href"]) | undefined;
+  /** The link's words, for the common case of plain text.
+
+The fallback of the default slot, so slotted content replaces it rather than
+appearing beside it. */
+  label?: (HelixSkipLink["label"]) | undefined;
+};
+
+export type HelixSkipLinkVueEvents = {};
+
 /** `HelixSlider` component event */
 export type HelixSliderElementEvent<E = Event> = TypedEvent<HelixSlider, E>;
 /** `helix-before-change` event type */
@@ -7091,6 +7750,9 @@ export type HelixSpeedDialHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixSpeedDialHelixBeforeOpenElementEvent =
   HelixSpeedDialElementEvent<HelixBeforeOpenEvent>;
+/** `helix-select` event type */
+export type HelixSpeedDialHelixSelectElementEvent =
+  HelixSpeedDialElementEvent<HelixSelectEvent>;
 
 export type HelixSpeedDialVueProps = {
   /** Whether the element is open.
@@ -7126,6 +7788,8 @@ export type HelixSpeedDialVueEvents = {
   "helix-before-close": HelixSpeedDialHelixBeforeCloseElementEvent;
   /** Fired before it opens, and cancelable. */
   "helix-before-open": HelixSpeedDialHelixBeforeOpenElementEvent;
+  /** Fired when an action is chosen. Dispatched by the action and listened for here, and the dial closes behind it once it has been heard. Cancelable: refusing it takes the decision and the dial stays open. */
+  "helix-select": HelixSpeedDialHelixSelectElementEvent;
   /** Says the state moved, carrying `newState` and `oldState`. */
   toggle: HelixSpeedDialElementEvent;
 };
@@ -7302,6 +7966,9 @@ export type HelixStepsHelixActivateElementEvent =
 /** `helix-before-activate` event type */
 export type HelixStepsHelixBeforeActivateElementEvent =
   HelixStepsElementEvent<HelixBeforeActivateEvent>;
+/** `helix-select` event type */
+export type HelixStepsHelixSelectElementEvent =
+  HelixStepsElementEvent<HelixSelectEvent>;
 
 export type HelixStepsVueProps = {
   /** Which item is current, by its `value`.
@@ -7356,6 +8023,8 @@ export type HelixStepsVueEvents = {
   "helix-activate": HelixStepsHelixActivateElementEvent;
   /** Fired before the active step changes. Cancelable: refusing it takes the decision and nothing moves. */
   "helix-before-activate": HelixStepsHelixBeforeActivateElementEvent;
+  /** Fired when a step is pressed. Dispatched by the step and listened for here, because the root is what a consumer holds. Cancelable: refusing it takes the decision and nothing moves. */
+  "helix-select": HelixStepsHelixSelectElementEvent;
 };
 
 /** `HelixStep` component event */
@@ -7454,6 +8123,15 @@ export type HelixTableCellVueProps = {
 
 export type HelixTableCellVueEvents = {};
 
+/** `HelixTableColumn` component event */
+export type HelixTableColumnElementEvent<E = Event> = TypedEvent<
+  HelixTableColumn,
+  E
+>;
+/** `helix-before-resize` event type */
+export type HelixTableColumnHelixBeforeResizeElementEvent =
+  HelixTableColumnElementEvent<HelixBeforeResizeEvent>;
+
 export type HelixTableColumnVueProps = {
   /** Which edge the values line up against.
 
@@ -7475,6 +8153,13 @@ after a column moves is a sort a consumer cannot store in a URL.
 Empty on a column that is purely presentational, an actions column say, and
 such a column is never sortable however it is marked. */
   field?: (HelixTableColumn["field"]) | undefined;
+  /** Whether a reader may change this column's width.
+
+By dragging the edge at the end of the heading, or with the arrow keys once
+it has focus, a step at a time and four with Shift. The width lands in
+`width` as pixels, and `helix-before-resize` asks first, so a consumer who
+stores the widths can take the decision. */
+  resizable?: (HelixTableColumn["resizable"]) | undefined;
   /** Whether a reader may reorder the set by this column.
 
 Ignored without a `field`, and silently: a column with nothing to sort by
@@ -7520,7 +8205,10 @@ correct default: the raw value is what an API sorted by. */
   compare?: (HelixTableColumn["compare"]) | undefined;
 };
 
-export type HelixTableColumnVueEvents = {};
+export type HelixTableColumnVueEvents = {
+  /** Fired as a reader resizes the column, with the width asked for, and cancelable. */
+  "helix-before-resize": HelixTableColumnHelixBeforeResizeElementEvent;
+};
 
 export type HelixTableVueProps = {
   /** What is said where there are none, and none are coming. */
@@ -7685,7 +8373,17 @@ neither. That is the test the whole axis registry answers to. */
   /** Which status the tag reports.
 
 `tone` is semantic color, which is what these are and what `helix-text`
-already calls them. `helix component`'s `axes` holds the vocabulary. */
+already calls them. `helix component`'s `axes` holds the vocabulary.
+
+**Not all seven are statuses, and `accent` is the one worth saying out
+loud**: it is the second emphasis, a rotation off the brand seed rather than
+a color of its own, so it stays in relation when somebody rethemes.
+`primary` is the seed itself. The four that are statuses are the four
+`HelixStatusTone` names, and those are the ones that would carry a glyph
+somewhere that draws one.
+
+`Badge` and `Announcement` take the same seven, all three being a mark that
+carries a meaning beside something else. */
   tone?: (HelixTag["tone"]) | undefined;
   /** Whether it offers a control to take it away. */
   dismissible?: (HelixTag["dismissible"]) | undefined;
@@ -7715,21 +8413,31 @@ export type HelixTextVueProps = {
 
 Decides the outline and the semantics. */
   as?: (HelixText["as"]) | undefined;
-  /** Color role. A separate axis from the type ramp, because color carries
-state: folding it in would mean `caption-danger` and the rest of the cross
-product.
+  /** How loud the text is, beside what it means.
+
+`muted` is the quiet ink that still has to be read, and `subtle` the
+quieter one below it. Two axes because the test says so: a line can be a
+danger *and* quiet at once, and a muted danger is what a validation hint
+under a field is.
+
+**With a `tone`, both are that tone's one quiet ink**: the tone's hue at half
+its chroma, as readable as the tone. The readable range holds one quiet step
+and not two, measured in #124 for the neutral ink, and a tone has less room
+there rather than more, so `subtle` on a tone is the same ink as `muted`
+rather than a second one that could not be read.
+
+The resting case is the absent attribute, full strength. */
+  emphasis?: (HelixText["emphasis"]) | undefined;
+  /** What the text means. A separate axis from the type ramp, because color
+carries state: folding it in would mean `caption-danger` and the rest of the
+cross product.
 
 **There is no `default` value**, and one must not be added: it would match
 no rule and fall through to the inherited ink, reading as working while
 saying nothing. The resting case is the absent attribute.
 
-**`muted` and `subtle` are weight rather than meaning and belong on
-`emphasis`, which is why this is still off the registry.** Splitting them
-out is blocked on the palette rather than on the rename: there is a quiet
-step for the neutral ink and none for any other tone, so a muted danger has
-nothing to be made of. `primary-subtle` is a tinted *ground* and not a
-quiet ink. That is #141's to derive, and until it does, folding the two
-halves apart would leave three of the four combinations unsayable. */
+Weight is not a tone. How loud the text is belongs on `emphasis`, which is
+why `muted` and `subtle` moved there. */
   tone?: (HelixText["tone"]) | undefined;
   /** Type treatment.
 
@@ -8340,6 +9048,12 @@ export type HelixToastItemVueEvents = {
   "helix-dismiss": HelixToastItemHelixDismissElementEvent;
 };
 
+/** `HelixToast` component event */
+export type HelixToastElementEvent<E = Event> = TypedEvent<HelixToast, E>;
+/** `helix-dismiss` event type */
+export type HelixToastHelixDismissElementEvent =
+  HelixToastElementEvent<HelixDismissEvent>;
+
 export type HelixToastVueProps = {
   /** Accessible name for the region, such as "Notifications". */
   label?: (HelixToast["label"]) | undefined;
@@ -8358,7 +9072,10 @@ departures, which is what `orientation` does. */
   placement?: (HelixToast["placement"]) | undefined;
 };
 
-export type HelixToastVueEvents = {};
+export type HelixToastVueEvents = {
+  /** A message asking to go, by its control or by its timer, dispatched by the message and heard here because the stack is what a consumer holds. Cancelable: refusing it takes the decision and the message stays. */
+  "helix-dismiss": HelixToastHelixDismissElementEvent;
+};
 
 /** `HelixToggleGroup` component event */
 export type HelixToggleGroupElementEvent<E = Event> = TypedEvent<
@@ -8674,6 +9391,9 @@ export type HelixTourHelixBeforeCloseElementEvent =
 /** `helix-complete` event type */
 export type HelixTourHelixCompleteElementEvent =
   HelixTourElementEvent<HelixCompleteEvent>;
+/** `helix-tour-ask` event type */
+export type HelixTourHelixTourAskElementEvent =
+  HelixTourElementEvent<HelixTourAskEvent>;
 
 export type HelixTourVueProps = {
   /** Label for the control that goes back, handed to every stop. */
@@ -8724,6 +9444,8 @@ export type HelixTourVueEvents = {
   "helix-before-close": HelixTourHelixBeforeCloseElementEvent;
   /** Fired when the last stop is finished. */
   "helix-complete": HelixTourHelixCompleteElementEvent;
+  /** A stop's own controls asking the tour to move, dispatched by the stop and heard here because the tour is what moves. */
+  "helix-tour-ask": HelixTourHelixTourAskElementEvent;
   /** Says the state moved, carrying `newState` and `oldState`. */
   toggle: HelixTourElementEvent;
 };
@@ -9387,6 +10109,16 @@ export type CustomCssProperties = {
   "--app-header-max-inline-size"?: (string) | undefined;
   /** Inline padding of the banner. */
   "--app-header-padding"?: (string) | undefined;
+  /** Height of the drawing. */
+  "--area-chart-block-size"?: (string) | undefined;
+  /** How much of its series' color a band takes, as a percentage mixed toward the page. */
+  "--area-chart-fill-strength"?: (string) | undefined;
+  /** Space between the drawing and its labels. */
+  "--area-chart-gap"?: (string) | undefined;
+  /** One rule across the plot, under `gridlines`. */
+  "--area-chart-gridline-color"?: (string) | undefined;
+  /** Thickness of a band's top edge. */
+  "--area-chart-width"?: (string) | undefined;
   /** How far each avatar sits over the one before it. */
   "--avatar-group-overlap"?: (string) | undefined;
   /** The separation drawn between one avatar and the next. */
@@ -9659,6 +10391,8 @@ export type CustomCssProperties = {
   "--date-picker-track-size"?: (string) | undefined;
   /** How many month columns are drawn, capped at two. `--date-picker-columns` overrides it. */
   "--date-picker-column-count"?: (string) | undefined;
+  /** Space between one pair and the next. */
+  "--description-list-gap"?: (string) | undefined;
   /** Color of the panel's edge. */
   "--dialog-border-color"?: (string) | undefined;
   /** Width of the panel's edge. Follows `--helix-border-floating`, which is `0`, so the panel is told apart by its lift unless a theme says otherwise. */
@@ -9727,6 +10461,16 @@ export type CustomCssProperties = {
   "--file-input-background-color"?: (string) | undefined;
   /** Padding inside the field. */
   "--file-input-padding"?: (string) | undefined;
+  /** Fill behind the chip. */
+  "--filter-input-chip-background-color"?: (string) | undefined;
+  /** Color of the edge. */
+  "--filter-input-chip-border-color"?: (string) | undefined;
+  /** Corner radius of the chip. */
+  "--filter-input-chip-radius"?: (string) | undefined;
+  /** Space either side of a slotted control's label. Follows `--helix-space-xs`, which is what a token uses. */
+  "--filter-input-action-padding-inline"?: (string) | undefined;
+  /** Height of a control slotted at either end. Follows `--helix-size-tag`, so it matches the tokens beside it rather than the field around them. */
+  "--filter-input-action-size"?: (string) | undefined;
   /** Fill behind the field. */
   "--filter-input-background-color"?: (string) | undefined;
   /** Color of the suggestion panel's edge. */
@@ -9735,6 +10479,8 @@ export type CustomCssProperties = {
   "--filter-input-border-width"?: (string) | undefined;
   /** Smallest the text keeps as tokens fill the line, before it wraps to its own. */
   "--filter-input-control-size"?: (string) | undefined;
+  /** The seam between the leading box and the text. */
+  "--filter-input-lead-border-color"?: (string) | undefined;
   /** Width of the suggestion panel. Follows the field by default. */
   "--filter-input-panel-size"?: (string) | undefined;
   /** Lift under the panel. Follows `--helix-shadow-floating`: a floating surface sits over content nobody can predict, so it keeps a lift by default. */
@@ -9911,6 +10657,14 @@ export type CustomCssProperties = {
   "--notifications-color"?: (string) | undefined;
   /** Ink on the control that removes an item, which is `danger` because removing one is the end of it. */
   "--notifications-dismiss-color"?: (string) | undefined;
+  /** Color of a carded row's border. */
+  "--notifications-item-edge"?: (string) | undefined;
+  /** Fill behind a `filled` row. */
+  "--notifications-item-fill"?: (string) | undefined;
+  /** Space between carded rows, which replaces the hairline. */
+  "--notifications-item-gap"?: (string) | undefined;
+  /** Corner radius of a carded row. */
+  "--notifications-item-radius"?: (string) | undefined;
   /** Space above and below an item. */
   "--notifications-padding-block"?: (string) | undefined;
   /** Space either side of an item. */
@@ -9933,6 +10687,18 @@ export type CustomCssProperties = {
   "--notifications-max-block-size"?: (string) | undefined;
   /** The gutter every item holds open where something in the feed has media. */
   "--notifications-media-column"?: (string) | undefined;
+  /** Ground under the tree. */
+  "--object-inspector-background-color"?: (string) | undefined;
+  /** Height of the scrolling box, when windowed. */
+  "--object-inspector-block-size"?: (string) | undefined;
+  /** The edge around the tree and its header. */
+  "--object-inspector-border-color"?: (string) | undefined;
+  /** The bar carrying the label. */
+  "--object-inspector-header-background-color"?: (string) | undefined;
+  /** Corner radius of the tree. */
+  "--object-inspector-radius"?: (string) | undefined;
+  /** How deep a row is, from 0 at the root, for indenting it. */
+  "--object-inspector-level"?: (string) | undefined;
   /** Wash behind the option the keyboard is on. */
   "--option-active-color"?: (string) | undefined;
   /** Space above and below it. `Command` raises this, a palette being a page of rows read at speed rather than a select's short list. */
@@ -10049,6 +10815,24 @@ export type CustomCssProperties = {
   "--sandbox-toolbar-gap"?: (string) | undefined;
   /** The bar's height. Defaults to a large control. */
   "--sandbox-toolbar-size"?: (string) | undefined;
+  /** Height of the drawing. */
+  "--scatter-chart-block-size"?: (string) | undefined;
+  /** Space between the drawing and its axes. */
+  "--scatter-chart-gap"?: (string) | undefined;
+  /** One rule across the plot, under `gridlines`. */
+  "--scatter-chart-gridline-color"?: (string) | undefined;
+  /** How much of its color a point shows, so a cluster reads darker where it is denser. */
+  "--scatter-chart-point-opacity"?: (string) | undefined;
+  /** The ring around each point, which is the page's color unless the chart sits on something else. */
+  "--scatter-chart-point-ring-color"?: (string) | undefined;
+  /** Diameter of a point. */
+  "--scatter-chart-point-size"?: (string) | undefined;
+  /** Where a point sits across, as a percentage. Written by the component. */
+  "--chart-point-x"?: (string) | undefined;
+  /** Where a point sits up, as a percentage from the top. Written by the component. */
+  "--chart-point-y"?: (string) | undefined;
+  /** Where a tick sits along its axis, as a percentage. Written by the component. */
+  "--chart-tick"?: (string) | undefined;
   /** How deep the fades are, at both edges. */
   "--scroll-area-fade"?: (string) | undefined;
   /** And the bottom one. */
@@ -10077,6 +10861,12 @@ export type CustomCssProperties = {
   "--select-surface-max-block-size"?: (string) | undefined;
   /** Diameter of the circle shape. */
   "--skeleton-size"?: (string) | undefined;
+  /** Color of the revealed link's edge. */
+  "--skip-link-border-color"?: (string) | undefined;
+  /** Width of the revealed link's edge. Follows `--helix-border-floating`, which is `0`, so the link is told apart by its lift unless a theme says otherwise. */
+  "--skip-link-border-width"?: (string) | undefined;
+  /** Lift under the revealed link. Follows `--helix-shadow-floating`, since it sits over whatever the page has at its corner. */
+  "--skip-link-shadow"?: (string) | undefined;
   /** The part behind the thumb. */
   "--slider-fill-color"?: (string) | undefined;
   /** How long a vertical track is. Nine rem by default, and read only when `orientation` is `vertical`, a horizontal track taking the width of its row. */
@@ -10343,6 +11133,12 @@ export interface WcToolkitVueGlobalComponents {
     HelixAppHeaderVueProps,
     HelixAppHeaderVueEvents
   >;
+  /** The bands take the series palette in order, the first column at the bottom, so a legend beside the chart names them in the order they are stacked.  Each band is a pale fill with its top edge drawn at the series' full color. The fills are mixed toward the page rather than made translucent, because the bands overlap where they are drawn and a translucent one would show the others through it. */
+  "helix-area-chart": DefineCustomElement<
+    HelixAreaChart,
+    HelixAreaChartVueProps,
+    HelixAreaChartVueEvents
+  >;
   /** One fragment shader over a full-screen triangle, with the palette read from the tokens rather than given as colors. A background written with hex values is an asset that has to be re-cut when the brand moves; one written against '--helix-color-primary' is a consequence of it.  **Every shape ramps through four token stops**, and the token layer inverts each: the page's background, 'primary-subtle', 'primary', then 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 takes the chroma out of the pixels carrying most of it. Which way the page runs is read off the ground's own luminance rather than asked of the mode, which is a private token.  **No dependency, and no scene graph.** The geometry is three vertices derived from 'gl_VertexID', so there is no attribute, no buffer and no upload.  **It stops when nobody is looking**, off screen and in a background tab, and 'prefers-reduced-motion' gets one still frame rather than an empty box. */
   "helix-aura": DefineCustomElement<
     HelixAura,
@@ -10451,7 +11247,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixCheckboxVueProps,
     HelixCheckboxVueEvents
   >;
-  /** The header sits above the code rather than floating on it. Overlaid, which is the usual build, the copy button covers the first line, which is the one line of a snippet a reader is most likely to be reading. */
+  /** The header sits above the code rather than floating on it. Overlaid, which is the usual build, the copy button covers the first line, which is the one line of a snippet a reader is most likely to be reading.  A diff is drawn a block per file in the same frame, each changed line washed in its tone at Tag's resting strength with its '+' or '-' in the tone's ink, so the change does not rest on telling two pale grounds apart. A split diff stacks its two versions below about 40rem of the file's own width. */
   "helix-code-block": DefineCustomElement<
     HelixCodeBlock,
     HelixCodeBlockVueProps,
@@ -10511,6 +11307,18 @@ export interface WcToolkitVueGlobalComponents {
     HelixDatePickerVueProps,
     HelixDatePickerVueEvents
   >;
+  /** A subgrid of the list, so the label and value stay one element, and one pair to a screen reader, while lining up with every other pair in the list. */
+  "helix-description-list-item": DefineCustomElement<
+    HelixDescriptionListItem,
+    HelixDescriptionListItemVueProps,
+    HelixDescriptionListItemVueEvents
+  >;
+  /** Each label is quiet and each value takes the text around it, so the eye goes to the values and the labels are there to find them by. With 'direction="row"' the labels share one column, as wide as the longest of them, and the values start on one line beside it.  **Beside falls back to over below about 22rem of its own width**, measured on the list rather than on the viewport, since a details panel is as often a sidebar on a wide screen as the whole of a narrow one. Below that the label column leaves the values too little room to be read.  **'width="auto"' with 'justify="between"' is a summary**: the list as wide as its widest pair, labels on the start edge and values on the end one in figures of one width, which is how a set of totals is read. */
+  "helix-description-list": DefineCustomElement<
+    HelixDescriptionList,
+    HelixDescriptionListVueProps,
+    HelixDescriptionListVueEvents
+  >;
   /** The panel is 'surface-overlay' with a shadow, because that is what it is: a thing over the page rather than on it. The scrim is drawn on '::backdrop', which is the platform's own element for it and sits in the top layer with the dialog rather than being a div somebody positioned. */
   "helix-dialog": DefineCustomElement<
     HelixDialog,
@@ -10559,6 +11367,30 @@ export interface WcToolkitVueGlobalComponents {
     HelixFileInputVueProps,
     HelixFileInputVueEvents
   >;
+  /** Three segments and a control, drawn so the reader's eye lands on the values. The field is the quietest of the three because it is the part they already know, having picked it; the values carry the weight, because a bar of these is scanned for what the filters are set to rather than for what they are on.  The operator segment is drawn only where there is one, which is what keeps the common chip free of jargon. See the headless note, which records the rule. */
+  "helix-filter-chip": DefineCustomElement<
+    HelixFilterChip,
+    HelixFilterChipVueProps,
+    HelixFilterChipVueEvents
+  >;
+  /** A declaration rather than a control: it renders nothing, and the filter input reads it to build its menu. The headless note carries the model.  The stylesheet here is one rule and it is a guard rather than a look. Written where it belongs, inside a filter input, this is never assigned to a slot and so is never rendered at all. Written anywhere else it would be an empty inline box, which is nothing to look at and still a flex item a 'gap' would space away from its neighbors. */
+  "helix-filter-field": DefineCustomElement<
+    HelixFilterField,
+    HelixFilterFieldVueProps,
+    HelixFilterFieldVueEvents
+  >;
+  /** Everything drawn here is drawn by something else: the trigger is the consumer's, and the pages are 'Menu''s, whose reserved tick column is what keeps a page of ticked and unticked values on one edge. This element's own stylesheet is one rule, and it is 'display: contents'.  The headless note carries the model, including why a tick is a filter immediately and why the operator is decided here rather than on the chip. */
+  "helix-filter-menu": DefineCustomElement<
+    HelixFilterMenu,
+    HelixFilterMenuVueProps,
+    HelixFilterMenuVueEvents
+  >;
+  /** A declaration rather than a control: it renders nothing, and the field it is written under reads it. The headless note carries the model, including why the words are the consumer's and never this element's.  The stylesheet is one rule and it is a guard rather than a look, for the reason 'FilterField''s note gives. */
+  "helix-filter-operator": DefineCustomElement<
+    HelixFilterOperator,
+    HelixFilterOperatorVueProps,
+    HelixFilterOperatorVueEvents
+  >;
   /** The frame is the field rather than the input, so the tokens sit inside the same box as the text and the focus ring is drawn once around the whole control. It grows down a line at a time as tokens are added, which is the arrangement Combobox takes when it is holding a selection.  **The tokens are the consumer's own elements**, so the only thing said about them here is to keep their size and not run past the field. A 'Tag' slotted into 'tags' already looks like one; anything else looks like whatever it is.  **The suggestion panel is this element's own box, not a listbox's.** Combobox puts a 'helix-listbox' in its panel because the options there are a selection it owns; these are the consumer's suggestions, so the panel is a plain 'role="listbox"' region and the options pass their own 'helix-select' straight through it. That is why this surface scrolls where Combobox's does not: there is no list inside to do it.  Height comes from the region, like every other control: 'data-density' on whatever holds it, not a 'size' here. */
   "helix-filter-input": DefineCustomElement<
     HelixFilterInput,
@@ -10685,6 +11517,12 @@ export interface WcToolkitVueGlobalComponents {
     HelixNavigationVueProps,
     HelixNavigationVueEvents
   >;
+  /** The heading is chrome: it says which pile a reader is looking at and is never the thing they came to read, so it is drawn quieter than a row's title. A feed cut into five days has five of these, and a heading at the weight of the content turns a list of notifications into a list of dates.  **The stack is two lines rather than two cards.** Collapsed, the rows behind the first are not rendered at all, so there is nothing to see through: what draws the pile is a pair of pseudo-elements above the visible row, offset and inset so they read as the top edges of cards behind it. A shadow could not do it, spreading on four sides where this has a top edge and no bottom one, and having no way to sit narrower than the thing it is behind, which is the cue that says there is something back there. */
+  "helix-notification-group": DefineCustomElement<
+    HelixNotificationGroup,
+    HelixNotificationGroupVueProps,
+    HelixNotificationGroupVueEvents
+  >;
   /** A four-column grid: media, body, actions, dismiss.  **The media column is held open by the feed, not by the item.** Each item is its own grid, so nothing about one row's tracks reaches the row below it: a feed where some items had an avatar and some did not drew its text at two different left edges, which is the fault a grid was chosen to prevent. The root publishes whether anything in it has media and every item reserves that much, so a mixed feed reads down one edge and a feed with no media anywhere pays nothing for the column.  **Unread is weight and a mark on the inline start edge, not a fill.** Depth comes from a single border in this library, and a filled row is elevation spelled differently; a feed of filled rows is a striped list nobody can read. The mark is a fixed height on the first line rather than the height of the row, so it says the same thing about a one line notification and a five line one.  **Narrow, the actions go under the body.** How much room the row was given is a fact about this box and about nothing else, so it is a container query: a feed in a 320 pixel side panel is narrow inside a 1400 pixel window, and a viewport rule would hand it the wide branch. */
   "helix-notification": DefineCustomElement<
     HelixNotification,
@@ -10703,6 +11541,12 @@ export interface WcToolkitVueGlobalComponents {
     HelixNumberInputVueProps,
     HelixNumberInputVueEvents
   >;
+  /** Code Block's frame around a tree of entries. Each type takes its ink from the syntax set the code blocks already use, a key in one, a string in another and a number, a boolean and a null in theirs, and each row is one line with a long string ending in an ellipsis, so every row is one height and a windowed tree never has to measure them one by one. */
+  "helix-object-inspector": DefineCustomElement<
+    HelixObjectInspector,
+    HelixObjectInspectorVueProps,
+    HelixObjectInspectorVueEvents
+  >;
   /** The heading is set small and quiet, because it is a divider that happens to have words on it: a run of options is read as a list and the heading is what tells you which list, not something to read on its own. */
   "helix-option-group": DefineCustomElement<
     HelixOptionGroup,
@@ -10829,6 +11673,12 @@ export interface WcToolkitVueGlobalComponents {
     HelixSandboxToolbarVueProps,
     HelixSandboxToolbarVueEvents
   >;
+  /** The points take the series palette in order, so a table with one column measured up is series one and a table with three is the first three.  Each point has a ring of the page around it and stops short of opaque, so a dense cluster reads as dense rather than as one blot, and two points that overlap each keep their edge. */
+  "helix-scatter-chart": DefineCustomElement<
+    HelixScatterChart,
+    HelixScatterChartVueProps,
+    HelixScatterChartVueEvents
+  >;
   /** Presentation only: the fades on the edges the base class names, and a scrollbar that belongs to the system rather than to the platform. Which edges have content past them is measured by the base class. */
   "helix-scroll-area": DefineCustomElement<
     HelixScrollArea,
@@ -10847,6 +11697,12 @@ export interface WcToolkitVueGlobalComponents {
     HelixSkeletonVueProps,
     HelixSkeletonVueEvents
   >;
+  /** Out of sight until the keyboard reaches it, then in the corner of the viewport and impossible to miss. The hiding is the base layer's visually hidden helper, so the link stays in the tab order and in the accessibility tree while nobody can see it; 'display: none' would have taken it out of both. The reveal is this sheet's.  **Fixed to the viewport rather than placed where it sits in the document**, because it is first in the document and the page may already be scrolled when focus arrives, by a restored position or an anchor in the address. A link revealed above the top of the screen is revealed to nobody.  Put it first inside '<body>', before the header, and give the content region the id its 'href' names. */
+  "helix-skip-link": DefineCustomElement<
+    HelixSkipLink,
+    HelixSkipLinkVueProps,
+    HelixSkipLinkVueEvents
+  >;
   /** The track and the thumb are the browser's own, restyled through the range pseudo-elements rather than replaced. What that buys is everything a hand-built slider has to reimplement and usually gets slightly wrong: the drag, the keys, and a hit area sized by the platform for a finger.  The filled part of the track is painted with a gradient driven by the fraction the headless tier writes, rather than by a second element laid over it. One element cannot be half one color by any other means that survives the thumb being dragged. */
   "helix-slider": DefineCustomElement<
     HelixSlider,
@@ -10954,7 +11810,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixTagVueProps,
     HelixTagVueEvents
   >;
-  /** Two properties, and they answer different questions. 'as' is the element, which decides the document outline and what a screen reader announces. 'variant' is the ramp, which decides size, weight, leading, and tracking together.  They are separate because they genuinely come apart: a section's second heading sometimes has to look smaller without lying about the outline, and a '<p>' sometimes has to read as a caption. They default to matching, so the common case is 'as="h2"' and nothing else.  The pairing is resolved in CSS rather than by computing an attribute, so the element writes nothing to its own host: 'as="h2"' picks up the heading ramp through a selector, and setting 'variant' takes the pairing rule out of play. Deriving it in 'willUpdate' works and must not be done: it puts an attribute on the host that the server's markup does not have, which is a hydration mismatch in every React consumer.  **Size, weight, and leading are not properties.** Exposing them separately offers a few hundred combinations of which a handful are right, and every caller then picks one. A ramp is a decision the system already made: the ramp is named, and a page built from it is consistent because there was nothing else to choose.  'tone' stays separate, because color carries state rather than typography. Folding it in would mean 'caption-danger' and 'label-primary' and the rest of cross product, which is the explosion a named ramp exists to prevent. */
+  /** Two properties, and they answer different questions. 'as' is the element, which decides the document outline and what a screen reader announces. 'variant' is the ramp, which decides size, weight, leading, and tracking together.  They are separate because they genuinely come apart: a section's second heading sometimes has to look smaller without lying about the outline, and a '<p>' sometimes has to read as a caption. They default to matching, so the common case is 'as="h2"' and nothing else.  The pairing is resolved in CSS rather than by computing an attribute, so the element writes nothing to its own host: 'as="h2"' picks up the heading ramp through a selector, and setting 'variant' takes the pairing rule out of play. Deriving it in 'willUpdate' works and must not be done: it puts an attribute on the host that the server's markup does not have, which is a hydration mismatch in every React consumer.  **Size, weight, and leading are not properties.** Exposing them separately offers a few hundred combinations of which a handful are right, and every caller then picks one. A ramp is a decision the system already made: the ramp is named, and a page built from it is consistent because there was nothing else to choose.  'tone' and 'emphasis' stay separate, because color carries state rather than typography, and what a line means is not how loudly it says it. Folding either in would mean 'caption-danger' and 'label-muted' and the rest of the cross product, which is the explosion a named ramp exists to prevent. */
   "helix-text": DefineCustomElement<
     HelixText,
     HelixTextVueProps,