@fusion.dev/helix-headless 0.23.0 → 0.24.0

package/types/vue.d.ts

@@ -3,6 +3,7 @@ import type {
   HelixHeadlessAccordion,
   HelixHeadlessAnnouncement,
   HelixHeadlessAppHeader,
+  HelixHeadlessAreaChart,
   FOLDS_UP_TO,
   HelixHeadlessAvatarGroup,
   initialsOf,
@@ -18,6 +19,7 @@ import type {
   HelixHeadlessCard,
   HelixHeadlessCarousel,
   HelixHeadlessChatComposer,
+  FAILED_LABEL,
   HelixHeadlessChatMessage,
   HelixHeadlessChat,
   HelixHeadlessCheckboxGroup,
@@ -32,6 +34,8 @@ import type {
   HelixHeadlessDataTable,
   HelixHeadlessDateInput,
   HelixHeadlessDatePicker,
+  HelixHeadlessDescriptionListItem,
+  HelixHeadlessDescriptionList,
   HelixHeadlessDialog,
   HelixHeadlessDivider,
   HelixHeadlessDonutChart,
@@ -40,6 +44,10 @@ import type {
   HelixHeadlessDrilldown,
   HelixHeadlessEmpty,
   HelixHeadlessFileInput,
+  HelixHeadlessFilterChip,
+  HelixHeadlessFilterField,
+  HelixHeadlessFilterMenu,
+  HelixHeadlessFilterOperator,
   HelixHeadlessFilterInput,
   HelixHeadlessFormatDate,
   HelixHeadlessHeatmap,
@@ -59,9 +67,11 @@ import type {
   HelixHeadlessMenu,
   HelixHeadlessMeter,
   HelixHeadlessNavigation,
+  HelixHeadlessNotificationGroup,
   HelixHeadlessNotification,
   HelixHeadlessNotifications,
   HelixHeadlessNumberInput,
+  HelixHeadlessObjectInspector,
   HelixHeadlessOptionGroup,
   HelixHeadlessOption,
   HelixHeadlessOutline,
@@ -76,10 +86,12 @@ import type {
   HelixHeadlessRadioGroup,
   HelixHeadlessRadio,
   HelixHeadlessRating,
+  HelixHeadlessScatterChart,
   HelixHeadlessScrollArea,
   EDGES,
   HelixHeadlessSelect,
   HelixHeadlessSkeleton,
+  HelixHeadlessSkipLink,
   HelixHeadlessSlider,
   HelixHeadlessSparkline,
   HelixHeadlessSpeedDialItem,
@@ -91,6 +103,7 @@ import type {
   HelixHeadlessStep,
   HelixHeadlessSwitch,
   HelixHeadlessTableCell,
+  at,
   HelixHeadlessTableColumn,
   HelixHeadlessTable,
   HelixHeadlessTableRow,
@@ -130,6 +143,7 @@ import type {
   HelixSelectEvent,
   HelixSendEvent,
   HelixBeforePinEvent,
+  HelixHistoryEvent,
   HelixBeforeChangeEvent,
   HelixBeforeToggleEvent,
   HelixCopyEvent,
@@ -138,7 +152,9 @@ import type {
   HelixCreateEvent,
   HelixFilterEvent,
   HelixNavigateEvent,
+  HelixReorderEvent,
   HelixSortEvent,
+  HelixFacetEvent,
   HelixResizeEvent,
   HelixShortcutEvent,
   HelixReadEvent,
@@ -294,10 +310,24 @@ export type HelixHeadlessAnnouncementVueProps = {
   /** 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?: (HelixHeadlessAnnouncement["tone"]) | undefined;
   /** Whether it offers a control to take it away. */
   dismissible?: (HelixHeadlessAnnouncement["dismissible"]) | undefined;
@@ -367,6 +397,47 @@ export type HelixHeadlessAppHeaderVueEvents = {
   "helix-scrolled": HelixHeadlessAppHeaderHelixScrolledElementEvent;
 };
 
+export type HelixHeadlessAreaChartVueProps = {
+  /** 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?: (HelixHeadlessAreaChart["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?: (HelixHeadlessAreaChart["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?: (HelixHeadlessAreaChart["share"]) | undefined;
+  /** What to call the sum of the parts, in the tooltip and the summary. */
+  "total-label"?: (HelixHeadlessAreaChart["totalLabel"]) | undefined;
+  /** What to call the sum of the parts, in the tooltip and the summary. */
+  totalLabel?: (HelixHeadlessAreaChart["totalLabel"]) | undefined;
+  /** 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?: (HelixHeadlessAreaChart["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?: (HelixHeadlessAreaChart["label"]) | undefined;
+};
+
+export type HelixHeadlessAreaChartVueEvents = {};
+
 export type HelixHeadlessAvatarGroupVueProps = {
   /** Accessible name for the set, such as "Reviewers". */
   label?: (HelixHeadlessAvatarGroup["label"]) | undefined;
@@ -1023,12 +1094,29 @@ export type HelixHeadlessChatElementEvent<E = Event> = TypedEvent<
 /** `helix-before-pin` event type */
 export type HelixHeadlessChatHelixBeforePinElementEvent =
   HelixHeadlessChatElementEvent<HelixBeforePinEvent>;
+/** `helix-history` event type */
+export type HelixHeadlessChatHelixHistoryElementEvent =
+  HelixHeadlessChatElementEvent<HelixHistoryEvent>;
+/** `helix-send` event type */
+export type HelixHeadlessChatHelixSendElementEvent =
+  HelixHeadlessChatElementEvent<HelixSendEvent>;
 
 export type HelixHeadlessChatVueProps = {
   /** Whether to open pinned, where nothing declared it. */
   "default-pinned"?: (HelixHeadlessChat["defaultPinned"]) | undefined;
   /** Whether to open pinned, where nothing declared it. */
   defaultPinned?: (HelixHeadlessChat["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?: (HelixHeadlessChat["history"]) | undefined;
+  /** What to say while older turns are on their way. */
+  "history-text"?: (HelixHeadlessChat["historyText"]) | undefined;
+  /** What to say while older turns are on their way. */
+  historyText?: (HelixHeadlessChat["historyText"]) | undefined;
   /** Accessible name for the conversation. */
   label?: (HelixHeadlessChat["label"]) | undefined;
   /** Whether the transcript follows new turns to the bottom.
@@ -1053,7 +1141,8 @@ 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?: (HelixHeadlessChat["threshold"]) | undefined;
   /** What is said where there are none, and none are coming. */
   "empty-text"?: (HelixHeadlessChat["emptyText"]) | undefined;
@@ -1069,11 +1158,24 @@ say that without the component knowing what a row looks like. */
   "loading-text"?: (HelixHeadlessChat["loadingText"]) | undefined;
   /** What is said while they are on their way. */
   loadingText?: (HelixHeadlessChat["loadingText"]) | 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?: (HelixHeadlessChat["turns"]) | undefined;
 };
 
 export type HelixHeadlessChatVueEvents = {
   /** Fired when the reader pins or unpins the transcript by scrolling. Cancelable. */
   "helix-before-pin": HelixHeadlessChatHelixBeforePinElementEvent;
+  /** Fired when the reader reaches the oldest turn while `history` is `more`, reporting where they are rather than asking. */
+  "helix-history": HelixHeadlessChatHelixHistoryElementEvent;
+  /** 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": HelixHeadlessChatHelixSendElementEvent;
 };
 
 /** `HelixHeadlessCheckboxGroup` component event */
@@ -1208,7 +1310,15 @@ export type HelixHeadlessCheckboxVueEvents = {
 };
 
 export type HelixHeadlessCodeBlockVueProps = {
-  /** 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?: (HelixHeadlessCodeBlock["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?: (HelixHeadlessCodeBlock["label"]) | undefined;
   /** Whether to leave the copy button off.
 
@@ -1250,6 +1360,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?: (HelixHeadlessCodeBlock["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?: (HelixHeadlessCodeBlock["variant"]) | undefined;
 };
 
 export type HelixHeadlessCodeBlockVueEvents = {};
@@ -1968,6 +2084,12 @@ export type HelixHeadlessDataTableHelixFilterElementEvent =
 /** `helix-navigate` event type */
 export type HelixHeadlessDataTableHelixNavigateElementEvent =
   HelixHeadlessDataTableElementEvent<HelixNavigateEvent>;
+/** `helix-reorder` event type */
+export type HelixHeadlessDataTableHelixReorderElementEvent =
+  HelixHeadlessDataTableElementEvent<HelixReorderEvent>;
+/** `helix-select` event type */
+export type HelixHeadlessDataTableHelixSelectElementEvent =
+  HelixHeadlessDataTableElementEvent<HelixSelectEvent>;
 /** `helix-sort` event type */
 export type HelixHeadlessDataTableHelixSortElementEvent =
   HelixHeadlessDataTableElementEvent<HelixSortEvent>;
@@ -1977,6 +2099,10 @@ export type HelixHeadlessDataTableVueProps = {
   "default-filter"?: (HelixHeadlessDataTable["defaultFilter"]) | undefined;
   /** Query to open with, where nothing declared one. */
   defaultFilter?: (HelixHeadlessDataTable["defaultFilter"]) | undefined;
+  /** Column order to open with, where nothing declared one. */
+  "default-order"?: (HelixHeadlessDataTable["defaultOrder"]) | undefined;
+  /** Column order to open with, where nothing declared one. */
+  defaultOrder?: (HelixHeadlessDataTable["defaultOrder"]) | undefined;
   /** Page to open on, where nothing declared one. */
   "default-page"?: (HelixHeadlessDataTable["defaultPage"]) | undefined;
   /** Page to open on, where nothing declared one. */
@@ -1985,6 +2111,10 @@ export type HelixHeadlessDataTableVueProps = {
   "default-page-size"?: (HelixHeadlessDataTable["defaultPageSize"]) | undefined;
   /** Page size to open with, where nothing declared one. */
   defaultPageSize?: (HelixHeadlessDataTable["defaultPageSize"]) | undefined;
+  /** Keys to open with selected, comma separated, where nothing declared any. */
+  "default-selected"?: (HelixHeadlessDataTable["defaultSelected"]) | undefined;
+  /** Keys to open with selected, comma separated, where nothing declared any. */
+  defaultSelected?: (HelixHeadlessDataTable["defaultSelected"]) | undefined;
   /** Order to open on, where nothing declared one. */
   "default-sort"?: (HelixHeadlessDataTable["defaultSort"]) | undefined;
   /** Order to open on, where nothing declared one. */
@@ -2003,29 +2133,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?: (HelixHeadlessDataTable["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?: (HelixHeadlessDataTable["key"]) | undefined;
+  /** Accessible name for the grid. */
+  label?: (HelixHeadlessDataTable["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?: (HelixHeadlessDataTable["filter"]) | undefined;
-  /** Accessible name for the grid. */
-  label?: (HelixHeadlessDataTable["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?: (HelixHeadlessDataTable["page"]) | undefined;
   /** Whether this element does the work or asks the consumer to.
 
 `client` filters, sorts and pages `rows` itself. `server` applies none of
@@ -2035,6 +2150,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?: (HelixHeadlessDataTable["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?: (HelixHeadlessDataTable["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?: (HelixHeadlessDataTable["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?: (HelixHeadlessDataTable["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"?: (HelixHeadlessDataTable["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?: (HelixHeadlessDataTable["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?: (HelixHeadlessDataTable["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?: (HelixHeadlessDataTable["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
@@ -2114,6 +2287,10 @@ export type HelixHeadlessDataTableVueEvents = {
   "helix-filter": HelixHeadlessDataTableHelixFilterElementEvent;
   /** Fired when a reader asks for another page, and cancelable. */
   "helix-navigate": HelixHeadlessDataTableHelixNavigateElementEvent;
+  /** Fired when a reader asks for the columns in another order, with every field in the new one, and cancelable. */
+  "helix-reorder": HelixHeadlessDataTableHelixReorderElementEvent;
+  /** Fired when a reader changes which rows are selected, with every selected key comma separated, and cancelable. */
+  "helix-select": HelixHeadlessDataTableHelixSelectElementEvent;
   /** Fired when a reader asks for a different order, and cancelable. */
   "helix-sort": HelixHeadlessDataTableHelixSortElementEvent;
 };
@@ -2531,6 +2708,35 @@ export type HelixHeadlessDatePickerVueEvents = {
   input: HelixHeadlessDatePickerElementEvent;
 };
 
+export type HelixHeadlessDescriptionListItemVueProps = {
+  /** 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?: (HelixHeadlessDescriptionListItem["label"]) | undefined;
+};
+
+export type HelixHeadlessDescriptionListItemVueEvents = {};
+
+export type HelixHeadlessDescriptionListVueProps = {
+  /** 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?: (HelixHeadlessDescriptionList["direction"]) | undefined;
+};
+
+export type HelixHeadlessDescriptionListVueEvents = {};
+
 /** `HelixHeadlessDialog` component event */
 export type HelixHeadlessDialogElementEvent<E = Event> = TypedEvent<
   HelixHeadlessDialog,
@@ -2967,6 +3173,171 @@ export type HelixHeadlessFileInputVueEvents = {
   "helix-before-change": HelixHeadlessFileInputHelixBeforeChangeElementEvent;
 };
 
+/** `HelixHeadlessFilterChip` component event */
+export type HelixHeadlessFilterChipElementEvent<E = Event> = TypedEvent<
+  HelixHeadlessFilterChip,
+  E
+>;
+/** `helix-dismiss` event type */
+export type HelixHeadlessFilterChipHelixDismissElementEvent =
+  HelixHeadlessFilterChipElementEvent<HelixDismissEvent>;
+
+export type HelixHeadlessFilterChipVueProps = {
+  /** 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?: (HelixHeadlessFilterChip["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?: (HelixHeadlessFilterChip["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?: (HelixHeadlessFilterChip["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"?: (HelixHeadlessFilterChip["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?: (HelixHeadlessFilterChip["operatorLabel"]) | undefined;
+  /** Whether it offers a control to take it away. */
+  dismissible?: (HelixHeadlessFilterChip["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"?: (HelixHeadlessFilterChip["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?: (HelixHeadlessFilterChip["dismissLabel"]) | undefined;
+};
+
+export type HelixHeadlessFilterChipVueEvents = {
+  /** Fired when the reader asks to remove the filter. Cancelable: refusing it takes the decision and nothing moves. */
+  "helix-dismiss": HelixHeadlessFilterChipHelixDismissElementEvent;
+};
+
+export type HelixHeadlessFilterFieldVueProps = {
+  /** What a reader is shown, in the menu and on every chip built from this field. */
+  label?: (HelixHeadlessFilterField["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?: (HelixHeadlessFilterField["name"]) | undefined;
+};
+
+export type HelixHeadlessFilterFieldVueEvents = {};
+
+/** `HelixHeadlessFilterMenu` component event */
+export type HelixHeadlessFilterMenuElementEvent<E = Event> = TypedEvent<
+  HelixHeadlessFilterMenu,
+  E
+>;
+/** `helix-facet` event type */
+export type HelixHeadlessFilterMenuHelixFacetElementEvent =
+  HelixHeadlessFilterMenuElementEvent<HelixFacetEvent>;
+
+export type HelixHeadlessFilterMenuVueProps = {
+  /** Accessible name for the menu. */
+  label?: (HelixHeadlessFilterMenu["label"]) | undefined;
+};
+
+export type HelixHeadlessFilterMenuVueEvents = {
+  /** Fired when a field's values change. Cancelable: refusing it takes the decision and nothing moves. */
+  "helix-facet": HelixHeadlessFilterMenuHelixFacetElementEvent;
+};
+
+export type HelixHeadlessFilterOperatorVueProps = {
+  /** 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?: (HelixHeadlessFilterOperator["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?: (HelixHeadlessFilterOperator["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?: (HelixHeadlessFilterOperator["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?: (HelixHeadlessFilterOperator["name"]) | undefined;
+};
+
+export type HelixHeadlessFilterOperatorVueEvents = {};
+
 /** `HelixHeadlessFilterInput` component event */
 export type HelixHeadlessFilterInputElementEvent<E = Event> = TypedEvent<
   HelixHeadlessFilterInput,
@@ -2981,6 +3352,15 @@ export type HelixHeadlessFilterInputHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixHeadlessFilterInputHelixBeforeOpenElementEvent =
   HelixHeadlessFilterInputElementEvent<HelixBeforeOpenEvent>;
+/** `helix-dismiss` event type */
+export type HelixHeadlessFilterInputHelixDismissElementEvent =
+  HelixHeadlessFilterInputElementEvent<HelixDismissEvent>;
+/** `helix-facet` event type */
+export type HelixHeadlessFilterInputHelixFacetElementEvent =
+  HelixHeadlessFilterInputElementEvent<HelixFacetEvent>;
+/** `helix-select` event type */
+export type HelixHeadlessFilterInputHelixSelectElementEvent =
+  HelixHeadlessFilterInputElementEvent<HelixSelectEvent>;
 
 export type HelixHeadlessFilterInputVueProps = {
   /** Whether the field offers a button that empties it.
@@ -3085,6 +3465,12 @@ export type HelixHeadlessFilterInputVueEvents = {
   "helix-before-close": HelixHeadlessFilterInputHelixBeforeCloseElementEvent;
   /** Fired before the suggestions show, and cancelable. */
   "helix-before-open": HelixHeadlessFilterInputHelixBeforeOpenElementEvent;
+  /** 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": HelixHeadlessFilterInputHelixDismissElementEvent;
+  /** 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": HelixHeadlessFilterInputHelixFacetElementEvent;
+  /** 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": HelixHeadlessFilterInputHelixSelectElementEvent;
   /** Announced once the text has moved. */
   input: HelixHeadlessFilterInputElementEvent;
   /** Says the panel moved, carrying `newState` and `oldState`. */
@@ -3726,10 +4112,12 @@ shadow root names a table in that root rather than in the document.
 export type HelixHeadlessLegendVueEvents = {};
 
 export type HelixHeadlessLineChartVueProps = {
-  /** 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?: (HelixHeadlessLineChart["area"]) | undefined;
   /** How the line gets from one reading to the next.
@@ -4156,6 +4544,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?: (HelixHeadlessMenuItem["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?: (HelixHeadlessMenuItem["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
@@ -4187,13 +4586,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?: (HelixHeadlessMenuItem["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?: (HelixHeadlessMenuItem["showingSubmenu"]) | undefined;
 };
 
@@ -4374,6 +4774,63 @@ export type HelixHeadlessNavigationVueProps = {
 
 export type HelixHeadlessNavigationVueEvents = {};
 
+/** `HelixHeadlessNotificationGroup` component event */
+export type HelixHeadlessNotificationGroupElementEvent<E = Event> = TypedEvent<
+  HelixHeadlessNotificationGroup,
+  E
+>;
+/** `helix-before-close` event type */
+export type HelixHeadlessNotificationGroupHelixBeforeCloseElementEvent =
+  HelixHeadlessNotificationGroupElementEvent<HelixBeforeCloseEvent>;
+/** `helix-before-open` event type */
+export type HelixHeadlessNotificationGroupHelixBeforeOpenElementEvent =
+  HelixHeadlessNotificationGroupElementEvent<HelixBeforeOpenEvent>;
+
+export type HelixHeadlessNotificationGroupVueProps = {
+  /** 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?: (HelixHeadlessNotificationGroup["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?: (HelixHeadlessNotificationGroup["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?: (HelixHeadlessNotificationGroup["label"]) | undefined;
+  /** Whether the element is open.
+
+One property, not two, so `dialog.open` answers the question anyone
+asking it meant. Writing always applies; `<helix-dialog open>` is the
+same statement in markup.
+
+**Not reflected, and that is required rather than tidy.** Reflection
+writes the resolved state back as an attribute, so an element that opened
+itself would put `open` on its own host: cloned, serialized for
+hydration, or diffed by a framework, it comes back holding whatever the
+last reader did rather than what the author wrote. `:state(open)` carries
+the resolved state for stylesheets, which is what the mirror is for. */
+  open?: (HelixHeadlessNotificationGroup["open"]) | undefined;
+  /** Initial open state for uncontrolled use, where nothing declared one. */
+  "default-open"?: (HelixHeadlessNotificationGroup["defaultOpen"]) | undefined;
+  /** Initial open state for uncontrolled use, where nothing declared one. */
+  defaultOpen?: (HelixHeadlessNotificationGroup["defaultOpen"]) | undefined;
+};
+
+export type HelixHeadlessNotificationGroupVueEvents = {
+  /** Fired before the group folds, and cancelable. */
+  "helix-before-close": HelixHeadlessNotificationGroupHelixBeforeCloseElementEvent;
+  /** Fired before the group unfolds. Cancelable: refusing it takes the decision and nothing moves. */
+  "helix-before-open": HelixHeadlessNotificationGroupHelixBeforeOpenElementEvent;
+};
+
 /** `HelixHeadlessNotification` component event */
 export type HelixHeadlessNotificationElementEvent<E = Event> = TypedEvent<
   HelixHeadlessNotification,
@@ -4436,6 +4893,9 @@ export type HelixHeadlessNotificationsElementEvent<E = Event> = TypedEvent<
   HelixHeadlessNotifications,
   E
 >;
+/** `helix-dismiss` event type */
+export type HelixHeadlessNotificationsHelixDismissElementEvent =
+  HelixHeadlessNotificationsElementEvent<HelixDismissEvent>;
 /** `helix-read` event type */
 export type HelixHeadlessNotificationsHelixReadElementEvent =
   HelixHeadlessNotificationsElementEvent<HelixReadEvent>;
@@ -4468,6 +4928,8 @@ say that without the component knowing what a row looks like. */
 };
 
 export type HelixHeadlessNotificationsVueEvents = {
+  /** 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": HelixHeadlessNotificationsHelixDismissElementEvent;
   /** Fired by an item, and by this element when everything is marked read. Cancelable. */
   "helix-read": HelixHeadlessNotificationsHelixReadElementEvent;
 };
@@ -4598,6 +5060,65 @@ export type HelixHeadlessNumberInputVueEvents = {
   input: HelixHeadlessNumberInputElementEvent;
 };
 
+/** `HelixHeadlessObjectInspector` component event */
+export type HelixHeadlessObjectInspectorElementEvent<E = Event> = TypedEvent<
+  HelixHeadlessObjectInspector,
+  E
+>;
+/** `helix-copy` event type */
+export type HelixHeadlessObjectInspectorHelixCopyElementEvent =
+  HelixHeadlessObjectInspectorElementEvent<HelixCopyEvent>;
+
+export type HelixHeadlessObjectInspectorVueProps = {
+  /** 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"?: (HelixHeadlessObjectInspector["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?: (HelixHeadlessObjectInspector["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?: (HelixHeadlessObjectInspector["for"]) | undefined;
+  /** Accessible name for the tree, and the text of the header where there is one. */
+  label?: (HelixHeadlessObjectInspector["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"?: (HelixHeadlessObjectInspector["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?: (HelixHeadlessObjectInspector["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?: (HelixHeadlessObjectInspector["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?: (HelixHeadlessObjectInspector["value"]) | undefined;
+};
+
+export type HelixHeadlessObjectInspectorVueEvents = {
+  /** A value was put on the clipboard, from the copy button or the keyboard. */
+  "helix-copy": HelixHeadlessObjectInspectorHelixCopyElementEvent;
+};
+
 export type HelixHeadlessOptionGroupVueProps = {
   /** The heading over the run. */
   label?: (HelixHeadlessOptionGroup["label"]) | undefined;
@@ -4743,7 +5264,8 @@ JavaScript rather than CSS decides. */
   behavior?: (HelixHeadlessOutline["behavior"]) | undefined;
   /** Accessible name for the navigation. */
   label?: (HelixHeadlessOutline["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
@@ -5268,6 +5790,9 @@ export type HelixHeadlessRadioGroupElementEvent<E = Event> = TypedEvent<
 /** `helix-before-change` event type */
 export type HelixHeadlessRadioGroupHelixBeforeChangeElementEvent =
   HelixHeadlessRadioGroupElementEvent<HelixBeforeChangeEvent>;
+/** `helix-select` event type */
+export type HelixHeadlessRadioGroupHelixSelectElementEvent =
+  HelixHeadlessRadioGroupElementEvent<HelixSelectEvent>;
 
 export type HelixHeadlessRadioGroupVueProps = {
   /** Which way the choices run. A column reads one line per answer.
@@ -5331,6 +5856,8 @@ export type HelixHeadlessRadioGroupVueEvents = {
   change: HelixHeadlessRadioGroupElementEvent;
   /** Fired when the answer changes, and cancelable. */
   "helix-before-change": HelixHeadlessRadioGroupHelixBeforeChangeElementEvent;
+  /** 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": HelixHeadlessRadioGroupHelixSelectElementEvent;
   /** Announced once the value has moved. */
   input: HelixHeadlessRadioGroupElementEvent;
 };
@@ -5505,6 +6032,40 @@ export type HelixHeadlessRatingVueEvents = {
   input: HelixHeadlessRatingElementEvent;
 };
 
+export type HelixHeadlessScatterChartVueProps = {
+  /** What to call the strength of the relation in the summary. */
+  "correlation-label"?: (HelixHeadlessScatterChart["correlationLabel"]) | undefined;
+  /** What to call the strength of the relation in the summary. */
+  correlationLabel?: (HelixHeadlessScatterChart["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?: (HelixHeadlessScatterChart["gridlines"]) | undefined;
+  /** What to call a row in the summary, which counts them. */
+  "points-label"?: (HelixHeadlessScatterChart["pointsLabel"]) | undefined;
+  /** What to call a row in the summary, which counts them. */
+  pointsLabel?: (HelixHeadlessScatterChart["pointsLabel"]) | undefined;
+  /** 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?: (HelixHeadlessScatterChart["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?: (HelixHeadlessScatterChart["label"]) | undefined;
+};
+
+export type HelixHeadlessScatterChartVueEvents = {};
+
 export type HelixHeadlessScrollAreaVueProps = {
   /** Names the region, for a reader arriving at it out of context.
 
@@ -5643,6 +6204,23 @@ export type HelixHeadlessSkeletonVueProps = {};
 
 export type HelixHeadlessSkeletonVueEvents = {};
 
+export type HelixHeadlessSkipLinkVueProps = {
+  /** 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?: (HelixHeadlessSkipLink["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?: (HelixHeadlessSkipLink["label"]) | undefined;
+};
+
+export type HelixHeadlessSkipLinkVueEvents = {};
+
 /** `HelixHeadlessSlider` component event */
 export type HelixHeadlessSliderElementEvent<E = Event> = TypedEvent<
   HelixHeadlessSlider,
@@ -5863,6 +6441,9 @@ export type HelixHeadlessSpeedDialHelixBeforeCloseElementEvent =
 /** `helix-before-open` event type */
 export type HelixHeadlessSpeedDialHelixBeforeOpenElementEvent =
   HelixHeadlessSpeedDialElementEvent<HelixBeforeOpenEvent>;
+/** `helix-select` event type */
+export type HelixHeadlessSpeedDialHelixSelectElementEvent =
+  HelixHeadlessSpeedDialElementEvent<HelixSelectEvent>;
 
 export type HelixHeadlessSpeedDialVueProps = {
   /** Names the trigger and the set of actions it opens. */
@@ -5898,6 +6479,8 @@ export type HelixHeadlessSpeedDialVueEvents = {
   "helix-before-close": HelixHeadlessSpeedDialHelixBeforeCloseElementEvent;
   /** Fired before it opens, and cancelable. */
   "helix-before-open": HelixHeadlessSpeedDialHelixBeforeOpenElementEvent;
+  /** 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": HelixHeadlessSpeedDialHelixSelectElementEvent;
   /** Says the state moved, carrying `newState` and `oldState`. */
   toggle: HelixHeadlessSpeedDialElementEvent;
 };
@@ -6062,6 +6645,9 @@ export type HelixHeadlessStepsHelixActivateElementEvent =
 /** `helix-before-activate` event type */
 export type HelixHeadlessStepsHelixBeforeActivateElementEvent =
   HelixHeadlessStepsElementEvent<HelixBeforeActivateEvent>;
+/** `helix-select` event type */
+export type HelixHeadlessStepsHelixSelectElementEvent =
+  HelixHeadlessStepsElementEvent<HelixSelectEvent>;
 
 export type HelixHeadlessStepsVueProps = {
   /** Accessible name for the sequence.
@@ -6116,6 +6702,8 @@ export type HelixHeadlessStepsVueEvents = {
   "helix-activate": HelixHeadlessStepsHelixActivateElementEvent;
   /** Fired before the active step changes. Cancelable: refusing it takes the decision and nothing moves. */
   "helix-before-activate": HelixHeadlessStepsHelixBeforeActivateElementEvent;
+  /** 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": HelixHeadlessStepsHelixSelectElementEvent;
 };
 
 /** `HelixHeadlessStep` component event */
@@ -6220,6 +6808,15 @@ export type HelixHeadlessTableCellVueProps = {
 
 export type HelixHeadlessTableCellVueEvents = {};
 
+/** `HelixHeadlessTableColumn` component event */
+export type HelixHeadlessTableColumnElementEvent<E = Event> = TypedEvent<
+  HelixHeadlessTableColumn,
+  E
+>;
+/** `helix-before-resize` event type */
+export type HelixHeadlessTableColumnHelixBeforeResizeElementEvent =
+  HelixHeadlessTableColumnElementEvent<HelixBeforeResizeEvent>;
+
 export type HelixHeadlessTableColumnVueProps = {
   /** Which edge the values line up against.
 
@@ -6241,6 +6838,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?: (HelixHeadlessTableColumn["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?: (HelixHeadlessTableColumn["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
@@ -6286,7 +6890,10 @@ correct default: the raw value is what an API sorted by. */
   compare?: (HelixHeadlessTableColumn["compare"]) | undefined;
 };
 
-export type HelixHeadlessTableColumnVueEvents = {};
+export type HelixHeadlessTableColumnVueEvents = {
+  /** Fired as a reader resizes the column, with the width asked for, and cancelable. */
+  "helix-before-resize": HelixHeadlessTableColumnHelixBeforeResizeElementEvent;
+};
 
 export type HelixHeadlessTableVueProps = {
   /** Column track list, as CSS. Deprecated: declare columns instead.
@@ -7071,6 +7678,15 @@ export type HelixHeadlessToastItemVueEvents = {
   "helix-dismiss": HelixHeadlessToastItemHelixDismissElementEvent;
 };
 
+/** `HelixHeadlessToast` component event */
+export type HelixHeadlessToastElementEvent<E = Event> = TypedEvent<
+  HelixHeadlessToast,
+  E
+>;
+/** `helix-dismiss` event type */
+export type HelixHeadlessToastHelixDismissElementEvent =
+  HelixHeadlessToastElementEvent<HelixDismissEvent>;
+
 export type HelixHeadlessToastVueProps = {
   /** Accessible name for the region, such as "Notifications". */
   label?: (HelixHeadlessToast["label"]) | undefined;
@@ -7089,7 +7705,10 @@ departures, which is what `orientation` does. */
   placement?: (HelixHeadlessToast["placement"]) | undefined;
 };
 
-export type HelixHeadlessToastVueEvents = {};
+export type HelixHeadlessToastVueEvents = {
+  /** 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": HelixHeadlessToastHelixDismissElementEvent;
+};
 
 /** `HelixHeadlessToggleGroup` component event */
 export type HelixHeadlessToggleGroupElementEvent<E = Event> = TypedEvent<
@@ -7377,6 +7996,9 @@ export type HelixHeadlessTourHelixBeforeCloseElementEvent =
 /** `helix-complete` event type */
 export type HelixHeadlessTourHelixCompleteElementEvent =
   HelixHeadlessTourElementEvent<HelixCompleteEvent>;
+/** `helix-tour-ask` event type */
+export type HelixHeadlessTourHelixTourAskElementEvent =
+  HelixHeadlessTourElementEvent<HelixTourAskEvent>;
 
 export type HelixHeadlessTourVueProps = {
   /** Label for the control that goes back, handed to every stop. */
@@ -7427,6 +8049,8 @@ export type HelixHeadlessTourVueEvents = {
   "helix-before-close": HelixHeadlessTourHelixBeforeCloseElementEvent;
   /** Fired when the last stop is finished. */
   "helix-complete": HelixHeadlessTourHelixCompleteElementEvent;
+  /** 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": HelixHeadlessTourHelixTourAskElementEvent;
   /** Says the state moved, carrying `newState` and `oldState`. */
   toggle: HelixHeadlessTourElementEvent;
 };
@@ -8102,6 +8726,8 @@ export type CustomCssProperties = {
   "--meter-fraction"?: (string) | undefined;
   /** How much of the circle the arc covers, as a path length. */
   "--meter-sweep"?: (string) | undefined;
+  /** How deep a row is, from 0 at the root, for indenting it. */
+  "--object-inspector-level"?: (string) | undefined;
   /** The value as a fraction of the range, 0 to 1. Pinned to 1 while indeterminate. */
   "--progress-fraction"?: (string) | undefined;
   /** How many marks are wholly filled. */
@@ -8112,6 +8738,12 @@ export type CustomCssProperties = {
   "--rating-step"?: (string) | undefined;
   /** How many steps one mark is divided into. */
   "--rating-steps"?: (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;
   /** The value as a fraction of the range, 0 to 1. */
   "--slider-fraction"?: (string) | undefined;
   /** Where the filled span starts, as a percentage of the track. */
@@ -8172,6 +8804,12 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessAppHeaderVueProps,
     HelixHeadlessAppHeaderVueEvents
   >;
+  /** The chart for a composition: every column of the table is a part, the parts sum to the whole at each reading, and the top edge is that whole. What a line chart of the same table cannot show is the share, which here is the thickness of a band.  **Not 'Line Chart' with 'area'.** That washes each series from the floor on its own, so the series overlap; this adds them. Reach for 'Line Chart' when the question is how each series moved, and for this when it is how the whole is made up.  **It measures from zero, always**, which is 'BarChart''s rule and for the same reason: a band's thickness *is* its value, so a range that starts anywhere else draws every part in proportion to nothing. 'LineChart' measures from its own range because a line claims a position; a band claims an amount.  **Straight between readings unless asked otherwise.** A band's top edge is a sum, and a curve fitted through one sum can pass under the curve fitted through the sum beneath it, so a smoothed stack can draw a part as less than nothing between two readings. Straight segments between ordered points stay ordered. 'curve="smooth"' is there for a stack that is read as a shape.  **'share' draws each reading as a hundred percent**, so the bands are the parts' shares and the top edge is flat. It answers "which part grew" where the default answers "did the whole grow".  **What a reader without the picture is told is the total and the share**, not every band in turn. The table beside the chart already reads out every number; what the drawing adds is the composition, so the summary says the latest reading's total and each part's share of it. The drawing itself is 'aria-hidden'.  Every numeric column is a part. A table that carries its own total column would count it twice, so leave it out of the table the chart reads. A negative reading is drawn as none: a part of a whole cannot be less than nothing, and a band that folded under its neighbor would say it was. */
+  "helix-headless-area-chart": DefineCustomElement<
+    HelixHeadlessAreaChart,
+    HelixHeadlessAreaChartVueProps,
+    HelixHeadlessAreaChartVueEvents
+  >;
   /** A part of 'Avatar' rather than a family of its own: it arranges avatars and is about nothing else.  **The overflow count is the group's, not a slot.** Which avatars are hidden is a fact the group works out from 'max', so a consumer writing the "+3" would be writing a number that has to agree with a list they do not control.  **Hidden, not removed.** Past 'max' the extra avatars stay in the DOM and stop being shown, so nothing re-renders when 'max' changes and the accessible name is still built from all of them. */
   "helix-headless-avatar-group": DefineCustomElement<
     HelixHeadlessAvatarGroup,
@@ -8256,7 +8894,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessChatMessageVueProps,
     HelixHeadlessChatMessageVueEvents
   >;
-  /** **It has no opinion about where it sits.** A chat is asked for as a floating button, a page, a palette, a sidebar, a modal and an inline block, and none of those is a variant of a conversation: they are containers, and the containers already exist. Nothing here is positioned, nothing has a backdrop, and nothing owns a trigger. If a form factor needs a mode on this element, the split is wrong.  **Scroll ownership is the behavior everything else depends on.** A transcript that grows wants to stay at the bottom, except when the reader has scrolled up to read, where pinning is hostile. The rule: pin while the reader is within 'threshold' of the bottom, and let go the moment they leave it. */
+  /** **It has no opinion about where it sits.** A chat is asked for as a floating button, a page, a palette, a sidebar, a modal and an inline block, and none of those is a variant of a conversation: they are containers, and the containers already exist. Nothing here is positioned, nothing has a backdrop, and nothing owns a trigger. If a form factor needs a mode on this element, the split is wrong.  **Scroll ownership is the behavior everything else depends on.** A transcript that grows wants to stay at the bottom, except when the reader has scrolled up to read, where pinning is hostile. The rule: pin while the reader is within 'threshold' of the bottom, and let go the moment they leave it. A turn growing under a pinned reader is not the reader leaving, so a streamed answer is followed to its last line.  **History loads upward, under a reader who does not move.** With 'history' set to 'more', reaching the top fires 'helix-history'; the consumer sets 'loading' while it fetches and prepends the older turns, and the turn the reader was looking at stays where it was on screen while the room above it grows.  **A turn is announced once, when it settles**, and not by the log. A log that is a live region reads what enters it, which is every token of a stream where 'aria-busy' is not honored, every page of history as it loads, and every window of a long transcript as the reader scrolls through it. So the log is 'aria-live="off"', and a status region of its own says each new turn when it has finished arriving: never the reader's own words unless they failed to send, never a turn loaded above the ones already there, and never what was in the transcript when it opened.  **Turns are markup children or data, not both.** Children serve whole from a server and are what most conversations want. 'turns' is for the transcript too long to hold as elements: it is drawn a window at a time, measured as it goes, and the log needs a block size of its own for that to mean anything. */
   "helix-headless-chat": DefineCustomElement<
     HelixHeadlessChat,
     HelixHeadlessChatVueProps,
@@ -8274,7 +8912,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessCheckboxVueProps,
     HelixHeadlessCheckboxVueEvents
   >;
-  /** **'<pre><code>' and nothing cleverer.** The pair is what the platform means by a block of code: 'pre' keeps the whitespace, 'code' says what the whitespace is for, and losing either one loses something no styling puts back. Indentation in a 'div' is a paragraph with odd spacing.  **It scrolls rather than wraps.** A wrapped line of code is a lie about where the line ends, and in a language where a line break can be significant it is a lie that costs someone an afternoon. The box takes its own scrollbar.  **The copy button is here because the alternative is selecting it by hand.** Every consumer would otherwise put one there, slightly differently, and the one that forgot would be the one with the longest snippet. It is on unless 'no-copy' says otherwise, and takes its text from the slot rather than from a property, so there is no second copy of the code to keep in step.  A 'Code' for a fragment inside a sentence. Separate families, because one flows with prose and the other is a figure. */
+  /** **'<pre><code>' and nothing cleverer.** The pair is what the platform means by a block of code: 'pre' keeps the whitespace, 'code' says what the whitespace is for, and losing either one loses something no styling puts back. Indentation in a 'div' is a paragraph with odd spacing.  **It scrolls rather than wraps.** A wrapped line of code is a lie about where the line ends, and in a language where a line break can be significant it is a lie that costs someone an afternoon. The box takes its own scrollbar.  **The copy button is here because the alternative is selecting it by hand.** Every consumer would otherwise put one there, slightly differently, and the one that forgot would be the one with the longest snippet. It is on unless 'no-copy' says otherwise, and takes its text from the slot rather than from a property, so there is no second copy of the code to keep in step.  A 'Code' for a fragment inside a sentence. Separate families, because one flows with prose and the other is a figure.  **'diff' reads the code as a change.** The content is then a unified diff, what 'git diff' and 'diff -u' write, in the same slot ordinary code goes in, and it is drawn as the lines it added and removed. The block reads a diff and never computes one, so the algorithm stays wherever the two versions are. Numbers come from the hunk headers, which makes them the file's; changed lines are '<ins>' and '<del>' with the '+' and '-' kept as text, so the change is not carried by color; the numbers are hidden from the accessibility tree. Each file in the patch is a block of its own under its own name, and its copy button takes the file as it now reads. 'variant="split"' sets the old version beside the new, each removal opposite its replacement.  **Before the script runs, a diff is its own text.** A server has no children to read, so it renders the slot as ordinary code, which for a diff is the patch in a '<pre>': a legible diff, and the first render the client makes too, which is what keeps hydration clean. The drawn diff replaces it once the content can be read. Diff mode is experimental while the rest of the family is stable. */
   "helix-headless-code-block": DefineCustomElement<
     HelixHeadlessCodeBlock,
     HelixHeadlessCodeBlockVueProps,
@@ -8316,7 +8954,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessCopyButtonVueProps,
     HelixHeadlessCopyButtonVueEvents
   >;
-  /** **The schema is markup and the data is a property.** Columns are declared as 'helix-table-column' children, because a schema is small and something a reader should see in the HTML; rows are handed over as an array, because a table that draws ten thousand elements cannot window them.  '''html <helix-data-table .rows=${rows} sort="name:asc" page-size="20">   <helix-table-column field="name" sortable>Name</helix-table-column>   <helix-table-column field="size" align="end" sortable .cell=${bytes}>Size</helix-table-column> </helix-data-table> '''  'helix-table' takes rows as markup and is the right component for a table of twelve things a person wrote out.  **Sort and filter apply to the whole set, never the page.** Sorting the drawn window is correct on the first screen and wrong on every other one.  **The cell values do not server-render.** The headings do, and the row elements do, but reading a cell needs the columns, and the columns are markup children Lit SSR does not hand this element. So a crawler sees a table of the right shape with nothing in it. That is the cost of the first paragraph: use 'helix-table' where the served HTML has to carry the values. */
+  /** **The schema is markup and the data is a property.** Columns are declared as 'helix-table-column' children, because a schema is small and something a reader should see in the HTML; rows are handed over as an array, because a table that draws ten thousand elements cannot window them.  '''html <helix-data-table .rows=${rows} sort="name:asc" page-size="20">   <helix-table-column field="name" sortable>Name</helix-table-column>   <helix-table-column field="size" align="end" sortable .cell=${bytes}>Size</helix-table-column> </helix-data-table> '''  'helix-table' takes rows as markup and is the right component for a table of twelve things a person wrote out.  **Sort and filter apply to the whole set, never the page.** Sorting the drawn window is correct on the first screen and wrong on every other one.  **The cell values do not server-render.** The headings do, and the row elements do, but reading a cell needs the columns, and the columns are markup children Lit SSR does not hand this element. So a crawler sees a table of the right shape with nothing in it. That is the cost of the first paragraph: use 'helix-table' where the served HTML has to carry the values.  **'selectable' adds a column of checkboxes, keyed on 'row-key'.** A row is selected by its identity rather than its position, so a selection survives a sort, a filter and a page. 'selected' is the chosen keys, comma separated, the shape Listbox uses for a multiple choice, and like 'sort' it is controlled when set and seeded by 'default-selected'. The box in the heading selects every row in the result, across pages, and shows a dash while only some are chosen. Choosing one of many, rather than several, is opening a row, and that is a link or a button in a cell rather than a selection.  **A reader can size and order the columns.** 'resizable' on a column puts a separator on its edge; 'reorderable' on the table puts a grip on each heading that has a 'field', moved by dragging or with the arrow keys. The order lands in 'order' as fields, and the consumer's own markup is never rewritten: the table assigns the headings to its header in that order instead.  **'csv()' hands back the result as text**: every row the filter lets through, in the order on screen, in the columns on screen. Saving it is the page's business, the same as any other file. */
   "helix-headless-data-table": DefineCustomElement<
     HelixHeadlessDataTable,
     HelixHeadlessDataTableVueProps,
@@ -8334,6 +8972,18 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessDatePickerVueProps,
     HelixHeadlessDatePickerVueEvents
   >;
+  /** An element rather than a pair of slots on the list, because a pair is the unit a reader hears: the label is the '<dt>' and the value its '<dd>', and the two stay together however the list lays them out.  The value is the default slot, since it is what varies and is often more than text: a tag, an avatar, a link. The label is text almost every time, so it is also a property. */
+  "helix-headless-description-list-item": DefineCustomElement<
+    HelixHeadlessDescriptionListItem,
+    HelixHeadlessDescriptionListItemVueProps,
+    HelixHeadlessDescriptionListItemVueEvents
+  >;
+  /** "Owner: Ada, Region: us-east, Created: 3 days ago" is the commonest panel in any console, and built from layout primitives it is a run of adjacent text: nothing tells a screen reader that a label and a value belong together, or how many pairs there are. This renders the element the platform has for it, a '<dl>', with each item's label a '<dt>' and its value a '<dd>'.  **The items render their own term and description**, and the list takes them through its slot. The accessibility tree is built from the flattened tree, so the pairs reach it inside the list rather than beside it. Measured in Chromium's tree rather than assumed, because a list whose semantics stopped at a shadow boundary would look identical on screen: one description list holding term and definition pairs, node for node what a plain '<dl>' with the same content produces, with a slotted label and with an item drawn as 'display: contents' alike. */
+  "helix-headless-description-list": DefineCustomElement<
+    HelixHeadlessDescriptionList,
+    HelixHeadlessDescriptionListVueProps,
+    HelixHeadlessDescriptionListVueEvents
+  >;
   /** A real '<dialog>' opened with 'showModal()', not a div with a role and a hand-built trap. The platform gives four things that are each a day's work to reimplement: the top layer, so the dialog is above everything whatever 'z-index' anyone wrote; a real backdrop; Escape; and inert-behind, so the page underneath is unreachable by pointer, keyboard or virtual cursor.  **'open' drives 'showModal()', and every way it can close comes back through 'requestOpen'.** A native dialog closes from three directions: the property, Escape, and a '<form method="dialog">' submit. Left alone, two of them would shut the dialog while the consumer's state still said open, which is the bug that makes a modal impossible to reopen. */
   "helix-headless-dialog": DefineCustomElement<
     HelixHeadlessDialog,
@@ -8382,7 +9032,31 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessFileInputVueProps,
     HelixHeadlessFileInputVueEvents
   >;
-  /** **The tokens are the consumer's own elements, slotted.** What a filter narrows by belongs to the consumer's model rather than to this element: a facet with a prefix, a saved query, a range. So they are slotted rather than rendered from a list of strings, and removing one is a request this element makes rather than a change it applies. Combobox is the other way round, and that is the difference between the two: its tokens are a view of a selection it owns, drawn from options it was handed.  **'value' is the text being typed, not the tokens**, which is what makes this a field a consumer can listen to. Every keystroke announces 'input' with the text on the element, so a table narrows as the reader types. The tokens need no reporting back, being markup the consumer already holds.  Backspace on an empty field asks the last token to go, through the same 'helix-dismiss' its own remove control fires, so a consumer who handled the pointer has already handled the keyboard.  **It can suggest what to type next, and it never learns the grammar.** Slot 'helix-option' elements into 'suggestions' and the field shows them, moves through them with the arrows, and lets Enter press one; the option fires its own 'helix-select' and the consumer decides what choosing meant. Deciding *what* to suggest is theirs too: keys before a colon and values after it are the same panel with different contents, which is all a two-level filter is, and the parse that tells them apart belongs where the domain does.  **The panel opens when there is something in it and closes when there is not**, rather than on a choice. A reader who picks a key wants its values next, and closing on the choice would shut the panel between two renders. Use 'selectionStart' and 'setSelectionRange' to write a completion back and put the caret after it, or the next parse reads the wrong term.  **Three things here have three different owners, and only one of them is a controlled property.**  'value' is the text, and it is uncontrolled by default: the reader types, the element applies it, and 'input' says so. **Writing 'value' does not take that over.** It is a seed and a correction, so a consumer who sets it and then expects the field to hold still will watch the next keystroke overwrite them. Ownership is taken by refusing 'helix-before-change' and writing the value you want, which is the same shape every field in this library uses and is worth saying out loud here because the property looks like React's. 'default-value' seeds the field without claiming anything.  'open' is the suggestions panel, and it is the ordinary controlled pair: refuse 'helix-before-open' or 'helix-before-close' to take the decision, and 'default-open' to seed it.  The tokens are neither, because they are not state. They are the consumer's own elements in a slot, so there is nothing for this to own and nothing to report back: a token goes when the consumer removes it from their markup, having been asked by 'helix-dismiss'. */
+  /** A chip is the readable form of the thing 'FilterField' declares. It carries the three parts a filter has and a control that asks for it to go.  **The operator is drawn only when it is worth drawing**, which is the whole reason the common case reads as plainly as it does:  ''' Disposition   refunded, chargeback         the field's usual comparison, unwritten Disposition   is not   refunded            a comparison somebody chose, so it shows Created       after    1 Aug               a scalar, which has no usual comparison '''  A reader ticking two values in a menu gets the first, with no jargon on it. A reader who reaches for a comparison gets the third, which explains itself the first time they see one. The rule is one line: **omit 'operator-label' for the field's default operator and pass it for every other.** Whoever builds the chip holds the field, and the field knows which its default is.  **It shows a filter and never applies one.** Dismissing is a request, the way it is on 'Tag' and 'Announcement': the chip is the consumer's element in a consumer's list, and taking it out from under them would put their model and the document out of step. 'preventDefault()' on the 'helix-dismiss' is a refusal, and that is also how a consumer takes control of the interaction for one press: 'requestChange' documents the whole pattern, and its first line is that control is an action rather than a mode.  **Changing the comparison belongs to whatever is slotted into 'operator'.** A menu trigger there makes the segment a control; the text fallback makes it a label. This element does not learn either, for the reason 'FilterOperator' gives: what the words mean is the domain's. */
+  "helix-headless-filter-chip": DefineCustomElement<
+    HelixHeadlessFilterChip,
+    HelixHeadlessFilterChipVueProps,
+    HelixHeadlessFilterChipVueEvents
+  >;
+  /** **A declaration, not a control.** It renders nothing and is never seen. A consumer writes one per field, with the comparisons that field supports and the values it supports them on, and the filter input reads them to build its menu:  '''html <helix-headless-filter-field name="disposition" label="Disposition">   <helix-headless-filter-operator name="any" label="is any of" default>   </helix-headless-filter-operator>   <helix-headless-filter-operator name="none" label="is none of">   </helix-headless-filter-operator>   <helix-headless-option value="refunded">Refunded</helix-headless-option> </helix-headless-filter-field> '''  **Operators are per field and never global.** 'is after' belongs to a date and 'has all of' to a set, and a field that supports one comparison shows no chooser at all. A global list would offer every field every word and leave the component deciding which of them made sense, which is the domain question it declines to answer.  **A field that declares none gets two, and they are the ones the punctuation can say.** 'is any of' and 'is none of' are what 'field:a,b' and '-field:a,b' mean, so declaring them was ceremony for the case every product has; the example above is what a consumer writes when the words matter, not the price of admission. Declaring one comparison replaces both rather than joining them — see 'vocabulary', which is where that is decided once for the menu and the grammar together.  **Values are 'Option's, which is the element a consumer already has.** They carry a value, a label and a disabled state, and a picker built on 'Menu' or 'Listbox' can render them without this element inventing a second way to say the same thing. A field whose values cannot be enumerated declares none, and what fills a chip then is whatever the consumer types. */
+  "helix-headless-filter-field": DefineCustomElement<
+    HelixHeadlessFilterField,
+    HelixHeadlessFilterFieldVueProps,
+    HelixHeadlessFilterFieldVueEvents
+  >;
+  /** **It reads the declarations and renders a menu.** A consumer writes their fields as 'FilterField's inside this, and what comes out is a two level menu: the fields, and under each one its comparisons and its values. Nothing here knows what a field means, which is the line 'FilterField' already draws.  '''html <helix-headless-filter-menu label="Filter">   <helix-headless-filter-field name="disposition" label="Disposition">     <helix-headless-option value="refunded">Refunded</helix-headless-option>   </helix-headless-filter-field> </helix-headless-filter-menu> '''  That field declares no comparisons and so is offered 'is any of' and 'is none of', which are the two the typed grammar can say. The menu and the text end up offering the same filters because both read 'FilterField.vocabulary', and a consumer whose field needs other words declares them there.  **A tick is a filter, immediately.** There is no Apply: ticking a value announces the field's whole set as it now stands, so a queue narrows as the reader works rather than after they have finished. Unticking the last value announces an empty set, which is a consumer's cue to drop the chip.  **The operator is chosen here and written nowhere else.** 'helix-facet' carries 'operatorLabel' empty when the comparison is the field's default, which is exactly what a chip's 'operator-label' wants: the segment appears only where somebody picked something worth noticing. Deciding it here is the point, since this is the only thing that has read both the field and its operators.  **How many values a comparison takes decides what is under it.** A field whose comparison is 'arity="none"', 'is empty' or 'is set', is offered no values at all and gives back any that were ticked: the comparison is the whole filter. One at 'arity="one"' offers its values as a single choice, so pressing another replaces it and pressing the one already on clears it. Both announce 'arity' in the facet, which is what lets a consumer tell an empty filter from no filter at all.  **It applies nothing.** The chips are the consumer's markup and the rows are their data, so this announces and stops, the way 'Notification' reports a read rather than inventing one. Refusing 'helix-facet' refuses the change. */
+  "helix-headless-filter-menu": DefineCustomElement<
+    HelixHeadlessFilterMenu,
+    HelixHeadlessFilterMenuVueProps,
+    HelixHeadlessFilterMenuVueEvents
+  >;
+  /** **A declaration, not a control.** It renders nothing and is never seen: it is how a consumer says which comparisons their field supports, in markup, beside the values it supports them on. 'Field' reads them; the chip shows the one in force; the menu offers the rest.  **The vocabulary is the consumer's and this element never learns it.** What 'is none of' means against a queue of refunds is a question about refunds, so nothing here compares anything or knows what 'name' will be handed to. Helix owns the shape a filter has, which is a field, an operator and some values, and owns the interaction that builds one. What the words mean is the domain's, which is the same line 'FilterInput' already draws when it declines to learn a grammar.  **'default' is what makes a chip readable.** The operator a field is usually filtered by is the one nobody needs told, so a chip drawn with it says only the field and the values. Naming a second operator 'default' on one field is a consumer bug and the field reports it rather than guessing. */
+  "helix-headless-filter-operator": DefineCustomElement<
+    HelixHeadlessFilterOperator,
+    HelixHeadlessFilterOperatorVueProps,
+    HelixHeadlessFilterOperatorVueEvents
+  >;
+  /** **The tokens are the consumer's own elements, slotted.** What a filter narrows by belongs to the consumer's model rather than to this element: a facet with a prefix, a saved query, a range. So they are slotted rather than rendered from a list of strings, and removing one is a request this element makes rather than a change it applies. Combobox is the other way round, and that is the difference between the two: its tokens are a view of a selection it owns, drawn from options it was handed.  **'value' is the text being typed, not the tokens**, which is what makes this a field a consumer can listen to. Every keystroke announces 'input' with the text on the element, so a table narrows as the reader types. The tokens need no reporting back, being markup the consumer already holds.  Backspace on an empty field asks the last token to go, through the same 'helix-dismiss' its own remove control fires, so a consumer who handled the pointer has already handled the keyboard.  **It reads what was declared, and nothing that was not.** Write 'FilterField's — usually inside the 'FilterMenu' slotted into 'start', so the picker and the text work off one set — and Enter reads the box against them: 'disposition:refunded,settled' and '-disposition:refunded' announce 'helix-facet', exactly as ticking those values in the picker would, and the text they were read from goes. Everything else stays where it was typed, so 'refund tuesday disposition:settled' is a filter and a search at once. 'grammar.ts' carries the whole rule and is worth reading before relying on it; the short version is that Helix owns the punctuation and the consumer owns every word in it. A field with no 'FilterField' in it parses nothing, which is the behavior this had before it could.  **A field whose values cannot be listed belongs here rather than in the picker.** 'assignee:ada' is a filter and nobody wants to enumerate every name in the company, but a menu page for it would have nothing on it to press. Written directly inside this element it is read by the grammar and never offered as a page: unslotted, so nothing draws it, which is the same trick 'FilterField' already plays on its own children.  **It can suggest what to type next, and deciding what to suggest is still the consumer's.** Slot 'helix-option' elements into 'suggestions' and the field shows them, moves through them with the arrows, and lets Enter press one; the option fires its own 'helix-select' and the consumer decides what choosing meant. Keys before a colon and values after it are the same panel with different contents, and 'readFilterText' is exported for a consumer narrowing that panel against what a reader has half typed.  **The panel opens when there is something in it and closes when there is not**, rather than on a choice. A reader who picks a key wants its values next, and closing on the choice would shut the panel between two renders. Use 'selectionStart' and 'setSelectionRange' to write a completion back and put the caret after it, or the next parse reads the wrong term.  **Three things here have three different owners, and only one of them is a controlled property.**  'value' is the text, and it is uncontrolled by default: the reader types, the element applies it, and 'input' says so. **Writing 'value' does not take that over.** It is a seed and a correction, so a consumer who sets it and then expects the field to hold still will watch the next keystroke overwrite them. Ownership is taken by refusing 'helix-before-change' and writing the value you want, which is the same shape every field in this library uses and is worth saying out loud here because the property looks like React's. 'default-value' seeds the field without claiming anything.  'open' is the suggestions panel, and it is the ordinary controlled pair: refuse 'helix-before-open' or 'helix-before-close' to take the decision, and 'default-open' to seed it.  The tokens are neither, because they are not state. They are the consumer's own elements in a slot, so there is nothing for this to own and nothing to report back: a token goes when the consumer removes it from their markup, having been asked by 'helix-dismiss'. **A 'FilterChip' naming a declared field is asked differently**, and it has to be: the picker holds what is ticked, so a chip that removed itself without telling it left the value ticked in a list nobody could see was wrong. That dismissal is answered as the field being filtered by nothing, so it arrives as 'helix-facet' like every other change and the chip goes because the filter went. */
   "helix-headless-filter-input": DefineCustomElement<
     HelixHeadlessFilterInput,
     HelixHeadlessFilterInputVueProps,
@@ -8436,7 +9110,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessLegendVueProps,
     HelixHeadlessLegendVueEvents
   >;
-  /** The chart for a shape rather than for a quantity, which is what decides the one thing a bar chart is not allowed to do.  **It measures from its own range and not from zero, deliberately.** 'BarChart' refuses that switch because a bar's length *is* its value, so a baseline anywhere else makes the lengths proportional to nothing. A line claims no such thing: it says where the readings went, and forcing zero into the range of a series that moves between 980 and 1020 flattens the entire shape into a rule across the top of the box. The two rules are opposite because the two charts answer opposite questions, and 'zero' is here for the case where the distance from nothing is the point.  **One scale across every series**, the same as the bar chart, because two series drawn to different scales are two charts sharing a picture.  **The labels are HTML beside the drawing rather than '<text>' inside it**, for the reason 'BarChart' records: an '<svg>' that fills its box scales its type with everything else, the same 'font-size' arriving at 10px in a narrow chart and 43px in a wide one, and there is no non-scaling-font to answer it the way 'vector-effect' answers strokes.  The table is the accessible representation and this drawing is 'aria-hidden'. A reader who wants the numbers gets the numbers, not a described picture. */
+  /** The chart for a shape rather than for a quantity, which is what decides the one thing a bar chart is not allowed to do.  **It measures from its own range and not from zero, deliberately.** 'BarChart' refuses that switch because a bar's length *is* its value, so a baseline anywhere else makes the lengths proportional to nothing. A line claims no such thing: it says where the readings went, and forcing zero into the range of a series that moves between 980 and 1020 flattens the entire shape into a rule across the top of the box. The two rules are opposite because the two charts answer opposite questions, and 'zero' is here for the case where the distance from nothing is the point.  **One scale across every series**, the same as the bar chart, because two series drawn to different scales are two charts sharing a picture.  **Not the chart for a total made of parts.** 'area' washes each series from the floor on its own, so they overlap; 'Area Chart' stacks them, so the top edge is the total and each band is a share. A line chart answers how each series moved, an area chart how the whole is made up.  **The labels are HTML beside the drawing rather than '<text>' inside it**, for the reason 'BarChart' records: an '<svg>' that fills its box scales its type with everything else, the same 'font-size' arriving at 10px in a narrow chart and 43px in a wide one, and there is no non-scaling-font to answer it the way 'vector-effect' answers strokes.  The table is the accessible representation and this drawing is 'aria-hidden'. A reader who wants the numbers gets the numbers, not a described picture. */
   "helix-headless-line-chart": DefineCustomElement<
     HelixHeadlessLineChart,
     HelixHeadlessLineChartVueProps,
@@ -8472,7 +9146,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessMegamenuVueProps,
     HelixHeadlessMegamenuVueEvents
   >;
-  /** Three shapes, one element, because a reader moving down a menu with the arrow keys does not care which kind each row is and neither should the markup. What it is follows from what it was given: something slotted into 'submenu' makes it a way in, 'checked' makes it a choice, and neither makes it a command.  **The role follows the shape.** A row that can be ticked is 'menuitemcheckbox' and carries 'aria-checked', because a reader is told "one of these is on" rather than "here is a button". A row that opens a page keeps 'menuitem' and says 'aria-haspopup', since the page it opens is a menu.  Whether it is on the page showing is set by the menu as a property, never as an attribute: an attribute written onto a consumer's element after it upgrades is a hydration mismatch waiting to happen. */
+  /** Three shapes, one element, because a reader moving down a menu with the arrow keys does not care which kind each row is and neither should the markup. What it is follows from what it was given: something slotted into 'submenu' makes it a way in, 'checked' makes it a choice, and neither makes it a command.  **The role follows the shape.** A row that can be ticked is 'menuitemcheckbox' and carries 'aria-checked', because a reader is told "one of these is on" rather than "here is a button"; 'exclusive' makes it 'menuitemradio', for a set where only one can be. A row that opens a page keeps 'menuitem' and says 'aria-haspopup', since the page it opens is a menu.  Whether it is on the page showing is set by the menu as a property, never as an attribute: an attribute written onto a consumer's element after it upgrades is a hydration mismatch waiting to happen. */
   "helix-headless-menu-item": DefineCustomElement<
     HelixHeadlessMenuItem,
     HelixHeadlessMenuItemVueProps,
@@ -8496,6 +9170,12 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessNavigationVueProps,
     HelixHeadlessNavigationVueEvents
   >;
+  /** **What groups with what is the consumer's, and this never guesses.** A feed can be cut by day, by the thing being talked about, by the person doing the talking, or by nothing at all, and which of those is right is a question about the product. So a group is written by hand around the rows that belong together and told what to call itself, exactly as 'FilterField' is told what its operators are.  **Collapsed shows the first row and assigns the rest nowhere.** Not 'hidden', not 'inert', not a stylesheet: the slot is assigned imperatively, so a collapsed group's later rows are absent from the layout and from the accessibility tree with no CSS at all, which is what the headless tier claims for itself. 'Notifications' already assigns its list this way and this borrows the mechanism.  The count is separate from how many rows are written, because it usually is: a group saying five with one row under it and a link to the rest is the common shape, and computing the number from the children would make that unsayable. Left off, it is the number of rows. */
+  "helix-headless-notification-group": DefineCustomElement<
+    HelixHeadlessNotificationGroup,
+    HelixHeadlessNotificationGroupVueProps,
+    HelixHeadlessNotificationGroupVueEvents
+  >;
   /** A notification is a toast that did not go away. 'helix-toast' is deliberately the opposite of this: a live region whose items carry a 'duration' and whose root never creates or destroys anything. What makes this its own family is the state each item carries rather than the arrangement it sits in: read and unread, a timestamp that has to stay correct, and an action a reader can take later.  **The row is a label, a caption under it, and one trailing column that holds either the time or the controls.** A feed is scanned rather than read, so the thing that happened gets the first line on its own and everything qualifying it goes under. The time and the controls occupy the same place because a reader wants exactly one of them at a time: the time while they are scanning, and what they can do about it once they have stopped on a row.  **The timestamp is 'helix-format-date'**, which is where the reading, the '<time datetime>' and the shared timer now live. It was implemented here, and a component that formats a date is not a fact about notifications: Chat wanted the same thing and had its own copy of half of it.  **Read state is reported, not invented.** Marking something read is usually a round trip, and a component that flips its own state and then hears the request failed has told the reader something untrue. 'helix-read' is cancelable, and a 'read' set by the consumer makes this element defer entirely. */
   "helix-headless-notification": DefineCustomElement<
     HelixHeadlessNotification,
@@ -8514,6 +9194,12 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessNumberInputVueProps,
     HelixHeadlessNumberInputVueEvents
   >;
+  /** What a developer-facing product shows constantly is a structured value: an API response, a config, a row's raw record. As text in a code block, a reader scrolls a wall of JSON and cannot put away the branch they do not care about; as a Tree, every node is a label and a string reads the same as a number. This reads the value and draws each entry with its type visible.  **It reads and never edits.** An inspector that edits is a different component, with validation, undo and a model of what changed, and the reading one is what is wanted.  **The data is text in the page or a property.** 'for' names a '<script type="application/json">' by id, the channel 'VirtualList' and the charts already read: it survives a server, which has attributes and no children, and React's hydration, which skips object properties. 'value' is there for a page that already holds the object, and wins when both are set.  **One tab stop, and the rows are reached with the arrow keys**, the tree pattern: Up and Down move, Right opens a branch or enters it, Left closes it or goes to its parent, Home and End go to the ends. The tree keeps focus and points at the active row with 'aria-activedescendant', which is what lets a windowed tree drop rows from the page without dropping focus with them. Each row carries its real level, position and set size, so a reader on a windowed row hears where it is in the value rather than in the slice drawn.  **Copying takes the active row**, as JSON for a branch and as itself for a string, from the copy button or from Command or Control with C while the tree has focus and nothing is selected. The button sits beside the tree rather than in each row, where a button would be an interactive control inside a tree item, which assistive technology cannot reach reliably.  **'windowed' draws only the rows in view**, for a value of thousands of entries, through the same controller 'VirtualList' and 'DataTable' use. The box has to have a height for that to mean anything, which the styled tier gives it and a headless consumer has to. */
+  "helix-headless-object-inspector": DefineCustomElement<
+    HelixHeadlessObjectInspector,
+    HelixHeadlessObjectInspectorVueProps,
+    HelixHeadlessObjectInspectorVueEvents
+  >;
   /** A heading over a set, and nothing else: it holds no selection and no value, because grouping is presentation over a list whose owner is the listbox. Its options are still the listbox's options, which is what keeps the keyboard moving through a grouped list exactly as it moves through a flat one.  'role="group"' named by the heading, so a screen reader announces which run an option is in without the heading becoming something to land on. */
   "helix-headless-option-group": DefineCustomElement<
     HelixHeadlessOptionGroup,
@@ -8598,6 +9284,12 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessRatingVueProps,
     HelixHeadlessRatingVueEvents
   >;
+  /** The chart for a relation rather than a series. The table's first numeric column is measured across and every other numeric column is measured up, one point per row, so a table of countries with a column of income and a column of life expectancy draws one dot for each country. More numeric columns are more series against the same across, each in its own color.  **Both axes are measured, so both are labeled.** A line chart's readings are named along the bottom and its values are read from the tooltip; here the horizontal position is itself a value, and a point with no scale under it says nothing about how far along it is. The ticks sit at round numbers and the range is widened to them, so the plot's edges are numbers a reader can name.  **What a reader without the picture is told is how strongly the two relate**, because that is the question a scatter is drawn to answer and the one a table of the same numbers makes hardest to see. The summary gives each series' correlation coefficient and how many points it rests on; the table has every number, and the drawing is 'aria-hidden'.  **The points are elements, not shapes in the drawing.** The drawing stretches to its box, and a circle in a stretched space is an ellipse, so each point is a '<span>' placed by percentage over it, which is how 'LineChart' draws its termini and for the same reason. */
+  "helix-headless-scatter-chart": DefineCustomElement<
+    HelixHeadlessScatterChart,
+    HelixHeadlessScatterChartVueProps,
+    HelixHeadlessScatterChartVueEvents
+  >;
   /** **The whole component is one fact a stylesheet cannot work out for itself: which edges have content past them.** A fade at the bottom of a list is easy to draw and impossible to decide, because CSS has no reading of scroll position. So this measures and says, in a custom state per edge, and the styled tier draws whatever it likes on the edges named.  **States rather than attributes**, so an element that upgrades after a framework rendered its markup does not hand that framework markup it did not write. A stylesheet asks ':host(:state(more-block-end))'.  **A scrolling region takes the keyboard when it scrolls, and not before.** A box a reader can only reach with a pointer is a box some readers cannot read at all, which is what 'tabindex' answers here. Only while it overflows: a tab stop on a box with nothing to scroll is a stop that does nothing, and a form full of them is worse than the problem.  'role="region"' only with a 'label', because an unnamed region is an announcement with no content: a screen reader says "region" and the reader has learned nothing they did not already know. */
   "helix-headless-scroll-area": DefineCustomElement<
     HelixHeadlessScrollArea,
@@ -8616,6 +9308,12 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessSkeletonVueProps,
     HelixHeadlessSkeletonVueEvents
   >;
+  /** A keyboard reader arriving on a page tabs through the whole header before reaching anything the page is about, and does it again on the next page. This is the control that skips it: first in the document, and pointed at the content.  **It moves focus, not only the scroll position.** An in-page link on its own scrolls to its target and leaves focus behind, so the next Tab goes to whatever followed the link, which is the header it was meant to skip. Pressed, this focuses the target. A target that cannot take focus, which is most of them, since '<main>' cannot, is given 'tabindex="-1"' for as long as it holds focus and has it taken off again when focus leaves, so the page ends up as the consumer wrote it.  **The address is left alone.** The press is handled rather than followed, so no '#main' lands in the URL and no history entry is added, which matters to a router reading the hash. The anchor is still a real anchor with a real 'href', so before any script has run the link does what a plain link does: it scrolls there and moves the point the next Tab starts from.  **Hidden until focused is the styled tier's**, being a decision about paint, and on this tier the link is simply a link. A headless consumer hides '::part(link)' while the host is not ':focus-within' and shows it when it is. Hiding with 'display: none' or 'visibility: hidden' takes it out of the tab order as well, and a skip link nobody can reach is the most common way one is broken. */
+  "helix-headless-skip-link": DefineCustomElement<
+    HelixHeadlessSkipLink,
+    HelixHeadlessSkipLinkVueProps,
+    HelixHeadlessSkipLinkVueEvents
+  >;
   /** A real '<input type="range">', so the drag, the arrow keys, Home and End, the page keys and the touch target are the platform's. The last is the one nobody notices: a native range has a hit area larger than its thumb, sized by the platform for a finger.  **The value is a string, like every other form control's.** A range submits text and 'MixinControllerValue' holds text, so the number is a reading of the value. 'valueAsNumber' is there for arithmetic.  **Marks are drawn rather than left to '<datalist>'**, whose ticks cannot be styled and which Firefox does not render for a range at all. A mark is decoration; what a reader can land on is 'step', which the input enforces whether or not anything is drawn. 'markers' is a count rather than a flag, so a slider from zero to a hundred cannot silently ask for a hundred and one.  **A range is two of them.** There is no native two-thumb range, so two are stacked on one track and each thumb keeps its own. */
   "helix-headless-slider": DefineCustomElement<
     HelixHeadlessSlider,
@@ -8682,7 +9380,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessTableCellVueProps,
     HelixHeadlessTableCellVueEvents
   >;
-  /** **The column is the source of both its heading and its track.** Add one and the table has another track; remove one and it does not. Declaring the widths separately, as a CSS track list on the table, leaves nothing tying the two together: a table with three headings and a two-track list renders without complaint, and a track list that is accidentally the headings is invalid CSS the grid silently ignores, collapsing the whole table into one column.  **It is also where every per-column fact goes**, which is the reason 'helix-data-table' needs no column config object. 'field' names the key the cell reads, 'sortable' says a reader may reorder by it, 'align' says which edge the values line up against, and 'cell' takes a function for anything the field alone cannot express. The schema is markup and the data is a property: a schema is small, declarative, and something a reader should be able to see in the HTML, and data is large and windowed.  **The same element serves both tables**, the markup one and the data one. It is identified by a flag rather than by 'instanceof', so a 'helix-table-column' works inside either without the two roots sharing anything else.  **It generates no box of its own**, the same as a row: the heading is a grid item of the table, so it lines up with the cells under it rather than sitting in a wrapper that has to be kept the same width. */
+  /** **The column is the source of both its heading and its track.** Add one and the table has another track; remove one and it does not. Declaring the widths separately, as a CSS track list on the table, leaves nothing tying the two together: a table with three headings and a two-track list renders without complaint, and a track list that is accidentally the headings is invalid CSS the grid silently ignores, collapsing the whole table into one column.  **It is also where every per-column fact goes**, which is the reason 'helix-data-table' needs no column config object. 'field' names the key the cell reads, 'sortable' says a reader may reorder by it, 'align' says which edge the values line up against, and 'cell' takes a function for anything the field alone cannot express. The schema is markup and the data is a property: a schema is small, declarative, and something a reader should be able to see in the HTML, and data is large and windowed.  **The same element serves both tables**, the markup one and the data one. It is identified by a flag rather than by 'instanceof', so a 'helix-table-column' works inside either without the two roots sharing anything else.  **It generates no box of its own**, the same as a row: the heading is a grid item of the table, so it lines up with the cells under it rather than sitting in a wrapper that has to be kept the same width.  **A heading that does something holds a control that does it.** The host is the column header, and a header is not focusable, so a sortable heading is a '<button>' inside it: the pattern for a sortable table, and the only way a reader on a keyboard reaches the sort at all. A column a reader may resize carries a 'separator' on its end edge, moved by dragging it or with the arrow keys, and a column in a table that lets a reader reorder its columns carries a grip the table moves. */
   "helix-headless-table-column": DefineCustomElement<
     HelixHeadlessTableColumn,
     HelixHeadlessTableColumnVueProps,
@@ -8802,7 +9500,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessTourStopVueProps,
     HelixHeadlessTourStopVueEvents
   >;
-  /** **'open', on 'MixinControllerOpen', rather than a bare boolean of its own.** A branch showing its children is the same state a disclosure holds. A hand-written toggle announces nothing, so a consumer could neither know a branch opened nor own the state. 'aria-expanded' is still what the row renders: the property differs, not the semantics.  An element rather than a slot, because it owns state: whether it is open, selected, and whether it holds focus.  A branch is any item with something slotted into 'children', detected in 'firstUpdated' because the server cannot inspect children. The server renders the node as a leaf and the twisty appears on hydration, which is the harmless direction.  **'href' makes the row itself the link.** With the anchor slotted into the name instead, everything outside the words is dead: no Enter, no middle click, no status bar. Given an 'href' the row *is* an '<a>'. */
+  /** **'open', on 'MixinControllerOpen', rather than a bare boolean of its own.** A branch showing its children is the same state a disclosure holds. A hand-written toggle announces nothing, so a consumer could neither know a branch opened nor own the state. 'aria-expanded' is still what the row renders: the property differs, not the semantics.  An element rather than a slot, because it owns state: whether it is open, selected, and whether it holds focus.  A branch is any item with something slotted into 'children', detected on the client because the server cannot inspect children. The server renders the node as a leaf and the twisty appears on hydration, which is the harmless direction.  **'href' makes the row itself the link.** With the anchor slotted into the name instead, everything outside the words is dead: no Enter, no middle click, no status bar. Given an 'href' the row *is* an '<a>'. */
   "helix-headless-tree-item": DefineCustomElement<
     HelixHeadlessTreeItem,
     HelixHeadlessTreeItemVueProps,