@fusion.dev/helix-headless 0.103.3 → 0.104.0

package/types/vue.d.ts

@@ -16,6 +16,19 @@ import type {
   HelixHeadlessButtonGroup,
   HelixHeadlessButton,
   HelixHeadlessCallout,
+  HelixHeadlessCanvasEdge,
+  HelixHeadlessCanvasNode,
+  CanvasDocument,
+  CanvasEdge,
+  CanvasEdgeProps,
+  CanvasEnd,
+  CanvasNode,
+  CanvasNodeProps,
+  CanvasPath,
+  CanvasSide,
+  CanvasTone,
+  fromJsonCanvas,
+  HelixHeadlessCanvas,
   HelixHeadlessCard,
   HelixHeadlessCarousel,
   HelixHeadlessChatComposer,
@@ -141,6 +154,18 @@ import type {
   HelixBeforeOpenEvent,
   HelixDismissEvent,
   HelixScrolledEvent,
+  HelixBeforeMoveEvent,
+  HelixBeforeReconnectEvent,
+  HelixBeforeRelabelEvent,
+  HelixCanvasEditEvent,
+  HelixCanvasPanEvent,
+  HelixCanvasViewEvent,
+  HelixCanvasZoomEvent,
+  HelixConnectEvent,
+  HelixMoveEvent,
+  HelixReconnectEvent,
+  HelixRelabelEvent,
+  HelixRemoveEvent,
   HelixSelectEvent,
   HelixSendEvent,
   HelixBeforePinEvent,
@@ -258,6 +283,10 @@ empty string writes `name=""` onto every item ever rendered: Lit reflects
 it, and the resting state of a reflected property is the attribute's
 absence. Caught by `hydration.dom.spec.ts`. */
   name?: (HelixHeadlessAccordionItem["name"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessAccordionItem["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessAccordionItem["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -271,10 +300,6 @@ 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?: (HelixHeadlessAccordionItem["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixHeadlessAccordionItem["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixHeadlessAccordionItem["defaultOpen"]) | undefined;
 };
 
 export type HelixHeadlessAccordionItemVueEvents = {
@@ -883,6 +908,474 @@ there is no `severity` beside it. */
 
 export type HelixHeadlessCalloutVueEvents = {};
 
+export type HelixHeadlessCanvasEdgeVueProps = {
+  /** The card it leaves. */
+  from?: (HelixHeadlessCanvasEdge["from"]) | undefined;
+  /** What sits at the end it leaves from.
+
+Absent is nothing, which is the format's own default and what makes an
+ordinary connector a one-way arrow. */
+  "from-end"?: (HelixHeadlessCanvasEdge["fromEnd"]) | undefined;
+  /** What sits at the end it leaves from.
+
+Absent is nothing, which is the format's own default and what makes an
+ordinary connector a one-way arrow. */
+  fromEnd?: (HelixHeadlessCanvasEdge["fromEnd"]) | undefined;
+  /** Which side of that card it leaves, where the document says. */
+  "from-side"?: (HelixHeadlessCanvasEdge["fromSide"]) | undefined;
+  /** Which side of that card it leaves, where the document says. */
+  fromSide?: (HelixHeadlessCanvasEdge["fromSide"]) | undefined;
+  /** What the connector says, drawn at its middle. */
+  label?: (HelixHeadlessCanvasEdge["label"]) | undefined;
+  /** What a request calls this connection, unique on its board.
+
+Optional, unlike a card's: a connection is also known by its two ends,
+which `helix-remove` carries beside this, so a page that names none of its
+connections can still find the one a reader asked to take away. */
+  name?: (HelixHeadlessCanvasEdge["name"]) | undefined;
+  /** How it travels: `straight`, or `step` for right angles.
+
+Absent is whatever the board says, and a curve where the board says
+nothing. Not part of JSON Canvas, which draws every edge one way; a
+document read from one keeps its curves.
+
+**`path` rather than `shape`**, which is a word this library already
+spends on how an element looks in the styled tier: this changes the line
+the connector is drawn along, which the board computes. Nor `route`, which
+every element here already has, as the method that sends a child to a slot. */
+  path?: (HelixHeadlessCanvasEdge["path"]) | undefined;
+  /** Keeps this connection: a reader cannot remove it.
+
+The board's `readonly` still wins. A connection is still removed with a
+card at either end of it, since a line to a card that has gone is not one
+the board can draw. */
+  readonly?: (HelixHeadlessCanvasEdge["readOnly"]) | undefined;
+  /** Keeps this connection: a reader cannot remove it.
+
+The board's `readonly` still wins. A connection is still removed with a
+card at either end of it, since a line to a card that has gone is not one
+the board can draw. */
+  readOnly?: (HelixHeadlessCanvasEdge["readOnly"]) | undefined;
+  /** The card it arrives at. */
+  to?: (HelixHeadlessCanvasEdge["to"]) | undefined;
+  /** What sits at the end it arrives at. Absent is an arrow, as the format says. */
+  "to-end"?: (HelixHeadlessCanvasEdge["toEnd"]) | undefined;
+  /** What sits at the end it arrives at. Absent is an arrow, as the format says. */
+  toEnd?: (HelixHeadlessCanvasEdge["toEnd"]) | undefined;
+  /** What the connection means, in the words every Helix component uses.
+
+A color with no meaning is `--canvas-edge-color`, written in the edge's own
+`style`: the line is drawn by the board rather than by this element, so the
+board carries the value across from where it was written. */
+  tone?: (HelixHeadlessCanvasEdge["tone"]) | undefined;
+  /** Which side of that card it arrives at, where the document says. */
+  "to-side"?: (HelixHeadlessCanvasEdge["toSide"]) | undefined;
+  /** Which side of that card it arrives at, where the document says. */
+  toSide?: (HelixHeadlessCanvasEdge["toSide"]) | undefined;
+  /** How the line is drawn: `dashed` or `dotted`, and solid where it says
+neither.
+
+**A variant rather than an axis**, which is what the registry keeps it for:
+no other family draws a line whose stroke says something, and a dashed
+connection is the ordinary way to draw a weaker or an optional one. On the
+headless tier because the board that draws the line is. */
+  variant?: (HelixHeadlessCanvasEdge["variant"]) | undefined;
+};
+
+export type HelixHeadlessCanvasEdgeVueEvents = {};
+
+export type HelixHeadlessCanvasNodeVueProps = {
+  /** A box drawn behind the cards inside it rather than a card.
+
+The board works out what is inside it from the geometry, which is what the
+format does too, and moves them with it. Its `label` is drawn above it. */
+  group?: (HelixHeadlessCanvasNode["group"]) | undefined;
+  /** How tall the card is, in the document's own units. */
+  height?: (HelixHeadlessCanvasNode["height"]) | undefined;
+  /** What the card is called, for a group and wherever another card names it.
+
+A group needs one because it has no text of its own; a card that has text
+is named by it, and one holding a picture or a figure is named by nothing
+short enough to read out in another card's connections. */
+  label?: (HelixHeadlessCanvasNode["label"]) | undefined;
+  /** What connections and requests call this card, unique on its board.
+
+Required: a card with no name is drawn but nothing can connect to it, and
+the board has nothing to say when a reader asks for it to go. */
+  name?: (HelixHeadlessCanvasNode["name"]) | undefined;
+  /** Keeps this card where it is: not moved, not connected, not removed.
+
+**The board's own word, meaning the same thing one card at a time.** A
+board of cards a reader rearranges often has one that anchors it, a start
+or a title, and this is that card. The board's `readonly` still wins, so a
+read-only board is read-only whatever its cards say. */
+  readonly?: (HelixHeadlessCanvasNode["readOnly"]) | undefined;
+  /** Keeps this card where it is: not moved, not connected, not removed.
+
+**The board's own word, meaning the same thing one card at a time.** A
+board of cards a reader rearranges often has one that anchors it, a start
+or a title, and this is that card. The board's `readonly` still wins, so a
+read-only board is read-only whatever its cards say. */
+  readOnly?: (HelixHeadlessCanvasNode["readOnly"]) | undefined;
+  /** The card's outline: `circle`, `diamond`, `pill` or `square`, and a rounded
+box where it says none.
+
+**A flowchart's vocabulary, and the reason it is on this tier**: a diamond
+is drawn as an outline the card renders, because a border follows a box
+and a diamond is not one, so the markup differs before any rule is
+written. Every shape here meets the middle of each side of its box, which
+is where a connection arrives, so a connection to a diamond lands on its
+point and one to a circle on its curve without the board knowing which. */
+  shape?: (HelixHeadlessCanvasNode["shape"]) | undefined;
+  /** What the card means, in the words every Helix component uses for it.
+
+**`tone` rather than the format's `color`**, which was a second word for
+the same thing on this family alone: JSON Canvas writes `1` to `6` and
+leaves the meaning to the application, and this board had already pinned
+each to a tone. `fromJsonCanvas` maps the six to tones on the way in. A
+color with no meaning, a hex a document chose, is a custom property on the
+card, `--canvas-node-color`, which is a style rather than a statement.
+
+On the headless tier because meaning survives having no stylesheet. */
+  tone?: (HelixHeadlessCanvasNode["tone"]) | undefined;
+  /** How wide the card is, in the document's own units. */
+  width?: (HelixHeadlessCanvasNode["width"]) | undefined;
+  /** Where its left edge sits, in the document's own units. */
+  x?: (HelixHeadlessCanvasNode["x"]) | undefined;
+  /** Where its top edge sits, in the document's own units. */
+  y?: (HelixHeadlessCanvasNode["y"]) | undefined;
+};
+
+export type HelixHeadlessCanvasNodeVueEvents = {};
+
+/** `HelixHeadlessCanvas` component event */
+export type HelixHeadlessCanvasElementEvent<E = Event> = TypedEvent<
+  HelixHeadlessCanvas,
+  E
+>;
+/** `helix-before-move` event type */
+export type HelixHeadlessCanvasHelixBeforeMoveElementEvent =
+  HelixHeadlessCanvasElementEvent<HelixBeforeMoveEvent>;
+/** `helix-before-reconnect` event type */
+export type HelixHeadlessCanvasHelixBeforeReconnectElementEvent =
+  HelixHeadlessCanvasElementEvent<HelixBeforeReconnectEvent>;
+/** `helix-before-relabel` event type */
+export type HelixHeadlessCanvasHelixBeforeRelabelElementEvent =
+  HelixHeadlessCanvasElementEvent<HelixBeforeRelabelEvent>;
+/** `helix-canvas-edit` event type */
+export type HelixHeadlessCanvasHelixCanvasEditElementEvent =
+  HelixHeadlessCanvasElementEvent<HelixCanvasEditEvent>;
+/** `helix-canvas-pan` event type */
+export type HelixHeadlessCanvasHelixCanvasPanElementEvent =
+  HelixHeadlessCanvasElementEvent<HelixCanvasPanEvent>;
+/** `helix-canvas-view` event type */
+export type HelixHeadlessCanvasHelixCanvasViewElementEvent =
+  HelixHeadlessCanvasElementEvent<HelixCanvasViewEvent>;
+/** `helix-canvas-zoom` event type */
+export type HelixHeadlessCanvasHelixCanvasZoomElementEvent =
+  HelixHeadlessCanvasElementEvent<HelixCanvasZoomEvent>;
+/** `helix-connect` event type */
+export type HelixHeadlessCanvasHelixConnectElementEvent =
+  HelixHeadlessCanvasElementEvent<HelixConnectEvent>;
+/** `helix-move` event type */
+export type HelixHeadlessCanvasHelixMoveElementEvent =
+  HelixHeadlessCanvasElementEvent<HelixMoveEvent>;
+/** `helix-reconnect` event type */
+export type HelixHeadlessCanvasHelixReconnectElementEvent =
+  HelixHeadlessCanvasElementEvent<HelixReconnectEvent>;
+/** `helix-relabel` event type */
+export type HelixHeadlessCanvasHelixRelabelElementEvent =
+  HelixHeadlessCanvasElementEvent<HelixRelabelEvent>;
+/** `helix-remove` event type */
+export type HelixHeadlessCanvasHelixRemoveElementEvent =
+  HelixHeadlessCanvasElementEvent<HelixRemoveEvent>;
+/** `helix-select` event type */
+export type HelixHeadlessCanvasHelixSelectElementEvent =
+  HelixHeadlessCanvasElementEvent<HelixSelectEvent>;
+
+export type HelixHeadlessCanvasVueProps = {
+  /** How a card says where its connections come from, with `{cards}`. */
+  "comes-from-label"?: (HelixHeadlessCanvas["comesFromLabel"]) | undefined;
+  /** How a card says where its connections come from, with `{cards}`. */
+  comesFromLabel?: (HelixHeadlessCanvas["comesFromLabel"]) | undefined;
+  /** What it says when a connection is asked for, with `{from}` and `{to}`. */
+  "connected-label"?: (HelixHeadlessCanvas["connectedLabel"]) | undefined;
+  /** What it says when a connection is asked for, with `{from}` and `{to}`. */
+  connectedLabel?: (HelixHeadlessCanvas["connectedLabel"]) | undefined;
+  /** What the live region says when a reader starts a connection, with `{from}`
+filled in.
+
+**Every sentence this board speaks is a property**, the rule the pan
+controls already kept with `pan-up-label` and its three: a board on a page in another
+language otherwise read its connections out in English. */
+  "connecting-label"?: (HelixHeadlessCanvas["connectingLabel"]) | undefined;
+  /** What the live region says when a reader starts a connection, with `{from}`
+filled in.
+
+**Every sentence this board speaks is a property**, the rule the pan
+controls already kept with `pan-up-label` and its three: a board on a page in another
+language otherwise read its connections out in English. */
+  connectingLabel?: (HelixHeadlessCanvas["connectingLabel"]) | undefined;
+  /** What a connection is called, with `{from}` and `{to}`.
+
+Its own label, where it has one, is its description rather than part of
+this, so a reader hears the ends first and what the line says after. */
+  "connection-label"?: (HelixHeadlessCanvas["connectionLabel"]) | undefined;
+  /** What a connection is called, with `{from}` and `{to}`.
+
+Its own label, where it has one, is its description rather than part of
+this, so a reader hears the ends first and what the line says after. */
+  connectionLabel?: (HelixHeadlessCanvas["connectionLabel"]) | undefined;
+  /** Accessible name for the board, which is the one thing a consumer must write.
+
+A document has no name of its own in the format, and "Canvas" names the
+widget rather than the thinking on it. */
+  label?: (HelixHeadlessCanvas["label"]) | undefined;
+  /** What the field a label is edited in is called, with `{name}` for what it
+labels. */
+  "label-editor-label"?: (HelixHeadlessCanvas["labelEditorLabel"]) | undefined;
+  /** What the field a label is edited in is called, with `{name}` for what it
+labels. */
+  labelEditorLabel?: (HelixHeadlessCanvas["labelEditorLabel"]) | undefined;
+  /** How a card says where its connections go, with `{cards}` as the list.
+
+The list is joined the way the page's language joins one, "Second and
+Third", rather than with a comma this component chose. */
+  "leads-to-label"?: (HelixHeadlessCanvas["leadsToLabel"]) | undefined;
+  /** How a card says where its connections go, with `{cards}` as the list.
+
+The list is joined the way the page's language joins one, "Second and
+Third", rather than with a comma this component chose. */
+  leadsToLabel?: (HelixHeadlessCanvas["leadsToLabel"]) | undefined;
+  /** The order a reader meets the cards in.
+
+`spatial` bands them into rows and reads each row across, which is how a
+person reads a board laid out on a grid and is a heuristic a loose board
+defeats. `edges` follows the arrows from the cards nothing points to, which
+on a board that is a flow is the order its author meant.
+
+Absent is spatial, a resting value being an attribute's absence: a default
+that reflected would write a choice onto every host that no server sent. */
+  order?: (HelixHeadlessCanvas["order"]) | undefined;
+  /** How every connection travels, where it does not say: `straight`, or `step`
+for right angles.
+
+Absent is a curve. A flowchart wants `step` on all of its edges, and
+writing it once here rather than on each is the reason this exists; an
+edge's own `path` still wins. */
+  path?: (HelixHeadlessCanvas["path"]) | undefined;
+  /** Keeps every card where its author put it.
+
+**The attribute is `readonly`, which is the platform's spelling**, and the
+reverse of an `editable` switch on purpose: a form control takes input
+unless it is told not to, and a board a reader can rearrange is the same
+kind of thing. A drag on a card pans the board instead, and the keys still
+walk the cards. */
+  readonly?: (HelixHeadlessCanvas["readOnly"]) | undefined;
+  /** Keeps every card where its author put it.
+
+**The attribute is `readonly`, which is the platform's spelling**, and the
+reverse of an `editable` switch on purpose: a form control takes input
+unless it is told not to, and a board a reader can rearrange is the same
+kind of thing. A drag on a card pans the board instead, and the keys still
+walk the cards. */
+  readOnly?: (HelixHeadlessCanvas["readOnly"]) | undefined;
+  /** What the live region says when a reader picks up a connection's end, with
+`{from}` and `{to}`. */
+  "reconnecting-label"?: (HelixHeadlessCanvas["reconnectingLabel"]) | undefined;
+  /** What the live region says when a reader picks up a connection's end, with
+`{from}` and `{to}`. */
+  reconnectingLabel?: (HelixHeadlessCanvas["reconnectingLabel"]) | undefined;
+  /** The cards and connections the reader selected, by name, comma separated,
+and empty for none.
+
+**Comma separated, the way `Listbox` writes a multiple value**, so a page
+reads one selection the same way wherever it comes from. A click, or a key
+that lands on one, selects it alone; Shift, Command or Control with a click
+adds or takes one away, and so does Space; Command or Control with A
+selects everything; Shift and a drag across the empty board selects the
+cards the box touches. A click on the empty board, or Escape, selects
+nothing. Dragging, Shift with an arrow, and Delete act on the whole
+selection.
+
+**Kept apart from focus**, so it stays when focus leaves: a reader who
+selects cards and clicks a button beside the board to act on them has not
+cleared what the button acts on by clicking. A connection with no name is
+called by its ends, `from->to`, which is also why a name has to be unique
+on its board across cards and connections both, and may not hold a comma.
+
+Written to select from outside, and read to act on the selection. */
+  selected?: (HelixHeadlessCanvas["selected"]) | undefined;
+  /** What it says when a reader stops connecting without asking. */
+  "stopped-label"?: (HelixHeadlessCanvas["stoppedLabel"]) | undefined;
+  /** What it says when a reader stops connecting without asking. */
+  stoppedLabel?: (HelixHeadlessCanvas["stoppedLabel"]) | undefined;
+  /** Which of the controls this surface draws, as a list of what to keep.
+
+**A list rather than a switch, because the overlap is not symmetric.** A
+surface a consumer brings often has zoom controls of its own and almost
+never has pan buttons, so a single switch would make them choose between
+a duplicate and nothing.
+
+`none` draws none of them, which is the right answer where what was
+slotted already has controls a reader can find: what this argues for is
+that *a* findable control exists, never that it is ours. The methods stay
+public either way, so a consumer drawing their own chrome can still drive
+the surface.
+
+Absent is whatever the family rests at, which is this library's rule that
+a resting value is an attribute's absence: all three for a map, whose
+reader may have no other way to move it, and zoom and fullscreen for a
+board, which a reader drags and whose pad took a third of the frame. The
+stylesheet lays the cluster out by which buttons are in it rather than by
+this attribute, so the two defaults need no rule each. */
+  controls?: (HelixHeadlessCanvas["controls"]) | undefined;
+  /** What the group of controls is called, for a reader who meets it.
+
+Absent is the family's own name for it, "Map controls" or "Board
+controls", which names what the controls drive rather than the
+mechanism. Written here to say it in another language, which every other
+string this surface speaks already allowed and this one did not. */
+  "controls-label"?: (HelixHeadlessCanvas["controlsLabel"]) | undefined;
+  /** What the group of controls is called, for a reader who meets it.
+
+Absent is the family's own name for it, "Map controls" or "Board
+controls", which names what the controls drive rather than the
+mechanism. Written here to say it in another language, which every other
+string this surface speaks already allowed and this one did not. */
+  controlsLabel?: (HelixHeadlessCanvas["controlsLabel"]) | undefined;
+  /** Which corner the controls sit in.
+
+**Configurable because there is no safe default**, which is a collision
+rather than a taste: whatever a consumer slots may put its own controls
+in any corner, and every library that draws some made this a setting for
+the same reason.
+
+Logical corners rather than left and right, so a right-to-left page moves
+them without a consumer writing a second rule. Absent is the top end, a
+resting value being an attribute's absence: a default that reflected
+would write an attribute onto every host that no server sent. */
+  "controls-placement"?: (HelixHeadlessCanvas["controlsPlacement"]) | undefined;
+  /** Which corner the controls sit in.
+
+**Configurable because there is no safe default**, which is a collision
+rather than a taste: whatever a consumer slots may put its own controls
+in any corner, and every library that draws some made this a setting for
+the same reason.
+
+Logical corners rather than left and right, so a right-to-left page moves
+them without a consumer writing a second rule. Absent is the top end, a
+resting value being an attribute's absence: a default that reflected
+would write an attribute onto every host that no server sent. */
+  controlsPlacement?: (HelixHeadlessCanvas["controlsPlacement"]) | undefined;
+  /** What the control that fills the screen is called. */
+  "fullscreen-label"?: (HelixHeadlessCanvas["fullscreenLabel"]) | undefined;
+  /** What the control that fills the screen is called. */
+  fullscreenLabel?: (HelixHeadlessCanvas["fullscreenLabel"]) | undefined;
+  /** How long the reader may be still before the chrome hides, in milliseconds.
+
+Zero keeps it up, which is the default: these controls are how a keyboard
+reader operates the surface, and chrome that hid itself by default would
+be the component undoing its own argument. Set it for a display nobody
+drives. */
+  "idle-delay"?: (HelixHeadlessCanvas["idleDelay"] | `${number}`) | undefined;
+  /** How long the reader may be still before the chrome hides, in milliseconds.
+
+Zero keeps it up, which is the default: these controls are how a keyboard
+reader operates the surface, and chrome that hid itself by default would
+be the component undoing its own argument. Set it for a display nobody
+drives. */
+  idleDelay?: (HelixHeadlessCanvas["idleDelay"]) | undefined;
+  /** What the control that pans down is called.
+
+**A label for each way rather than one with the way filled in**, which is
+what this was: `Pan {way}` filled in with `left`, so a page that said it
+in French read out "Déplacer left". The word for a direction is as much
+the translator's as the word for panning, and a language can put it
+anywhere in the phrase. */
+  "pan-down-label"?: (HelixHeadlessCanvas["panDownLabel"]) | undefined;
+  /** What the control that pans down is called.
+
+**A label for each way rather than one with the way filled in**, which is
+what this was: `Pan {way}` filled in with `left`, so a page that said it
+in French read out "Déplacer left". The word for a direction is as much
+the translator's as the word for panning, and a language can put it
+anywhere in the phrase. */
+  panDownLabel?: (HelixHeadlessCanvas["panDownLabel"]) | undefined;
+  /** What the control that pans left is called, on screen. */
+  "pan-left-label"?: (HelixHeadlessCanvas["panLeftLabel"]) | undefined;
+  /** What the control that pans left is called, on screen. */
+  panLeftLabel?: (HelixHeadlessCanvas["panLeftLabel"]) | undefined;
+  /** What the control that pans right is called, on screen. */
+  "pan-right-label"?: (HelixHeadlessCanvas["panRightLabel"]) | undefined;
+  /** What the control that pans right is called, on screen. */
+  panRightLabel?: (HelixHeadlessCanvas["panRightLabel"]) | undefined;
+  /** How far one press moves the view, as a fraction of what is on screen.
+
+A fraction rather than a distance, because this surface does not know the
+scale of what is inside it: a quarter of the viewport is the same gesture
+at any zoom, and a consumer who wants their own units multiplies by them. */
+  "pan-step"?: (HelixHeadlessCanvas["panStep"] | `${number}`) | undefined;
+  /** How far one press moves the view, as a fraction of what is on screen.
+
+A fraction rather than a distance, because this surface does not know the
+scale of what is inside it: a quarter of the viewport is the same gesture
+at any zoom, and a consumer who wants their own units multiplies by them. */
+  panStep?: (HelixHeadlessCanvas["panStep"]) | undefined;
+  /** What the control that pans up is called. */
+  "pan-up-label"?: (HelixHeadlessCanvas["panUpLabel"]) | undefined;
+  /** What the control that pans up is called. */
+  panUpLabel?: (HelixHeadlessCanvas["panUpLabel"]) | undefined;
+  /** What the control that zooms in is called. */
+  "zoom-in-label"?: (HelixHeadlessCanvas["zoomInLabel"]) | undefined;
+  /** What the control that zooms in is called. */
+  zoomInLabel?: (HelixHeadlessCanvas["zoomInLabel"]) | undefined;
+  /** What the control that zooms out is called. */
+  "zoom-out-label"?: (HelixHeadlessCanvas["zoomOutLabel"]) | undefined;
+  /** What the control that zooms out is called. */
+  zoomOutLabel?: (HelixHeadlessCanvas["zoomOutLabel"]) | undefined;
+  /** Where the board is looking: the document's point at the middle of the view,
+and the zoom.
+
+**Read to save a view and written to restore one**, which a consumer keeping
+a minimap in step, or putting a reader back where they were, had no way to
+do: where the board sat was private, and the events said only which way a
+control had moved it. The middle rather than a corner, so a view saved in
+one box shows the same thing in the middle of a box of another size.
+Writing one counts as the reader choosing a view, so a later resize keeps
+it rather than fitting the board again. */
+  view?: (HelixHeadlessCanvas["view"]) | undefined;
+};
+
+export type HelixHeadlessCanvasVueEvents = {
+  /** Cards are about to move. Refuse it to keep the positions in your own state. */
+  "helix-before-move": HelixHeadlessCanvasHelixBeforeMoveElementEvent;
+  /** A connection's end is about to move to another card or side. Refuse it to keep connections in your own state. */
+  "helix-before-reconnect": HelixHeadlessCanvasHelixBeforeReconnectElementEvent;
+  /** A connection's label or a group's name is about to change. Refuse it to keep labels in your own state. */
+  "helix-before-relabel": HelixHeadlessCanvasHelixBeforeRelabelElementEvent;
+  /** The reader asked to edit a card: a double-click, or Enter or F2. Open your own editor for it. */
+  "helix-canvas-edit": HelixHeadlessCanvasHelixCanvasEditElementEvent;
+  /** The board was moved a step, by its controls or the arrow keys: a fact rather than a request. A drag says so through `helix-canvas-view`. */
+  "helix-canvas-pan": HelixHeadlessCanvasHelixCanvasPanElementEvent;
+  /** Where the board is looking changed, however it changed. The detail is the new view. */
+  "helix-canvas-view": HelixHeadlessCanvasHelixCanvasViewElementEvent;
+  /** The board zoomed a step, by its controls or the keys. A wheel or a pinch says so through `helix-canvas-view`. */
+  "helix-canvas-zoom": HelixHeadlessCanvasHelixCanvasZoomElementEvent;
+  /** A reader asked for two cards to be joined. Add the `helix-canvas-edge` to do it. */
+  "helix-connect": HelixHeadlessCanvasHelixConnectElementEvent;
+  /** Cards moved and the move is finished: a drag let go, a click that put a card down, or a key pressed. */
+  "helix-move": HelixHeadlessCanvasHelixMoveElementEvent;
+  /** A connection's end moved, and the move is finished. */
+  "helix-reconnect": HelixHeadlessCanvasHelixReconnectElementEvent;
+  /** A connection's label or a group's name changed. */
+  "helix-relabel": HelixHeadlessCanvasHelixRelabelElementEvent;
+  /** A reader asked for cards or connections to go. Remove the elements it names. */
+  "helix-remove": HelixHeadlessCanvasHelixRemoveElementEvent;
+  /** The selection changed. The detail's `value` is the names, comma separated, empty for none. Cancelable: refusing it keeps the selection where it was. */
+  "helix-select": HelixHeadlessCanvasHelixSelectElementEvent;
+};
+
 export type HelixHeadlessCardVueProps = {
   /** Puts the media after the content instead of before it.
 
@@ -924,19 +1417,6 @@ export type HelixHeadlessCarouselHelixSelectElementEvent =
 export type HelixHeadlessCarouselVueProps = {
   /** Whether the carousel advances on its own. */
   autoplay?: (HelixHeadlessCarousel["autoplay"]) | undefined;
-  /** The slide in view, counted from zero.
-
-Reading gives the real slide. Writing always applies, the way a script
-assigning to a native control does, and is a seed and a correction rather
-than a claim of ownership: a consumer who wants the decision refuses the
-`helix-select`. `default-index` is where the carousel starts until
-something moves it.
-
-The same contract the four mixins carry, written out here rather than
-extracted, because a slide is addressed by position and every one of those
-mixins is keyed by a name. One consumer is not a mixin: if a second numeric
-state turns up, this is what it is extracted from. */
-  index?: (HelixHeadlessCarousel["index"]) | undefined;
   /** Whether the previous and next controls are shown.
 
 `auto`, which is the resting behavior and what an absent attribute means,
@@ -965,12 +1445,45 @@ touch device exactly as it does on a desktop. */
   "default-index"?: (HelixHeadlessCarousel["defaultIndex"] | `${number}`) | undefined;
   /** Slide to start on, where nothing declared one. */
   defaultIndex?: (HelixHeadlessCarousel["defaultIndex"]) | undefined;
+  /** The slide in view, counted from zero.
+
+Reading gives the real slide. Writing always applies, the way a script
+assigning to a native control does, and is a seed and a correction rather
+than a claim of ownership: a consumer who wants the decision refuses the
+`helix-select`. `default-index` is where the carousel starts until
+something moves it.
+
+The same contract the four mixins carry, written out here rather than
+extracted, because a slide is addressed by position and every one of those
+mixins is keyed by a name. One consumer is not a mixin: if a second numeric
+state turns up, this is what it is extracted from. */
+  index?: (HelixHeadlessCarousel["index"]) | undefined;
+  /** What one indicator is called, with `{index}` filled in.
+
+**Every word the carousel speaks is a property**, so a page in another
+language hears its own: only `label` was, and the controls around it
+read out in English. */
+  "indicator-label"?: (HelixHeadlessCarousel["indicatorLabel"]) | undefined;
+  /** What one indicator is called, with `{index}` filled in.
+
+**Every word the carousel speaks is a property**, so a page in another
+language hears its own: only `label` was, and the controls around it
+read out in English. */
+  indicatorLabel?: (HelixHeadlessCarousel["indicatorLabel"]) | undefined;
+  /** What the row of indicators is called, with the carousel's `{label}` filled in. */
+  "indicators-label"?: (HelixHeadlessCarousel["indicatorsLabel"]) | undefined;
+  /** What the row of indicators is called, with the carousel's `{label}` filled in. */
+  indicatorsLabel?: (HelixHeadlessCarousel["indicatorsLabel"]) | undefined;
   /** How long each slide is held, in milliseconds. */
   interval?: (HelixHeadlessCarousel["interval"]) | undefined;
   /** Accessible name for the carousel. */
   label?: (HelixHeadlessCarousel["label"]) | undefined;
   /** Whether moving past either end wraps to the other. */
   loop?: (HelixHeadlessCarousel["loop"]) | undefined;
+  /** What the control that moves forward is called. */
+  "next-label"?: (HelixHeadlessCarousel["nextLabel"]) | undefined;
+  /** What the control that moves forward is called. */
+  nextLabel?: (HelixHeadlessCarousel["nextLabel"]) | undefined;
   /** Which way the track runs.
 
 Behavior rather than presentation, which is why it is here: the scroll
@@ -1104,6 +1617,28 @@ its attribute on upgrade, and the host then carries something a consumer's
 server markup never had, which React reports as a mismatch. The one-across
 case is the absent attribute, and the styles read it that way. */
   perView?: (HelixHeadlessCarousel["perView"]) | undefined;
+  /** What the control that moves back is called. */
+  "previous-label"?: (HelixHeadlessCarousel["previousLabel"]) | undefined;
+  /** What the control that moves back is called. */
+  previousLabel?: (HelixHeadlessCarousel["previousLabel"]) | undefined;
+  /** What each slide is called, with `{index}` and `{count}` filled in. */
+  "slide-label"?: (HelixHeadlessCarousel["slideLabel"]) | undefined;
+  /** What each slide is called, with `{index}` and `{count}` filled in. */
+  slideLabel?: (HelixHeadlessCarousel["slideLabel"]) | undefined;
+  /** What a slide is, read out in place of its role: `aria-roledescription`,
+which is a word a reader hears and so a word to translate. */
+  "slide-role-label"?: (HelixHeadlessCarousel["slideRoleLabel"]) | undefined;
+  /** What a slide is, read out in place of its role: `aria-roledescription`,
+which is a word a reader hears and so a word to translate. */
+  slideRoleLabel?: (HelixHeadlessCarousel["slideRoleLabel"]) | undefined;
+  /** What the rotation control is called while it would start rotation. */
+  "start-label"?: (HelixHeadlessCarousel["startLabel"]) | undefined;
+  /** What the rotation control is called while it would start rotation. */
+  startLabel?: (HelixHeadlessCarousel["startLabel"]) | undefined;
+  /** And while it would stop it. */
+  "stop-label"?: (HelixHeadlessCarousel["stopLabel"]) | undefined;
+  /** And while it would stop it. */
+  stopLabel?: (HelixHeadlessCarousel["stopLabel"]) | undefined;
 };
 
 export type HelixHeadlessCarouselVueEvents = {
@@ -1228,9 +1763,17 @@ export type HelixHeadlessChatHelixSendElementEvent =
   HelixHeadlessChatElementEvent<HelixSendEvent>;
 
 export type HelixHeadlessChatVueProps = {
-  /** Whether to open pinned, where nothing declared it. */
+  /** Whether to open pinned, where nothing declared it.
+
+`default-pinned="false"` opens away from the bottom. A plain boolean
+attribute could not say that: it is true by being there, whatever it holds,
+so a default of true had no attribute that turned it off. */
   "default-pinned"?: (HelixHeadlessChat["defaultPinned"]) | undefined;
-  /** Whether to open pinned, where nothing declared it. */
+  /** Whether to open pinned, where nothing declared it.
+
+`default-pinned="false"` opens away from the bottom. A plain boolean
+attribute could not say that: it is true by being there, whatever it holds,
+so a default of true had no attribute that turned it off. */
   defaultPinned?: (HelixHeadlessChat["defaultPinned"]) | undefined;
   /** Whether there are older turns than the ones here, and whether they are coming.
 
@@ -1324,6 +1867,26 @@ export type HelixHeadlessCheckboxGroupVueProps = {
   label?: (HelixHeadlessCheckboxGroup["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessCheckboxGroup["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessCheckboxGroup["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessCheckboxGroup["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -1398,6 +1961,26 @@ stylesheets. */
   label?: (HelixHeadlessCheckbox["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessCheckbox["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessCheckbox["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessCheckbox["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -1563,6 +2146,26 @@ The trade is real and is the reason this is not the default: a swatch cannot
 be read or pasted into without opening the panel, which is worse for a form
 where the color is the answer rather than a setting. */
   variant?: (HelixHeadlessColorInput["variant"]) | undefined;
+  /** What a reader is told when the field holds something the picker cannot
+read: a date that is not one, a time, a color.
+
+**Every sentence a control raises in the browser's bubble is a
+property**, named for the validity flag it reports, so a form in another
+language speaks it. Absent is the family's own sentence, in English,
+which says what the value should look like. */
+  "bad-input-message"?: (HelixHeadlessColorInput["badInputMessage"]) | undefined;
+  /** What a reader is told when the field holds something the picker cannot
+read: a date that is not one, a time, a color.
+
+**Every sentence a control raises in the browser's bubble is a
+property**, named for the validity flag it reports, so a form in another
+language speaks it. Absent is the family's own sentence, in English,
+which says what the value should look like. */
+  badInputMessage?: (HelixHeadlessColorInput["badInputMessage"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessColorInput["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessColorInput["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -1576,10 +2179,6 @@ 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?: (HelixHeadlessColorInput["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixHeadlessColorInput["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixHeadlessColorInput["defaultOpen"]) | undefined;
   /** The value the markup declared, which is where a reset returns to. */
   "default-value"?: (HelixHeadlessColorInput["defaultValue"]) | undefined;
   /** The value the markup declared, which is where a reset returns to. */
@@ -1599,6 +2198,26 @@ a reset should return to. */
   label?: (HelixHeadlessColorInput["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessColorInput["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessColorInput["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessColorInput["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -1673,11 +2292,41 @@ point.** The field holds a color, so a browser offering to fill it with a
 saved address is competing for the same keystrokes as the square and the
 ramps. A consumer who wants autofill can still ask. */
   autocomplete?: (HelixHeadlessColorPicker["autocomplete"]) | undefined;
+  /** What the square's vertical ramp is called.
+
+**Every word the picker speaks is a property**, so a page in another
+language hears its own rather than English between its own labels. */
+  "brightness-label"?: (HelixHeadlessColorPicker["brightnessLabel"]) | undefined;
+  /** What the square's vertical ramp is called.
+
+**Every word the picker speaks is a property**, so a page in another
+language hears its own rather than English between its own labels. */
+  brightnessLabel?: (HelixHeadlessColorPicker["brightnessLabel"]) | undefined;
+  /** What the sample says for a moment after it copied the value. */
+  "copied-label"?: (HelixHeadlessColorPicker["copiedLabel"]) | undefined;
+  /** What the sample says for a moment after it copied the value. */
+  copiedLabel?: (HelixHeadlessColorPicker["copiedLabel"]) | undefined;
+  /** What the sample is called, which copies the value, with `{value}` filled in. */
+  "copy-label"?: (HelixHeadlessColorPicker["copyLabel"]) | undefined;
+  /** What the sample is called, which copies the value, with `{value}` filled in. */
+  copyLabel?: (HelixHeadlessColorPicker["copyLabel"]) | undefined;
+  /** What the eyedropper is called. */
+  "eyedropper-label"?: (HelixHeadlessColorPicker["eyedropperLabel"]) | undefined;
+  /** What the eyedropper is called. */
+  eyedropperLabel?: (HelixHeadlessColorPicker["eyedropperLabel"]) | undefined;
   /** The syntax the value is written in: `hex`, `rgb` or `hsl`.
 
 Only what is written. Everything is read whatever this says, so a picker on
 `hex` still takes an `rgb()` handed to it and stores the hex for it. */
   format?: (HelixHeadlessColorPicker["format"]) | undefined;
+  /** What the syntax toggle is called, with `{format}` filled in. */
+  "format-label"?: (HelixHeadlessColorPicker["formatLabel"]) | undefined;
+  /** What the syntax toggle is called, with `{format}` filled in. */
+  formatLabel?: (HelixHeadlessColorPicker["formatLabel"]) | undefined;
+  /** What the hue channel is called. */
+  "hue-label"?: (HelixHeadlessColorPicker["hueLabel"]) | undefined;
+  /** What the hue channel is called. */
+  hueLabel?: (HelixHeadlessColorPicker["hueLabel"]) | undefined;
   /** Whether the current selection fails validation.
 
 A flag rather than a message, the split Date Picker also draws. A flat
@@ -1720,6 +2369,14 @@ answer to which one is authoritative or which has the caret. Do not close it
 the other way round, with Color Input dropping its own field: the value
 would then be unreadable and unpasteable without opening a panel. */
   noValue?: (HelixHeadlessColorPicker["noValue"]) | undefined;
+  /** What the opacity channel is called, where `alpha` offers one. */
+  "opacity-label"?: (HelixHeadlessColorPicker["opacityLabel"]) | undefined;
+  /** What the opacity channel is called, where `alpha` offers one. */
+  opacityLabel?: (HelixHeadlessColorPicker["opacityLabel"]) | undefined;
+  /** What the row of `swatches` is called. */
+  "presets-label"?: (HelixHeadlessColorPicker["presetsLabel"]) | undefined;
+  /** What the row of `swatches` is called. */
+  presetsLabel?: (HelixHeadlessColorPicker["presetsLabel"]) | undefined;
   /** Whether the control refuses changes while still submitting its value.
 
 **Enforced by refusing every request in one place**, which is the seam this
@@ -1793,8 +2450,32 @@ report bad input because their value moves only on a commit. Color Input
 reports it for this family instead, once, against the field the reader
 typed into. */
   required?: (HelixHeadlessColorPicker["required"]) | undefined;
+  /** What the square's horizontal ramp is called. */
+  "saturation-label"?: (HelixHeadlessColorPicker["saturationLabel"]) | undefined;
+  /** What the square's horizontal ramp is called. */
+  saturationLabel?: (HelixHeadlessColorPicker["saturationLabel"]) | undefined;
   /** Colors offered under the picker, as a comma-separated list. */
   swatches?: (HelixHeadlessColorPicker["swatches"]) | undefined;
+  /** What the group holding the eyedropper and the syntax toggle is called. */
+  "tools-label"?: (HelixHeadlessColorPicker["toolsLabel"]) | undefined;
+  /** What the group holding the eyedropper and the syntax toggle is called. */
+  toolsLabel?: (HelixHeadlessColorPicker["toolsLabel"]) | undefined;
+  /** What the text field holding the value is called. */
+  "value-label"?: (HelixHeadlessColorPicker["valueLabel"]) | undefined;
+  /** What the text field holding the value is called. */
+  valueLabel?: (HelixHeadlessColorPicker["valueLabel"]) | undefined;
+  /** What a reader is told when a color is required and none is chosen.
+
+**Every sentence a control raises in the browser's bubble is a property**,
+named for the validity flag it reports, so a form in another language
+speaks it. Absent is the control's own sentence, in English. */
+  "value-missing-message"?: (HelixHeadlessColorPicker["valueMissingMessage"]) | undefined;
+  /** What a reader is told when a color is required and none is chosen.
+
+**Every sentence a control raises in the browser's bubble is a property**,
+named for the validity flag it reports, so a form in another language
+speaks it. Absent is the control's own sentence, in English. */
+  valueMissingMessage?: (HelixHeadlessColorPicker["valueMissingMessage"]) | undefined;
   /** The value the markup declared, which is where a reset returns to. */
   "default-value"?: (HelixHeadlessColorPicker["defaultValue"]) | undefined;
   /** The value the markup declared, which is where a reset returns to. */
@@ -1926,9 +2607,15 @@ element is responsible for. */
   multiple?: (HelixHeadlessCombobox["multiple"]) | undefined;
   /** Text shown while nothing has been chosen. */
   placeholder?: (HelixHeadlessCombobox["placeholder"]) | undefined;
-  /** What a tag's remove control is called, since the mark has no name. */
+  /** What the control removing one chosen option is called, with `{name}` filled in.
+
+**The name goes in**, so a row of them is heard as which one each
+removes rather than as "Remove" said once per chosen option. */
   "remove-label"?: (HelixHeadlessCombobox["removeLabel"]) | undefined;
-  /** What a tag's remove control is called, since the mark has no name. */
+  /** What the control removing one chosen option is called, with `{name}` filled in.
+
+**The name goes in**, so a row of them is heard as which one each
+removes rather than as "Remove" said once per chosen option. */
   removeLabel?: (HelixHeadlessCombobox["removeLabel"]) | undefined;
   /** Whether the field finishes the word as it is typed.
 
@@ -1937,6 +2624,10 @@ element already sets on the input it renders, and two things of one name
 meaning different things on the same control is a question a consumer
 should not have to ask. */
   suggest?: (HelixHeadlessCombobox["suggest"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessCombobox["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessCombobox["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -1950,10 +2641,6 @@ 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?: (HelixHeadlessCombobox["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixHeadlessCombobox["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixHeadlessCombobox["defaultOpen"]) | undefined;
   /** What the control is called once everything is showing. */
   "collapse-label"?: (HelixHeadlessCombobox["collapseLabel"]) | undefined;
   /** What the control is called once everything is showing. */
@@ -1987,6 +2674,26 @@ a reset should return to. */
   label?: (HelixHeadlessCombobox["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessCombobox["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessCombobox["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessCombobox["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -2071,6 +2778,10 @@ with: one key, said once. */
   label?: (HelixHeadlessCommand["label"]) | undefined;
   /** Shown in the field before anything is typed. */
   placeholder?: (HelixHeadlessCommand["placeholder"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessCommand["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessCommand["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -2084,10 +2795,6 @@ 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?: (HelixHeadlessCommand["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixHeadlessCommand["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixHeadlessCommand["defaultOpen"]) | undefined;
 };
 
 export type HelixHeadlessCommandVueEvents = {
@@ -2335,20 +3042,14 @@ replaces this with what each row came to as it draws. It still has to be
 close, because it is what the scrollbar is built from before anything has
 been measured. */
   estimate?: (HelixHeadlessDataTable["estimate"]) | undefined;
-  /** The order, as `field:direction`.
-
-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;
-  /** 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;
   /** Whether this element does the work or asks the consumer to.
 
 `client` filters, sorts and pages `rows` itself. `server` applies none of
@@ -2358,25 +3059,48 @@ 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 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 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;
+  /** 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
+element ever asks for a different page size: a size selector is
+`PaginationSize`, which a consumer puts in the `footer` slot and answers
+themselves. Routing this through `requestChange` would announce an event
+the element never has cause to fire. */
+  "page-size"?: (HelixHeadlessDataTable["pageSize"] | `${number}`) | 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
+element ever asks for a different page size: a size selector is
+`PaginationSize`, which a consumer puts in the `footer` slot and answers
+themselves. Routing this through `requestChange` would announce an event
+the element never has cause to fire. */
+  pageSize?: (HelixHeadlessDataTable["pageSize"]) | undefined;
+  /** Whether to draw a pagination under the grid.
+
+On by default once a page size is set, because a paged table with no way to
+change pages shows a reader the first twenty rows and no way to know there
+are more. Off for a consumer supplying their own through the `footer` slot,
+which is why the slot replaces this rather than sitting beside it. */
+  paginated?: (HelixHeadlessDataTable["paginated"]) | 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
@@ -2416,22 +3140,12 @@ 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
-element ever asks for a different page size: a size selector is
-`PaginationSize`, which a consumer puts in the `footer` slot and answers
-themselves. Routing this through `requestChange` would announce an event
-the element never has cause to fire. */
-  "page-size"?: (HelixHeadlessDataTable["pageSize"] | `${number}`) | undefined;
-  /** How many rows a page holds. Zero is every row, which is what "no paging" means.
+  /** The order, as `field:direction`.
 
-**It announces nothing, and that is not an omission.** Nothing in this
-element ever asks for a different page size: a size selector is
-`PaginationSize`, which a consumer puts in the `footer` slot and answers
-themselves. Routing this through `requestChange` would announce an event
-the element never has cause to fire. */
-  pageSize?: (HelixHeadlessDataTable["pageSize"]) | undefined;
+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;
   /** How many rows the whole result has, where this element cannot count them.
 
 Only read in `server` mode, where `rows` is one page and its length says
@@ -2457,13 +3171,6 @@ Off by default. Windowing costs a scroll listener, a measurement per row
 drawn, and a `block-size` on the scrolling box, and a table of twenty rows
 should pay none of them. */
   windowed?: (HelixHeadlessDataTable["windowed"]) | undefined;
-  /** Whether to draw a pagination under the grid.
-
-On by default once a page size is set, because a paged table with no way to
-change pages shows a reader the first twenty rows and no way to know there
-are more. Off for a consumer supplying their own through the `footer` slot,
-which is why the slot replaces this rather than sitting beside it. */
-  paginated?: (HelixHeadlessDataTable["paginated"]) | undefined;
   /** What is said where there are none, and none are coming. */
   "empty-text"?: (HelixHeadlessDataTable["emptyText"]) | undefined;
   /** What is said where there are none, and none are coming. */
@@ -2604,6 +3311,40 @@ window has no room for that width it shows one month until there is. */
   months?: (HelixHeadlessDateInput["months"]) | undefined;
   /** What the field says before a date is in it. */
   placeholder?: (HelixHeadlessDateInput["placeholder"]) | undefined;
+  /** What a reader is told when a range holds more than two dates.
+
+**Every sentence a control raises in the browser's bubble is a property**,
+so a form in another language speaks it. Absent is the control's own
+sentence, in English. */
+  "range-length-message"?: (HelixHeadlessDateInput["rangeLengthMessage"]) | undefined;
+  /** What a reader is told when a range holds more than two dates.
+
+**Every sentence a control raises in the browser's bubble is a property**,
+so a form in another language speaks it. Absent is the control's own
+sentence, in English. */
+  rangeLengthMessage?: (HelixHeadlessDateInput["rangeLengthMessage"]) | undefined;
+  /** What a reader is told when a date is after `max`, with `{max}` filled in
+as the field writes it. */
+  "range-overflow-message"?: (HelixHeadlessDateInput["rangeOverflowMessage"]) | undefined;
+  /** What a reader is told when a date is after `max`, with `{max}` filled in
+as the field writes it. */
+  rangeOverflowMessage?: (HelixHeadlessDateInput["rangeOverflowMessage"]) | undefined;
+  /** What a reader is told when a date is before `min`, with `{min}` filled
+in as the field writes it. */
+  "range-underflow-message"?: (HelixHeadlessDateInput["rangeUnderflowMessage"]) | undefined;
+  /** What a reader is told when a date is before `min`, with `{min}` filled
+in as the field writes it. */
+  rangeUnderflowMessage?: (HelixHeadlessDateInput["rangeUnderflowMessage"]) | undefined;
+  /** What the control removing one date is called, with `{name}` filled in.
+
+**The name goes in**, so a row of them is heard as which one each
+removes rather than as "Remove" said once per date. */
+  "remove-label"?: (HelixHeadlessDateInput["removeLabel"]) | undefined;
+  /** What the control removing one date is called, with `{name}` filled in.
+
+**The name goes in**, so a row of them is heard as which one each
+removes rather than as "Remove" said once per date. */
+  removeLabel?: (HelixHeadlessDateInput["removeLabel"]) | undefined;
   /** How far apart the selectable dates are, in days.
 
 `<input type="date" step>`'s own unit, handed to the calendar this renders
@@ -2639,6 +3380,26 @@ submits nothing and leaves the tab order, and a read-only one submits its
 value and stays reachable, which is what a form showing a value somebody
 else set needs. */
   readOnly?: (HelixHeadlessDateInput["readOnly"]) | undefined;
+  /** What a reader is told when the field holds something the picker cannot
+read: a date that is not one, a time, a color.
+
+**Every sentence a control raises in the browser's bubble is a
+property**, named for the validity flag it reports, so a form in another
+language speaks it. Absent is the family's own sentence, in English,
+which says what the value should look like. */
+  "bad-input-message"?: (HelixHeadlessDateInput["badInputMessage"]) | undefined;
+  /** What a reader is told when the field holds something the picker cannot
+read: a date that is not one, a time, a color.
+
+**Every sentence a control raises in the browser's bubble is a
+property**, named for the validity flag it reports, so a form in another
+language speaks it. Absent is the family's own sentence, in English,
+which says what the value should look like. */
+  badInputMessage?: (HelixHeadlessDateInput["badInputMessage"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessDateInput["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessDateInput["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -2652,10 +3413,6 @@ 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?: (HelixHeadlessDateInput["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixHeadlessDateInput["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixHeadlessDateInput["defaultOpen"]) | undefined;
   /** What the control is called once everything is showing. */
   "collapse-label"?: (HelixHeadlessDateInput["collapseLabel"]) | undefined;
   /** What the control is called once everything is showing. */
@@ -2689,6 +3446,26 @@ a reset should return to. */
   label?: (HelixHeadlessDateInput["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessDateInput["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessDateInput["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessDateInput["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -2759,6 +3536,18 @@ export type HelixHeadlessDatePickerHelixNavigateElementEvent =
   HelixHeadlessDatePickerElementEvent<HelixNavigateEvent>;
 
 export type HelixHeadlessDatePickerVueProps = {
+  /** What a reader is told when the value holds something that is not a date.
+
+**Every sentence a control raises in the browser's bubble is a property**,
+named for the validity flag it reports, so a form in another language
+speaks it. Absent is the control's own sentence, in English. */
+  "bad-input-message"?: (HelixHeadlessDatePicker["badInputMessage"]) | undefined;
+  /** What a reader is told when the value holds something that is not a date.
+
+**Every sentence a control raises in the browser's bubble is a property**,
+named for the validity flag it reports, so a form in another language
+speaks it. Absent is the control's own sentence, in English. */
+  badInputMessage?: (HelixHeadlessDatePicker["badInputMessage"]) | undefined;
   /** Month to open on, where nothing declared one. */
   "default-month"?: (HelixHeadlessDatePicker["defaultMonth"]) | undefined;
   /** Month to open on, where nothing declared one. */
@@ -2779,12 +3568,6 @@ export type HelixHeadlessDatePickerVueProps = {
   invalid?: (HelixHeadlessDatePicker["invalid"]) | undefined;
   /** Accessible name for the grid. */
   label?: (HelixHeadlessDatePicker["label"]) | undefined;
-  /** The month on show, as `YYYY-MM`. Follows `value`, then the current month.
-
-Separate from `value` on purpose, so paging selects nothing and a consumer
-can drive the view. Reading gives the month on show; writing sets it, and
-`default-month` seeds one the calendar keeps until somebody does. */
-  month?: (HelixHeadlessDatePicker["month"]) | undefined;
   /** Locale for month and day names.
 
 Absent uses the runtime's own. */
@@ -2795,6 +3578,12 @@ Absent uses the runtime's own. */
   min?: (HelixHeadlessDatePicker["min"]) | undefined;
   /** How many dates can be held at once. */
   mode?: (HelixHeadlessDatePicker["mode"]) | undefined;
+  /** The month on show, as `YYYY-MM`. Follows `value`, then the current month.
+
+Separate from `value` on purpose, so paging selects nothing and a consumer
+can drive the view. Reading gives the month on show; writing sets it, and
+`default-month` seeds one the calendar keeps until somebody does. */
+  month?: (HelixHeadlessDatePicker["month"]) | undefined;
   /** How many months to show, side by side. */
   months?: (HelixHeadlessDatePicker["months"]) | undefined;
   /** Accessible name for the control that pages forward. */
@@ -2853,6 +3642,10 @@ One is every date and needs no rule, which is why anything below one is
 treated as one rather than as an error: a step of zero would block every
 date including the one already chosen. */
   step?: (HelixHeadlessDatePicker["step"]) | undefined;
+  /** What a reader is told when a date is required and none is chosen. */
+  "value-missing-message"?: (HelixHeadlessDatePicker["valueMissingMessage"]) | undefined;
+  /** What a reader is told when a date is required and none is chosen. */
+  valueMissingMessage?: (HelixHeadlessDatePicker["valueMissingMessage"]) | undefined;
   /** The value the markup declared, which is where a reset returns to. */
   "default-value"?: (HelixHeadlessDatePicker["defaultValue"]) | undefined;
   /** The value the markup declared, which is where a reset returns to. */
@@ -2994,6 +3787,10 @@ A persistent dialog does not ignore that press. It answers it: see
 `refuse`, which is the only way a dialog that will not be dismissed can say
 so at the moment a reader asks. */
   persistent?: (HelixHeadlessDialog["persistent"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessDialog["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessDialog["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -3007,10 +3804,6 @@ 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?: (HelixHeadlessDialog["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixHeadlessDialog["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixHeadlessDialog["defaultOpen"]) | undefined;
   /** What the dialog closed with, the way `<dialog>` reports it.
 
 **The whole point of a `<dialog>` returning a value is lost behind a shadow
@@ -3178,6 +3971,10 @@ default assigned to the property would reflect onto every host and put a
 `placement="end"` into markup no consumer wrote. So what this tier
 guarantees is the absence, and a sheet selects on it. */
   placement?: (HelixHeadlessDrawer["placement"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessDrawer["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessDrawer["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -3191,10 +3988,6 @@ 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?: (HelixHeadlessDrawer["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixHeadlessDrawer["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixHeadlessDrawer["defaultOpen"]) | undefined;
   /** What the dialog closed with, the way `<dialog>` reports it.
 
 **The whole point of a `<dialog>` returning a value is lost behind a shadow
@@ -3338,9 +4131,17 @@ Absent uses the runtime's own. */
   locale?: (HelixHeadlessFileInput["locale"]) | undefined;
   /** Whether more than one file can be chosen. */
   multiple?: (HelixHeadlessFileInput["multiple"]) | undefined;
-  /** What the control removing one file is called, per file. */
+  /** What the control removing one file is called, with `{name}` filled in.
+
+**The name goes in**, so a row of them is heard as which one each
+removes rather than as "Remove" said once per file. A label with no
+`{name}` has it added after it. */
   "remove-label"?: (HelixHeadlessFileInput["removeLabel"]) | undefined;
-  /** What the control removing one file is called, per file. */
+  /** What the control removing one file is called, with `{name}` filled in.
+
+**The name goes in**, so a row of them is heard as which one each
+removes rather than as "Remove" said once per file. A label with no
+`{name}` has it added after it. */
   removeLabel?: (HelixHeadlessFileInput["removeLabel"]) | undefined;
   /** What the trigger reads, where nothing is slotted into it. */
   "trigger-label"?: (HelixHeadlessFileInput["triggerLabel"]) | undefined;
@@ -3354,6 +4155,26 @@ Absent uses the runtime's own. */
   label?: (HelixHeadlessFileInput["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessFileInput["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessFileInput["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessFileInput["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -3596,6 +4417,10 @@ them. */
 
 Not a label: it goes when typing starts. */
   placeholder?: (HelixHeadlessFilterInput["placeholder"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessFilterInput["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessFilterInput["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -3609,10 +4434,6 @@ 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?: (HelixHeadlessFilterInput["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixHeadlessFilterInput["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixHeadlessFilterInput["defaultOpen"]) | undefined;
   /** What the control is called once everything is showing. */
   "collapse-label"?: (HelixHeadlessFilterInput["collapseLabel"]) | undefined;
   /** What the control is called once everything is showing. */
@@ -3646,6 +4467,26 @@ a reset should return to. */
   label?: (HelixHeadlessFilterInput["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessFilterInput["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessFilterInput["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessFilterInput["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -4250,6 +5091,26 @@ a reset should return to. */
   label?: (HelixHeadlessInput["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessInput["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessInput["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessInput["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -4445,6 +5306,10 @@ Ignored once `active` is written. */
 
 Ignored once `active` is written. */
   defaultActive?: (HelixHeadlessLightbox["defaultActive"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessLightbox["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessLightbox["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -4458,10 +5323,6 @@ 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?: (HelixHeadlessLightbox["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixHeadlessLightbox["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixHeadlessLightbox["defaultOpen"]) | undefined;
 };
 
 export type HelixHeadlessLightboxVueEvents = {
@@ -4671,13 +5532,6 @@ point.** The field filters a list rather than collecting a value, so a
 browser offering to fill it with a saved address is competing for the same
 keystrokes as the listbox. A consumer who wants autofill can still ask. */
   autocomplete?: (HelixHeadlessListbox["autocomplete"]) | undefined;
-  /** What the list is narrowed to, if anything.
-
-Filtering hides rather than removes, so nothing about the value changes and
-the list is still the consumer's own elements in their own order. Reading
-gives what is being filtered on; writing declares it theirs, and
-`default-filter` seeds one the list owns. */
-  filter?: (HelixHeadlessListbox["filter"]) | undefined;
   /** What to start narrowed to, where nothing declared it. */
   "default-filter"?: (HelixHeadlessListbox["defaultFilter"]) | undefined;
   /** What to start narrowed to, where nothing declared it. */
@@ -4696,6 +5550,13 @@ and re-declared here only to keep this list's own wording: "No matches" is
 about a filter, and the mixin's "Nothing to show" is about a list that was
 never given anything. */
   emptyText?: (HelixHeadlessListbox["emptyText"]) | undefined;
+  /** What the list is narrowed to, if anything.
+
+Filtering hides rather than removes, so nothing about the value changes and
+the list is still the consumer's own elements in their own order. Reading
+gives what is being filtered on; writing declares it theirs, and
+`default-filter` seeds one the list owns. */
+  filter?: (HelixHeadlessListbox["filter"]) | undefined;
   /** Whether the list renders a field for narrowing itself.
 
 The field lives here rather than in whatever frames the list, because the
@@ -4738,6 +5599,26 @@ a reset should return to. */
   label?: (HelixHeadlessListbox["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessListbox["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessListbox["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessListbox["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -4834,12 +5715,27 @@ that *a* findable control exists, never that it is ours. The methods stay
 public either way, so a consumer drawing their own chrome can still drive
 the surface.
 
-Absent is all three, which is this library's rule that a resting value is
-an attribute's absence, and it is what the stylesheet asks about: the
-layout rules are written against `[controls]:not([controls~="zoom"])`
-rather than the bare negation, or a surface that named no list at all
-would be laid out as though it had dropped everything. */
+Absent is whatever the family rests at, which is this library's rule that
+a resting value is an attribute's absence: all three for a map, whose
+reader may have no other way to move it, and zoom and fullscreen for a
+board, which a reader drags and whose pad took a third of the frame. The
+stylesheet lays the cluster out by which buttons are in it rather than by
+this attribute, so the two defaults need no rule each. */
   controls?: (HelixHeadlessMap["controls"]) | undefined;
+  /** What the group of controls is called, for a reader who meets it.
+
+Absent is the family's own name for it, "Map controls" or "Board
+controls", which names what the controls drive rather than the
+mechanism. Written here to say it in another language, which every other
+string this surface speaks already allowed and this one did not. */
+  "controls-label"?: (HelixHeadlessMap["controlsLabel"]) | undefined;
+  /** What the group of controls is called, for a reader who meets it.
+
+Absent is the family's own name for it, "Map controls" or "Board
+controls", which names what the controls drive rather than the
+mechanism. Written here to say it in another language, which every other
+string this surface speaks already allowed and this one did not. */
+  controlsLabel?: (HelixHeadlessMap["controlsLabel"]) | undefined;
   /** Which corner the controls sit in.
 
 **Configurable because there is no safe default**, which is a collision
@@ -4882,10 +5778,30 @@ reader operates the surface, and chrome that hid itself by default would
 be the component undoing its own argument. Set it for a display nobody
 drives. */
   idleDelay?: (HelixHeadlessMap["idleDelay"]) | undefined;
-  /** What one pan control is called, with `{way}` filled in. */
-  "pan-label"?: (HelixHeadlessMap["panLabel"]) | undefined;
-  /** What one pan control is called, with `{way}` filled in. */
-  panLabel?: (HelixHeadlessMap["panLabel"]) | undefined;
+  /** What the control that pans down is called.
+
+**A label for each way rather than one with the way filled in**, which is
+what this was: `Pan {way}` filled in with `left`, so a page that said it
+in French read out "Déplacer left". The word for a direction is as much
+the translator's as the word for panning, and a language can put it
+anywhere in the phrase. */
+  "pan-down-label"?: (HelixHeadlessMap["panDownLabel"]) | undefined;
+  /** What the control that pans down is called.
+
+**A label for each way rather than one with the way filled in**, which is
+what this was: `Pan {way}` filled in with `left`, so a page that said it
+in French read out "Déplacer left". The word for a direction is as much
+the translator's as the word for panning, and a language can put it
+anywhere in the phrase. */
+  panDownLabel?: (HelixHeadlessMap["panDownLabel"]) | undefined;
+  /** What the control that pans left is called, on screen. */
+  "pan-left-label"?: (HelixHeadlessMap["panLeftLabel"]) | undefined;
+  /** What the control that pans left is called, on screen. */
+  panLeftLabel?: (HelixHeadlessMap["panLeftLabel"]) | undefined;
+  /** What the control that pans right is called, on screen. */
+  "pan-right-label"?: (HelixHeadlessMap["panRightLabel"]) | undefined;
+  /** What the control that pans right is called, on screen. */
+  panRightLabel?: (HelixHeadlessMap["panRightLabel"]) | undefined;
   /** How far one press moves the view, as a fraction of what is on screen.
 
 A fraction rather than a distance, because this surface does not know the
@@ -4898,6 +5814,10 @@ A fraction rather than a distance, because this surface does not know the
 scale of what is inside it: a quarter of the viewport is the same gesture
 at any zoom, and a consumer who wants their own units multiplies by them. */
   panStep?: (HelixHeadlessMap["panStep"]) | undefined;
+  /** What the control that pans up is called. */
+  "pan-up-label"?: (HelixHeadlessMap["panUpLabel"]) | undefined;
+  /** What the control that pans up is called. */
+  panUpLabel?: (HelixHeadlessMap["panUpLabel"]) | undefined;
   /** What the control that zooms in is called. */
   "zoom-in-label"?: (HelixHeadlessMap["zoomInLabel"]) | undefined;
   /** What the control that zooms in is called. */
@@ -5013,6 +5933,10 @@ question; borrowing it here would put a third meaning on it.
 a word and a band under a header are two arrangements this family has, and
 no other family is being asked the same question. */
   variant?: (HelixHeadlessMegamenu["variant"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessMegamenu["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessMegamenu["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -5026,10 +5950,6 @@ 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?: (HelixHeadlessMegamenu["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixHeadlessMegamenu["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixHeadlessMegamenu["defaultOpen"]) | undefined;
 };
 
 export type HelixHeadlessMegamenuVueEvents = {
@@ -5171,6 +6091,10 @@ say that without the component knowing what a row looks like. */
   "loading-text"?: (HelixHeadlessMenu["loadingText"]) | undefined;
   /** What is said while they are on their way. */
   loadingText?: (HelixHeadlessMenu["loadingText"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessMenu["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessMenu["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -5184,10 +6108,6 @@ 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?: (HelixHeadlessMenu["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixHeadlessMenu["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixHeadlessMenu["defaultOpen"]) | undefined;
 };
 
 export type HelixHeadlessMenuVueEvents = {
@@ -5334,6 +6254,10 @@ unsayable. Left off, it is the number of rows. */
 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 markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessNotificationGroup["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessNotificationGroup["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -5347,10 +6271,6 @@ 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;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixHeadlessNotificationGroup["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixHeadlessNotificationGroup["defaultOpen"]) | undefined;
 };
 
 export type HelixHeadlessNotificationGroupVueEvents = {
@@ -5380,6 +6300,14 @@ is the shape that needs no translation at either end. Left unset the item
 shows no timestamp rather than showing the epoch, which is what parsing an
 empty string would give. */
   at?: (HelixHeadlessNotification["at"]) | undefined;
+  /** State to open with, where nothing declared one. */
+  "default-read"?: (HelixHeadlessNotification["defaultRead"]) | undefined;
+  /** State to open with, where nothing declared one. */
+  defaultRead?: (HelixHeadlessNotification["defaultRead"]) | undefined;
+  /** Locale for the timestamp.
+
+Empty is the runtime's own. */
+  locale?: (HelixHeadlessNotification["locale"]) | undefined;
   /** Whether the reader has seen it.
 
 Set it and this element defers: a reader's click fires `helix-read` and
@@ -5394,14 +6322,6 @@ as a hydration mismatch, and which a copy of the serialized element
 re-parses as a declaration. `:state(read)` is what the stylesheet reads.
 `hydration.dom.spec.ts` holds it. */
   read?: (HelixHeadlessNotification["read"]) | undefined;
-  /** State to open with, where nothing declared one. */
-  "default-read"?: (HelixHeadlessNotification["defaultRead"]) | undefined;
-  /** State to open with, where nothing declared one. */
-  defaultRead?: (HelixHeadlessNotification["defaultRead"]) | undefined;
-  /** Locale for the timestamp.
-
-Empty is the runtime's own. */
-  locale?: (HelixHeadlessNotification["locale"]) | undefined;
   /** Whether it offers a control to take it away. */
   dismissible?: (HelixHeadlessNotification["dismissible"]) | undefined;
   /** Accessible name for that control.
@@ -5490,6 +6410,20 @@ lets autofill work at all. Hardcoding `off` here is what stops a reader
 having a birthday or a postal code filled in for them, with no way for a
 consumer to ask for it. */
   autocomplete?: (HelixHeadlessNumberInput["autocomplete"]) | undefined;
+  /** What a reader is told when the field holds something that is not a number.
+
+**Every sentence a control raises in the browser's bubble is a property**,
+named for the validity flag it reports, so a form in another language
+speaks it: `feedback` replaces the message under the field and does not
+reach the bubble. Absent is the control's own sentence, in English. */
+  "bad-input-message"?: (HelixHeadlessNumberInput["badInputMessage"]) | undefined;
+  /** What a reader is told when the field holds something that is not a number.
+
+**Every sentence a control raises in the browser's bubble is a property**,
+named for the validity flag it reports, so a form in another language
+speaks it: `feedback` replaces the message under the field and does not
+reach the bubble. Absent is the control's own sentence, in English. */
+  badInputMessage?: (HelixHeadlessNumberInput["badInputMessage"]) | undefined;
   /** Accessible name for the control that steps down. */
   "decrement-label"?: (HelixHeadlessNumberInput["decrementLabel"]) | undefined;
   /** Accessible name for the control that steps down. */
@@ -5522,6 +6456,14 @@ Absent has no floor. */
 
 Not a label: it goes when typing starts. */
   placeholder?: (HelixHeadlessNumberInput["placeholder"]) | undefined;
+  /** What a reader is told when the number is above `max`, with `{max}` filled in. */
+  "range-overflow-message"?: (HelixHeadlessNumberInput["rangeOverflowMessage"]) | undefined;
+  /** What a reader is told when the number is above `max`, with `{max}` filled in. */
+  rangeOverflowMessage?: (HelixHeadlessNumberInput["rangeOverflowMessage"]) | undefined;
+  /** What a reader is told when the number is below `min`, with `{min}` filled in. */
+  "range-underflow-message"?: (HelixHeadlessNumberInput["rangeUnderflowMessage"]) | undefined;
+  /** What a reader is told when the number is below `min`, with `{min}` filled in. */
+  rangeUnderflowMessage?: (HelixHeadlessNumberInput["rangeUnderflowMessage"]) | undefined;
   /** Whether the field refuses input while still submitting its value. */
   readonly?: (HelixHeadlessNumberInput["readOnly"]) | undefined;
   /** Whether the field refuses input while still submitting its value. */
@@ -5556,6 +6498,26 @@ a reset should return to. */
   label?: (HelixHeadlessNumberInput["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessNumberInput["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessNumberInput["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessNumberInput["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -5609,6 +6571,22 @@ export type HelixHeadlessObjectInspectorHelixCopyElementEvent =
   HelixHeadlessObjectInspectorElementEvent<HelixCopyEvent>;
 
 export type HelixHeadlessObjectInspectorVueProps = {
+  /** What the copy control is called on a row with a key, with the key as
+`{name}`.
+
+**Every word the inspector speaks is a property**, so a page in another
+language hears its own rather than English around its own keys. */
+  "copy-label"?: (HelixHeadlessObjectInspector["copyLabel"]) | undefined;
+  /** What the copy control is called on a row with a key, with the key as
+`{name}`.
+
+**Every word the inspector speaks is a property**, so a page in another
+language hears its own rather than English around its own keys. */
+  copyLabel?: (HelixHeadlessObjectInspector["copyLabel"]) | undefined;
+  /** What the copy control is called where there is no key, on the value itself. */
+  "copy-value-label"?: (HelixHeadlessObjectInspector["copyValueLabel"]) | undefined;
+  /** What the copy control is called where there is no key, on the value itself. */
+  copyValueLabel?: (HelixHeadlessObjectInspector["copyValueLabel"]) | undefined;
   /** How many levels start open.
 
 One by default: the root is open and everything under it closed, so a
@@ -5881,21 +6859,6 @@ look, so no rule selects on it, and the house rule is that reflection
 exists for selectors: an unread reflected attribute is one more thing
 written onto a host at upgrade that a server's output never had. */
   ends?: (HelixHeadlessPagination["ends"]) | undefined;
-  /** The page on show, one-based.
-
-An accessor pair, the same shape as the calendar's `month`. Reading gives
-the page on show; writing sets it, and `default-page` seeds one the element
-keeps until somebody does.
-
-**Clamped on the way out, because "the page on show" is what it says it
-gives.** Returning whatever was written means `default-page="99"` on a
-ten-page result renders page 10, marks page 10 with `aria-current`, and
-reports 99, so a consumer syncing their query from this reads a page that
-does not exist while the control in front of them says otherwise. Not a
-far-fetched value: it is a bookmarked link after the result shrank.
-
-Rounded here too, so `2.7` reads as the 2 it renders. */
-  page?: (HelixHeadlessPagination["page"]) | undefined;
   /** Accessible name for the control that jumps to the first page. */
   "first-label"?: (HelixHeadlessPagination["firstLabel"]) | undefined;
   /** Accessible name for the control that jumps to the first page. */
@@ -5932,6 +6895,21 @@ different address from `?page=1234`. */
   "next-label"?: (HelixHeadlessPagination["nextLabel"]) | undefined;
   /** Accessible name for the control that moves forward. */
   nextLabel?: (HelixHeadlessPagination["nextLabel"]) | undefined;
+  /** The page on show, one-based.
+
+An accessor pair, the same shape as the calendar's `month`. Reading gives
+the page on show; writing sets it, and `default-page` seeds one the element
+keeps until somebody does.
+
+**Clamped on the way out, because "the page on show" is what it says it
+gives.** Returning whatever was written means `default-page="99"` on a
+ten-page result renders page 10, marks page 10 with `aria-current`, and
+reports 99, so a consumer syncing their query from this reads a page that
+does not exist while the control in front of them says otherwise. Not a
+far-fetched value: it is a bookmarked link after the result shrank.
+
+Rounded here too, so `2.7` reads as the 2 it renders. */
+  page?: (HelixHeadlessPagination["page"]) | undefined;
   /** Accessible name for one page, with `{page}` and `{pages}` filled in. */
   "page-label"?: (HelixHeadlessPagination["pageLabel"]) | undefined;
   /** Accessible name for one page, with `{page}` and `{pages}` filled in. */
@@ -6007,12 +6985,6 @@ export type HelixHeadlessPaginationSizeVueProps = {
   "default-value"?: (HelixHeadlessPaginationSize["defaultValue"] | `${number}`) | undefined;
   /** Size to start on, where nothing declared one. */
   defaultValue?: (HelixHeadlessPaginationSize["defaultValue"]) | undefined;
-  /** The size in force.
-
-Reading gives the real one; writing declares it the consumer's, and
-`default-value` seeds one this element owns. Same accessor pair as
-`Pagination.page` and the calendar's `month`. */
-  value?: (HelixHeadlessPaginationSize["value"]) | undefined;
   /** The words beside the control. */
   label?: (HelixHeadlessPaginationSize["label"]) | undefined;
   /** Locale for the numbers.
@@ -6025,6 +6997,12 @@ A string rather than an array, so the whole control is expressible in
 markup and survives a server render. Anything that is not a positive number
 is dropped rather than rendered as an option that cannot mean anything. */
   sizes?: (HelixHeadlessPaginationSize["sizes"]) | undefined;
+  /** The size in force.
+
+Reading gives the real one; writing declares it the consumer's, and
+`default-value` seeds one this element owns. Same accessor pair as
+`Pagination.page` and the calendar's `month`. */
+  value?: (HelixHeadlessPaginationSize["value"]) | undefined;
 };
 
 export type HelixHeadlessPaginationSizeVueEvents = {
@@ -6105,6 +7083,12 @@ Empty by default, because a row of boxes already reads as a row of boxes. */
   readonly?: (HelixHeadlessPinInput["readOnly"]) | undefined;
   /** Whether the boxes refuse input while still submitting their value. */
   readOnly?: (HelixHeadlessPinInput["readOnly"]) | undefined;
+  /** What a reader is told when the code is started and not finished, with
+`{length}` filled in. Absent is the control's own sentence, in English. */
+  "too-short-message"?: (HelixHeadlessPinInput["tooShortMessage"]) | undefined;
+  /** What a reader is told when the code is started and not finished, with
+`{length}` filled in. Absent is the control's own sentence, in English. */
+  tooShortMessage?: (HelixHeadlessPinInput["tooShortMessage"]) | undefined;
   /** What a box accepts, which decides the keyboard a phone offers.
 
 `numeric` and `alphanumeric` also refuse anything else on the way in,
@@ -6145,6 +7129,26 @@ a reset should return to. */
   label?: (HelixHeadlessPinInput["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessPinInput["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessPinInput["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessPinInput["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -6205,6 +7209,10 @@ export type HelixHeadlessPopoverVueProps = {
 
 It moves if that side does not fit. */
   placement?: (HelixHeadlessPopover["placement"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessPopover["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessPopover["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -6218,10 +7226,6 @@ 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?: (HelixHeadlessPopover["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixHeadlessPopover["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixHeadlessPopover["defaultOpen"]) | undefined;
 };
 
 export type HelixHeadlessPopoverVueEvents = {
@@ -6389,6 +7393,26 @@ a reset should return to. */
   label?: (HelixHeadlessRadioGroup["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessRadioGroup["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessRadioGroup["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessRadioGroup["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -6619,6 +7643,26 @@ a reset should return to. */
   label?: (HelixHeadlessRating["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessRating["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessRating["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessRating["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -6744,6 +7788,10 @@ consumer wiring the same flag twice. */
   multiple?: (HelixHeadlessSelect["multiple"]) | undefined;
   /** Shown on the trigger while nothing is chosen. */
   placeholder?: (HelixHeadlessSelect["placeholder"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessSelect["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessSelect["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -6757,10 +7805,6 @@ 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?: (HelixHeadlessSelect["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixHeadlessSelect["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixHeadlessSelect["defaultOpen"]) | undefined;
   /** The value the markup declared, which is where a reset returns to. */
   "default-value"?: (HelixHeadlessSelect["defaultValue"]) | undefined;
   /** The value the markup declared, which is where a reset returns to. */
@@ -6780,6 +7824,26 @@ a reset should return to. */
   label?: (HelixHeadlessSelect["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessSelect["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessSelect["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessSelect["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -6881,8 +7945,28 @@ is the honest picture of the range being offered. */
   markers?: (HelixHeadlessSlider["markers"]) | undefined;
   /** The largest value the reader can choose. */
   max?: (HelixHeadlessSlider["max"]) | undefined;
+  /** What the upper thumb of a range is called, after the slider's own label.
+
+**Named with the label rather than instead of it.** Each thumb was
+`aria-label="${label} maximum"`, which overrode the `<label>` and read the
+`label` string only, so a slider named by a slotted label or `aria-label`
+had thumbs called "minimum" and "maximum" and nothing else. The word is a
+property, like every other word a control speaks. */
+  "maximum-label"?: (HelixHeadlessSlider["maximumLabel"]) | undefined;
+  /** What the upper thumb of a range is called, after the slider's own label.
+
+**Named with the label rather than instead of it.** Each thumb was
+`aria-label="${label} maximum"`, which overrode the `<label>` and read the
+`label` string only, so a slider named by a slotted label or `aria-label`
+had thumbs called "minimum" and "maximum" and nothing else. The word is a
+property, like every other word a control speaks. */
+  maximumLabel?: (HelixHeadlessSlider["maximumLabel"]) | undefined;
   /** The smallest value the reader can choose. */
   min?: (HelixHeadlessSlider["min"]) | undefined;
+  /** What the lower thumb of a range is called, after the slider's own label. */
+  "minimum-label"?: (HelixHeadlessSlider["minimumLabel"]) | undefined;
+  /** What the lower thumb of a range is called, after the slider's own label. */
+  minimumLabel?: (HelixHeadlessSlider["minimumLabel"]) | undefined;
   /** Which way the track runs, `vertical` standing it on end.
 
 For a level rather than a quantity: a fader, a channel, anything a reader
@@ -6925,6 +8009,26 @@ a reset should return to. */
   label?: (HelixHeadlessSlider["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessSlider["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessSlider["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessSlider["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -7091,6 +8195,10 @@ export type HelixHeadlessSpeedDialVueProps = {
 Up by default, because the control this hangs off is usually docked to the
 bottom of the window and there is nothing below it to fan into. */
   placement?: (HelixHeadlessSpeedDial["placement"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessSpeedDial["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessSpeedDial["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -7104,10 +8212,6 @@ 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?: (HelixHeadlessSpeedDial["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixHeadlessSpeedDial["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixHeadlessSpeedDial["defaultOpen"]) | undefined;
 };
 
 export type HelixHeadlessSpeedDialVueEvents = {
@@ -7134,6 +8238,32 @@ export type HelixHeadlessSplitterHelixBeforeResizeElementEvent =
   HelixHeadlessSplitterElementEvent<HelixBeforeResizeEvent>;
 
 export type HelixHeadlessSplitterVueProps = {
+  /** Which pane is shut, if either.
+
+The same accessor pair as `position`, and deliberately a second state
+rather than a reading of the first. A pane shut by dragging the divider to
+the edge and a pane shut on purpose look identical in geometry and are not
+the same thing: only the second knows where to go back to. Kept apart, the
+open position is simply the one collapsing never overwrote, so restoring
+needs no memory of its own.
+
+It overrides `min` and `max`, which is the point of it. Those keep a sliver
+of a pane during a drag; this is the thing that says the sliver can go. */
+  collapsed?: (HelixHeadlessSplitter["collapsed"]) | undefined;
+  /** What the divider says while a pane is shut, in place of a number.
+
+**A shut pane is off the scale the divider reports**, which is `min` to
+`max`, the sliver a drag keeps. The divider said a value outside its own
+range, 0 against a minimum of 20, which reads as broken rather than as
+shut. While shut it reports the whole 0 to 100 it sits on and says this. */
+  "collapsed-label"?: (HelixHeadlessSplitter["collapsedLabel"]) | undefined;
+  /** What the divider says while a pane is shut, in place of a number.
+
+**A shut pane is off the scale the divider reports**, which is `min` to
+`max`, the sliver a drag keeps. The divider said a value outside its own
+range, 0 against a minimum of 20, which reads as broken rather than as
+shut. While shut it reports the whole 0 to 100 it sits on and says this. */
+  collapsedLabel?: (HelixHeadlessSplitter["collapsedLabel"]) | undefined;
   /** How much of a shut pane is still shown, as a percentage.
 
 Zero by default, which is a pane fully gone. A tab strip or a title bar
@@ -7148,28 +8278,10 @@ that should survive its own collapse says how much of itself to keep, and
 only whoever put it there knows that, which is the same reason `min` is a
 consumer's to set. */
   collapsedSize?: (HelixHeadlessSplitter["collapsedSize"]) | undefined;
-  /** Where the divider sits, as a percentage of the whole.
-
-Reading gives where it is; writing declares it the consumer's, and
-`default-position` seeds one this element owns. The same accessor pair
-`Pagination.page` and the calendar's `month` carry. */
-  position?: (HelixHeadlessSplitter["position"]) | undefined;
   /** Accessible name for the handle where two dividers cross. */
   "corner-label"?: (HelixHeadlessSplitter["cornerLabel"]) | undefined;
   /** Accessible name for the handle where two dividers cross. */
   cornerLabel?: (HelixHeadlessSplitter["cornerLabel"]) | undefined;
-  /** Which pane is shut, if either.
-
-The same accessor pair as `position`, and deliberately a second state
-rather than a reading of the first. A pane shut by dragging the divider to
-the edge and a pane shut on purpose look identical in geometry and are not
-the same thing: only the second knows where to go back to. Kept apart, the
-open position is simply the one collapsing never overwrote, so restoring
-needs no memory of its own.
-
-It overrides `min` and `max`, which is the point of it. Those keep a sliver
-of a pane during a drag; this is the thing that says the sliver can go. */
-  collapsed?: (HelixHeadlessSplitter["collapsed"]) | undefined;
   /** Which pane starts shut, where nothing declared it. */
   "default-collapsed"?: (HelixHeadlessSplitter["defaultCollapsed"]) | undefined;
   /** Which pane starts shut, where nothing declared it. */
@@ -7225,6 +8337,12 @@ no room for two panes side by side, and a media query would hand it the
 desktop branch. A `ResizeObserver` on the host asks the only question that
 has an honest answer. */
   orientation?: (HelixHeadlessSplitter["orientation"]) | undefined;
+  /** Where the divider sits, as a percentage of the whole.
+
+Reading gives where it is; writing declares it the consumer's, and
+`default-position` seeds one this element owns. The same accessor pair
+`Pagination.page` and the calendar's `month` carry. */
+  position?: (HelixHeadlessSplitter["position"]) | undefined;
   /** How far one arrow press moves it, as a percentage. */
   step?: (HelixHeadlessSplitter["step"]) | undefined;
 };
@@ -7400,6 +8518,26 @@ stylesheets. */
   label?: (HelixHeadlessSwitch["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessSwitch["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessSwitch["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessSwitch["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -7468,6 +8606,18 @@ 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;
+  /** What the grip that moves the column is called, with the heading's words as
+`{name}`.
+
+**Every word a column speaks is a property**, so a table in another
+language hears its own rather than English around its own headings. */
+  "move-label"?: (HelixHeadlessTableColumn["moveLabel"]) | undefined;
+  /** What the grip that moves the column is called, with the heading's words as
+`{name}`.
+
+**Every word a column speaks is a property**, so a table in another
+language hears its own rather than English around its own headings. */
+  moveLabel?: (HelixHeadlessTableColumn["moveLabel"]) | 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
@@ -7475,6 +8625,12 @@ 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;
+  /** What the separator that resizes the column is called, with the heading's
+words as `{name}`. */
+  "resize-label"?: (HelixHeadlessTableColumn["resizeLabel"]) | undefined;
+  /** What the separator that resizes the column is called, with the heading's
+words as `{name}`. */
+  resizeLabel?: (HelixHeadlessTableColumn["resizeLabel"]) | undefined;
   /** Whether a reader may reorder the set by this column.
 
 Ignored without a `field`, and silently: a column with nothing to sort by
@@ -7569,6 +8725,10 @@ line, so a column holding sentences rather than values wants
 `width="minmax(0, 1fr)"` to opt back into wrapping. A headless consumer owns
 the overflow either way, that being paint, and gets the honest track list. */
   width?: (HelixHeadlessTableColumn["width"]) | undefined;
+  /** How the separator reads out the column's width, with `{width}` filled in. */
+  "width-label"?: (HelixHeadlessTableColumn["widthLabel"]) | undefined;
+  /** How the separator reads out the column's width, with `{width}` filled in. */
+  widthLabel?: (HelixHeadlessTableColumn["widthLabel"]) | undefined;
   /** How to read the cell, where the field alone will not do.
 
 A property and not an attribute, because it is a function. Set it from a Lit
@@ -7896,6 +9056,26 @@ a reset should return to. */
   label?: (HelixHeadlessTextarea["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessTextarea["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessTextarea["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessTextarea["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -7987,6 +9167,40 @@ on why a wheel cannot do either. */
   mode?: (HelixHeadlessTimeInput["mode"]) | undefined;
   /** What the field says before a time is in it. */
   placeholder?: (HelixHeadlessTimeInput["placeholder"]) | undefined;
+  /** What a reader is told when a range holds more than two times.
+
+**Every sentence a control raises in the browser's bubble is a property**,
+so a form in another language speaks it. Absent is the control's own
+sentence, in English. */
+  "range-length-message"?: (HelixHeadlessTimeInput["rangeLengthMessage"]) | undefined;
+  /** What a reader is told when a range holds more than two times.
+
+**Every sentence a control raises in the browser's bubble is a property**,
+so a form in another language speaks it. Absent is the control's own
+sentence, in English. */
+  rangeLengthMessage?: (HelixHeadlessTimeInput["rangeLengthMessage"]) | undefined;
+  /** What a reader is told when a time is after `max`, with `{max}` filled in
+as the field writes it. */
+  "range-overflow-message"?: (HelixHeadlessTimeInput["rangeOverflowMessage"]) | undefined;
+  /** What a reader is told when a time is after `max`, with `{max}` filled in
+as the field writes it. */
+  rangeOverflowMessage?: (HelixHeadlessTimeInput["rangeOverflowMessage"]) | undefined;
+  /** What a reader is told when a time is before `min`, with `{min}` filled
+in as the field writes it. */
+  "range-underflow-message"?: (HelixHeadlessTimeInput["rangeUnderflowMessage"]) | undefined;
+  /** What a reader is told when a time is before `min`, with `{min}` filled
+in as the field writes it. */
+  rangeUnderflowMessage?: (HelixHeadlessTimeInput["rangeUnderflowMessage"]) | undefined;
+  /** What the control removing one time is called, with `{name}` filled in.
+
+**The name goes in**, so a row of them is heard as which one each
+removes rather than as "Remove" said once per time. */
+  "remove-label"?: (HelixHeadlessTimeInput["removeLabel"]) | undefined;
+  /** What the control removing one time is called, with `{name}` filled in.
+
+**The name goes in**, so a row of them is heard as which one each
+removes rather than as "Remove" said once per time. */
+  removeLabel?: (HelixHeadlessTimeInput["removeLabel"]) | undefined;
   /** How far apart the offered times are, in minutes. */
   step?: (HelixHeadlessTimeInput["step"]) | undefined;
   /** Whether the field writes the time out, or holds the value as it is.
@@ -8045,6 +9259,26 @@ submits nothing and leaves the tab order, and a read-only one submits its
 value and stays reachable, which is what a form showing a value somebody
 else set needs. */
   readOnly?: (HelixHeadlessTimeInput["readOnly"]) | undefined;
+  /** What a reader is told when the field holds something the picker cannot
+read: a date that is not one, a time, a color.
+
+**Every sentence a control raises in the browser's bubble is a
+property**, named for the validity flag it reports, so a form in another
+language speaks it. Absent is the family's own sentence, in English,
+which says what the value should look like. */
+  "bad-input-message"?: (HelixHeadlessTimeInput["badInputMessage"]) | undefined;
+  /** What a reader is told when the field holds something the picker cannot
+read: a date that is not one, a time, a color.
+
+**Every sentence a control raises in the browser's bubble is a
+property**, named for the validity flag it reports, so a form in another
+language speaks it. Absent is the family's own sentence, in English,
+which says what the value should look like. */
+  badInputMessage?: (HelixHeadlessTimeInput["badInputMessage"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessTimeInput["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessTimeInput["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -8058,10 +9292,6 @@ 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?: (HelixHeadlessTimeInput["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixHeadlessTimeInput["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixHeadlessTimeInput["defaultOpen"]) | undefined;
   /** What the control is called once everything is showing. */
   "collapse-label"?: (HelixHeadlessTimeInput["collapseLabel"]) | undefined;
   /** What the control is called once everything is showing. */
@@ -8095,6 +9325,26 @@ a reset should return to. */
   label?: (HelixHeadlessTimeInput["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessTimeInput["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessTimeInput["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessTimeInput["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -8158,6 +9408,18 @@ export type HelixHeadlessTimePickerHelixBeforeChangeElementEvent =
   HelixHeadlessTimePickerElementEvent<HelixBeforeChangeEvent>;
 
 export type HelixHeadlessTimePickerVueProps = {
+  /** What a reader is told when the value holds something that is not a time.
+
+**Every sentence a control raises in the browser's bubble is a property**,
+named for the validity flag it reports, so a form in another language
+speaks it. Absent is the control's own sentence, in English. */
+  "bad-input-message"?: (HelixHeadlessTimePicker["badInputMessage"]) | undefined;
+  /** What a reader is told when the value holds something that is not a time.
+
+**Every sentence a control raises in the browser's bubble is a property**,
+named for the validity flag it reports, so a form in another language
+speaks it. Absent is the control's own sentence, in English. */
+  badInputMessage?: (HelixHeadlessTimePicker["badInputMessage"]) | undefined;
   /** Times that cannot be chosen, comma separated, as `HH:mm`.
 
 The counterpart to Date Picker's `disable-dates`, and it exists for the same
@@ -8248,6 +9510,10 @@ Fifteen, which is four rows an hour and ninety-six in a day: enough that a
 reader scrolls rather than hunts, and few enough that the list is a list.
 Anything under five is a thousand rows and wants a field instead. */
   step?: (HelixHeadlessTimePicker["step"]) | undefined;
+  /** What a reader is told when a time is required and none is chosen. */
+  "value-missing-message"?: (HelixHeadlessTimePicker["valueMissingMessage"]) | undefined;
+  /** What a reader is told when a time is required and none is chosen. */
+  valueMissingMessage?: (HelixHeadlessTimePicker["valueMissingMessage"]) | undefined;
   /** Whether the times are one list or a column each.
 
 `list` is the default and offers whole times, which is what a product with
@@ -8366,10 +9632,6 @@ export type HelixHeadlessToastItemVueProps = {
 Read once when the item is first rendered. Changing it afterwards does not
 restart a message the reader is already partway through. */
   duration?: (HelixHeadlessToastItem["duration"]) | undefined;
-  /** What kind of message it is, which picks the mark and its name.
-
-A subset of the tone axis: a toast reports a status and never a brand role. */
-  tone?: (HelixHeadlessToastItem["tone"]) | undefined;
   /** Whether the message is still showing.
 
 The item always applies: it goes when it is asked to, having announced
@@ -8382,6 +9644,10 @@ only one starting state that makes sense: a message that has been rendered
 is showing. An attribute whose only legal value is the default is an
 attribute nobody can use. */
   open?: (HelixHeadlessToastItem["open"]) | undefined;
+  /** What kind of message it is, which picks the mark and its name.
+
+A subset of the tone axis: a toast reports a status and never a brand role. */
+  tone?: (HelixHeadlessToastItem["tone"]) | undefined;
   /** Whether it offers a control to take it away. */
   dismissible?: (HelixHeadlessToastItem["dismissible"]) | undefined;
   /** Accessible name for that control.
@@ -8511,6 +9777,26 @@ a reset should return to. */
   label?: (HelixHeadlessToggleGroup["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixHeadlessToggleGroup["required"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  "value-missing-message"?: (HelixHeadlessToggleGroup["valueMissingMessage"]) | undefined;
+  /** What a reader is told when the field is required and empty, where the
+page says.
+
+**Absent, or empty, is the control's own sentence**, "Choose one to continue." on a
+set and the browser's own on a text field, which the browser writes in
+the reader's language. Every other word a control speaks is a property,
+and this one was the English a form in another language still spoke in
+the bubble it raises on submit: `feedback` replaces the message under
+the field and does not reach that one. */
+  valueMissingMessage?: (HelixHeadlessToggleGroup["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -8710,6 +9996,10 @@ Clamping is on the cross axis only, which is what makes this safe to point
 at a box the bubble genuinely does not fit inside. See `within` on
 `FloatingController` for what happens if it is applied to the rest. */
   within?: (HelixHeadlessTooltip["within"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessTooltip["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessTooltip["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -8723,10 +10013,6 @@ 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?: (HelixHeadlessTooltip["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixHeadlessTooltip["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixHeadlessTooltip["defaultOpen"]) | undefined;
 };
 
 export type HelixHeadlessTooltipVueEvents = {
@@ -8761,6 +10047,14 @@ export type HelixHeadlessTourVueProps = {
   "back-label"?: (HelixHeadlessTour["backLabel"]) | undefined;
   /** Label for the control that goes back, handed to every stop. */
   backLabel?: (HelixHeadlessTour["backLabel"]) | undefined;
+  /** Stop to start on, where nothing declared one. */
+  "default-index"?: (HelixHeadlessTour["defaultIndex"] | `${number}`) | undefined;
+  /** Stop to start on, where nothing declared one. */
+  defaultIndex?: (HelixHeadlessTour["defaultIndex"]) | undefined;
+  /** Label for the control that goes on from the last stop. */
+  "done-label"?: (HelixHeadlessTour["doneLabel"]) | undefined;
+  /** Label for the control that goes on from the last stop. */
+  doneLabel?: (HelixHeadlessTour["doneLabel"]) | undefined;
   /** Which stop the reader is on.
 
 **Moved through `requestChange`, never by assignment from `move`.** That
@@ -8772,14 +10066,6 @@ The shape is `Carousel`'s, which is the nearest thing in the library: a
 `default-index` for markup that only seeds and a held state that is
 `undefined` until somebody sets one. */
   index?: (HelixHeadlessTour["index"]) | undefined;
-  /** Stop to start on, where nothing declared one. */
-  "default-index"?: (HelixHeadlessTour["defaultIndex"] | `${number}`) | undefined;
-  /** Stop to start on, where nothing declared one. */
-  defaultIndex?: (HelixHeadlessTour["defaultIndex"]) | undefined;
-  /** Label for the control that goes on from the last stop. */
-  "done-label"?: (HelixHeadlessTour["doneLabel"]) | undefined;
-  /** Label for the control that goes on from the last stop. */
-  doneLabel?: (HelixHeadlessTour["doneLabel"]) | undefined;
   /** Accessible name for the run, such as "Getting started". */
   label?: (HelixHeadlessTour["label"]) | undefined;
   /** Label for the control that goes on. */
@@ -8901,6 +10187,10 @@ row is not part of the tree React hydrates. */
   target?: (HelixHeadlessTreeItem["target"]) | undefined;
   /** Identifies the item to the consumer, carried in `helix-select`. */
   value?: (HelixHeadlessTreeItem["value"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessTreeItem["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessTreeItem["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -8914,10 +10204,6 @@ 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?: (HelixHeadlessTreeItem["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixHeadlessTreeItem["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixHeadlessTreeItem["defaultOpen"]) | undefined;
   /** Depth from the root, counted by the tree so indentation needs no CSS nesting.
 
 **Read rather than written, and no attribute at all.** The tree counts the
@@ -9191,6 +10477,22 @@ the browser's policy and not this element's, and `play()` already swallows
 the refusal: what follows a refused autoplay is a paused player showing its
 start control, which is the correct thing to be looking at. */
   autoplay?: (HelixHeadlessVideo["autoplay"]) | undefined;
+  /** What the captions control is called where the video has one track, which it switches on and off.
+
+**Every word this player speaks is a property**, so a page in another
+language hears its own: the play, pause, loading and error labels were,
+and the rest of the bar read out in English beside them. */
+  "captions-label"?: (HelixHeadlessVideo["captionsLabel"]) | undefined;
+  /** What the captions control is called where the video has one track, which it switches on and off.
+
+**Every word this player speaks is a property**, so a page in another
+language hears its own: the play, pause, loading and error labels were,
+and the rest of the bar read out in English beside them. */
+  captionsLabel?: (HelixHeadlessVideo["captionsLabel"]) | undefined;
+  /** The row that turns captions off, where the video has several tracks to choose from. */
+  "captions-off-label"?: (HelixHeadlessVideo["captionsOffLabel"]) | undefined;
+  /** The row that turns captions off, where the video has several tracks to choose from. */
+  captionsOffLabel?: (HelixHeadlessVideo["captionsOffLabel"]) | undefined;
   /** Whether the browser draws the controls instead of this element.
 
 A fallback rather than a default. Two bars over one video is worse than
@@ -9228,6 +10530,10 @@ meaning something else. */
   disableremoteplayback?: (HelixHeadlessVideo["disableRemotePlayback"]) | undefined;
   /** Whether the browser may offer playback on a remote device. */
   disableRemotePlayback?: (HelixHeadlessVideo["disableRemotePlayback"]) | undefined;
+  /** What the control that saves the file is called. */
+  "download-label"?: (HelixHeadlessVideo["downloadLabel"]) | undefined;
+  /** What the control that saves the file is called. */
+  downloadLabel?: (HelixHeadlessVideo["downloadLabel"]) | undefined;
   /** And what they are told when it will not play at all. */
   "error-label"?: (HelixHeadlessVideo["errorLabel"]) | undefined;
   /** And what they are told when it will not play at all. */
@@ -9292,6 +10598,22 @@ ours to promise: the attribute is ignored cross-origin, so a file served
 from somewhere else opens rather than saves, which is the browser's rule
 and not something a player can work around. */
   extraControls?: (HelixHeadlessVideo["extraControls"]) | undefined;
+  /** What the control that skips ahead is called, with `{seconds}` filled in. */
+  "forward-label"?: (HelixHeadlessVideo["forwardLabel"]) | undefined;
+  /** What the control that skips ahead is called, with `{seconds}` filled in. */
+  forwardLabel?: (HelixHeadlessVideo["forwardLabel"]) | undefined;
+  /** What the control that fills the screen is called.
+
+**One name, pressed or not**, since the button says which with
+`aria-pressed`: a name that changed as well read out "Exit fullscreen,
+pressed", which is two answers to one question. */
+  "fullscreen-label"?: (HelixHeadlessVideo["fullscreenLabel"]) | undefined;
+  /** What the control that fills the screen is called.
+
+**One name, pressed or not**, since the button says which with
+`aria-pressed`: a name that changed as well read out "Exit fullscreen,
+pressed", which is two answers to one question. */
+  fullscreenLabel?: (HelixHeadlessVideo["fullscreenLabel"]) | undefined;
   /** How long the bar waits after the pointer stops before it goes, in ms.
 
 A wait rather than leaving with the pointer, or a reader moving across the
@@ -9320,6 +10642,18 @@ regardless, because a reader who stopped it is deciding what to do next. */
   loadingLabel?: (HelixHeadlessVideo["loadingLabel"]) | undefined;
   /** Whether it starts again at the end. */
   loop?: (HelixHeadlessVideo["loop"]) | undefined;
+  /** What the button that opens `overflow-controls` is called. */
+  "more-label"?: (HelixHeadlessVideo["moreLabel"]) | undefined;
+  /** What the button that opens `overflow-controls` is called. */
+  moreLabel?: (HelixHeadlessVideo["moreLabel"]) | undefined;
+  /** What the control that silences the video is called, pressed while it is silent. */
+  "mute-label"?: (HelixHeadlessVideo["muteLabel"]) | undefined;
+  /** What the control that silences the video is called, pressed while it is silent. */
+  muteLabel?: (HelixHeadlessVideo["muteLabel"]) | undefined;
+  /** What the control that asks for the next video is called. */
+  "next-label"?: (HelixHeadlessVideo["nextLabel"]) | undefined;
+  /** What the control that asks for the next video is called. */
+  nextLabel?: (HelixHeadlessVideo["nextLabel"]) | undefined;
   /** Controls that go behind one button instead of onto the bar, named the same
 way.
 
@@ -9356,6 +10690,14 @@ bar: two of the same control is worse than either placement. */
   "pause-label"?: (HelixHeadlessVideo["pauseLabel"]) | undefined;
   /** And while it would stop it. */
   pauseLabel?: (HelixHeadlessVideo["pauseLabel"]) | undefined;
+  /** How the volume is read out, with `{percent}` filled in. */
+  "percent-label"?: (HelixHeadlessVideo["percentLabel"]) | undefined;
+  /** How the volume is read out, with `{percent}` filled in. */
+  percentLabel?: (HelixHeadlessVideo["percentLabel"]) | undefined;
+  /** What the control that floats the video over other windows is called. */
+  "pip-label"?: (HelixHeadlessVideo["pipLabel"]) | undefined;
+  /** What the control that floats the video over other windows is called. */
+  pipLabel?: (HelixHeadlessVideo["pipLabel"]) | undefined;
   /** What the play control is called while it would start the video. */
   "play-label"?: (HelixHeadlessVideo["playLabel"]) | undefined;
   /** What the play control is called while it would start the video. */
@@ -9368,6 +10710,26 @@ bar: two of the same control is worse than either placement. */
   poster?: (HelixHeadlessVideo["poster"]) | undefined;
   /** How much to fetch before anything is asked for. */
   preload?: (HelixHeadlessVideo["preload"]) | undefined;
+  /** What the control that asks for the previous video is called. */
+  "previous-label"?: (HelixHeadlessVideo["previousLabel"]) | undefined;
+  /** What the control that asks for the previous video is called. */
+  previousLabel?: (HelixHeadlessVideo["previousLabel"]) | undefined;
+  /** What the control that casts the video to another device is called. */
+  "remote-label"?: (HelixHeadlessVideo["remoteLabel"]) | undefined;
+  /** What the control that casts the video to another device is called. */
+  remoteLabel?: (HelixHeadlessVideo["remoteLabel"]) | undefined;
+  /** What the control that skips back is called, with `{seconds}` filled in. */
+  "rewind-label"?: (HelixHeadlessVideo["rewindLabel"]) | undefined;
+  /** What the control that skips back is called, with `{seconds}` filled in. */
+  rewindLabel?: (HelixHeadlessVideo["rewindLabel"]) | undefined;
+  /** What the scrubber is called. */
+  "seek-label"?: (HelixHeadlessVideo["seekLabel"]) | undefined;
+  /** What the scrubber is called. */
+  seekLabel?: (HelixHeadlessVideo["seekLabel"]) | undefined;
+  /** What the control that changes the speed is called. */
+  "speed-label"?: (HelixHeadlessVideo["speedLabel"]) | undefined;
+  /** What the control that changes the speed is called. */
+  speedLabel?: (HelixHeadlessVideo["speedLabel"]) | undefined;
   /** The speeds offered, slowest first, as multipliers of normal. */
   speeds?: (HelixHeadlessVideo["speeds"]) | undefined;
   /** Where the video is, for the common case of one file. */
@@ -9404,6 +10766,20 @@ A value rather than a boolean, so the resting state is the attribute's
 absence: a boolean defaulting to on would have to be spelled as its own
 negation. */
   startControl?: (HelixHeadlessVideo["startControl"]) | undefined;
+  /** What the menu of tracks is called, where the video has several. */
+  "subtitles-label"?: (HelixHeadlessVideo["subtitlesLabel"]) | undefined;
+  /** What the menu of tracks is called, where the video has several. */
+  subtitlesLabel?: (HelixHeadlessVideo["subtitlesLabel"]) | undefined;
+  /** How the scrubber reads out where the video is, with `{position}` and
+`{duration}` filled in. */
+  "time-label"?: (HelixHeadlessVideo["timeLabel"]) | undefined;
+  /** How the scrubber reads out where the video is, with `{position}` and
+`{duration}` filled in. */
+  timeLabel?: (HelixHeadlessVideo["timeLabel"]) | undefined;
+  /** What the volume slider is called. */
+  "volume-label"?: (HelixHeadlessVideo["volumeLabel"]) | undefined;
+  /** What the volume slider is called. */
+  volumeLabel?: (HelixHeadlessVideo["volumeLabel"]) | undefined;
   /** Where playback has reached, in seconds.
 
 Writing seeks, through the same clamp `seek` uses, because a `currentTime`
@@ -9593,7 +10969,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessAccordionVueProps,
     HelixHeadlessAccordionVueEvents
   >;
-  /** Chrome rather than content. An announcement sits above the header and speaks for the whole page: a trial ending, a service degraded, a change of terms. A passage that interrupts a document to set itself apart is a 'Callout', which is read where it sits and cannot be dismissed. Neither is a variant of the other.  **Always a polite live region.** 'role="alert"' is assertive and interrupts whatever is being read, which is right for something that appears mid-session and wrong for something that was in the served HTML: an assertive announcement would cut across a screen-reader user on every page load, before they had read anything. Politeness costs a moment and is never wrong; the tone does not change that, because an error that was always there is still not an interruption.  Dismissing is a request. The announcement does not remove itself, because the consumer owns the markup and taking the node out from under them would put their state and the document out of step. 'preventDefault()' on the 'helix-dismiss' is a refusal. */
+  /** Chrome rather than content. An announcement sits above the header and speaks for the whole page: a trial ending, a service degraded, a change of terms. A passage that interrupts a document to set itself apart is a 'Callout', which is read where it sits and cannot be dismissed. Neither is a variant of the other.  **Always a polite live region.** 'role="alert"' is assertive and interrupts whatever is being read, which is right for something that appears mid-session and wrong for something that was in the served HTML: an assertive announcement would cut across a screen-reader user on every page load, before they had read anything. Politeness costs a moment and is never wrong; the tone does not change that, because an error that was always there is still not an interruption.  **The region is its own, and there before its words.** The host was the region, and a banner raised mid-session arrives with its message already in it, which a screen reader reads inconsistently at best. So the message is said from a region filled a frame after the banner appears, and one that came with the page is filled at once and says nothing, being no news.  Dismissing is a request. The announcement does not remove itself, because the consumer owns the markup and taking the node out from under them would put their state and the document out of step. 'preventDefault()' on the 'helix-dismiss' is a refusal. */
   "helix-headless-announcement": DefineCustomElement<
     HelixHeadlessAnnouncement,
     HelixHeadlessAnnouncementVueProps,
@@ -9671,6 +11047,24 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessCalloutVueProps,
     HelixHeadlessCalloutVueEvents
   >;
+  /** **A declaration rather than a drawing**, which is the shape 'Table.Column' has: this element renders nothing at all and the board draws the line, because a connector is geometry between two other elements and neither end of it belongs here. What this carries is which cards, which sides, and what sits at the ends.  Written as markup for the reason its cards are: an array of edges handed to a custom element does not survive React's hydration, and a connector a consumer can write is one they can also put a condition around. */
+  "helix-headless-canvas-edge": DefineCustomElement<
+    HelixHeadlessCanvasEdge,
+    HelixHeadlessCanvasEdgeVueProps,
+    HelixHeadlessCanvasEdgeVueEvents
+  >;
+  /** **Markup rather than an entry in an array**, which is the rule 'VideoPlaylist' writes out: an array handed to a custom element is missing from the first paint of every server-rendered React page, because React skips the properties it would have to apply imperatively while hydrating. A card written as an element is in the served HTML whichever renderer wrote it, and what is inside it is the consumer's own DOM rather than a string this component parses.  **Where it sits is data**, which is what makes a canvas a canvas: somebody placed this card and the placement carries meaning, so 'x' and 'y' are given rather than computed. The board reads them and places the card; a page with no JavaScript has the cards and their text and not the arrangement, which is the honest half of what a board can promise before it hydrates.  **Named by 'name', which only has to be unique on its board**, the way a form control's is in its form. An 'id' has to be unique on the whole page, and two boards written from one template, or one board shown twice, would each have a card called 'write' with no way to say which one a connection meant. 'id' is left for the page, which can still use it.  **What it holds is the consumer's**, which is why there is no card type any more: a card of text is text, a link is a link they put inside it, a file is whatever they show for one. The one kind the board treats differently is a group, a box drawn behind the cards inside it, and 'group' says so. JSON Canvas's four types are mapped by 'fromJsonCanvas' on the way in.  **The card is the way around the board, for a reader who cannot see it.** The board keeps one tab stop among its cards, arrow keys walk them in reading order, and the one a reader lands on is brought into view. What it connects to is read out with it, so the arrows between cards are heard as well as seen. That replaced a list of every card under the board, which said the same thing twice to a sighted reader and took a row from the board to do it. */
+  "helix-headless-canvas-node": DefineCustomElement<
+    HelixHeadlessCanvasNode,
+    HelixHeadlessCanvasNodeVueProps,
+    HelixHeadlessCanvasNodeVueEvents
+  >;
+  /** **The first of these surfaces Helix draws itself**, and the reason is where the positions come from. On a canvas **position is data**: somebody placed every card and the placement carries the meaning, so there is no layout to compute and drawing is arithmetic over rectangles. A map is somebody else's tiles and a graph view's positions are computed, which is why 'Map' takes a slotted map and this takes a document.  **The format is open.** [JSON Canvas](https://jsoncanvas.org) gives each node an 'x', 'y', 'width', 'height' and a type, and each edge the two nodes it joins and the sides it leaves and arrives on. A card belongs to a group when it sits inside the group's bounds, which the format leaves to the geometry.  **Accessibility is the design work, not the drawing.** The cards are text in the DOM, so they are readable already; what space does not supply is an order and the connections. So the family chooses an order, walks the cards in it, and says every card's links as text. 'order' takes 'spatial', which bands the cards into rows, and 'edges', which follows the arrows from the cards nothing points to.  **Cards move by default, the way a form control takes input by default.** The board writes the new 'x' and 'y' onto the card itself, as an input writes its own value, and says so twice: 'helix-before-move' for every step, which a consumer holding the positions in their own state refuses and applies themselves, and 'helix-move' once the move is finished. A resize is the same pair with a size in it. 'readonly' keeps every card where it is, for a board that is published rather than worked on, and 'readonly' on one card or connection keeps that one.  **The cards are the way around it.** One of them holds the board's tab stop, arrow keys walk them in reading order, and the one a reader lands on is brought into view with what it connects to read out beside it. Shift with an arrow moves it, which is the keyboard's way to do what a drag does. The connections leaving a card are stops of their own, straight after it, and Enter on one goes to the card it arrives at.  **Every drag can be done with clicks instead**, which WCAG 2.5.7 asks of a pointer that cannot hold a button down. A click on a selected card's move handle, a corner, a card's connection point or the end of a selected connection picks the thing up; it follows the pointer with no button held, and the next click puts it down wherever a drag let go there would have. On touch, the next tap is where it lands. Escape, or a press off the board, puts it back.  **Connecting and removing are requests, and the page acts on them.** Drawing from a card's handle to another card, or pressing C on one and Enter on another, sends 'helix-connect'; Delete on a card or a connection sends 'helix-remove', naming every connection a removed card would strand. A move can be applied by the board because the card is already there. A connection is a new element, and one a board added to markup React renders would be thrown away on the next render, so the board asks and the page writes it.  **Markup rather than a 'src' or a document property.** Nothing in this library fetches, and an array handed to an element is missing from the first paint of every server-rendered React page. The cards and connections are 'helix-canvas-node' and 'helix-canvas-edge' elements, in the served markup whichever renderer wrote them; 'fromJsonCanvas' turns a JSON Canvas document into their props and 'toJsonCanvas()' writes a board back out. */
+  "helix-headless-canvas": DefineCustomElement<
+    HelixHeadlessCanvas,
+    HelixHeadlessCanvasVueProps,
+    HelixHeadlessCanvasVueEvents
+  >;
   /** Regions are slots rather than separate elements, because a header, body, and footer carry no state, no behavior, and no API of their own. Slotting them costs one custom element instead of five and lets the consumer bring their own markup, so a title can be a real '<h2>' rather than an emulated one.  The host is the surface. A wrapper '<div part="container">' would be a second box doing nothing the host cannot: the element itself takes the border, the radius, and the grid, and a consumer styles 'Card' rather than reaching through '::part'. One node instead of two, on every card on the page.  Name the card with 'aria-label' or 'aria-labelledby'. That is the only naming that survives server rendering: reading a title out of the light DOM needs a DOM, and the server has none. */
   "helix-headless-card": DefineCustomElement<
     HelixHeadlessCard,
@@ -9821,7 +11215,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessDrilldownVueProps,
     HelixHeadlessDrilldownVueEvents
   >;
-  /** An empty region with no explanation is indistinguishable from one that failed to load, so this exists to tell the difference: what would be here, and the one action that would put something here.  'role="status"' on a polite live region, because an empty view usually arrives in place of content that was being fetched. Announcing it is the only way a screen-reader user learns the search returned nothing, rather than being left waiting.  Every region is a bare slot. The reference ships an 'empty-state-heading' and an 'empty-state-actions' whose only job is to assign themselves a slot on connect, which is a component for something the consumer can write. */
+  /** An empty region with no explanation is indistinguishable from one that failed to load, so this exists to tell the difference: what would be here, and the one action that would put something here.  Announced, because an empty view usually arrives in place of content that was being fetched: saying so is the only way a screen-reader user learns the search returned nothing, rather than being left waiting. **From a region of its own that is there before its words are**, filled a frame after the view appears. The host was the region, and a page inserts an empty state with its message already in it, which is a region arriving with its words: read inconsistently at best.  Every region is a bare slot. The reference ships an 'empty-state-heading' and an 'empty-state-actions' whose only job is to assign themselves a slot on connect, which is a component for something the consumer can write. */
   "helix-headless-empty": DefineCustomElement<
     HelixHeadlessEmpty,
     HelixHeadlessEmptyVueProps,
@@ -9941,7 +11335,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessListVueProps,
     HelixHeadlessListVueEvents
   >;
-  /** **The listbox is the control and the options are its vocabulary.** A Select is this with a trigger in front of it, a Combobox is this with a text input, and a command palette is this again: they differ in what opens the list and what filters it, not in what the list is.  **'value' is comma separated when 'multiple' is set**, the way 'Checkbox.Group''s is. It stays a string because that is what a form submits and what 'MixinControllerValue' holds.  **Chosen and active are two different things.** Chosen is the answer; active is where the keyboard is. Only the second moves with the arrows, and 'aria-activedescendant' names it while focus stays on the list. */
+  /** **The listbox is the control and the options are its vocabulary.** A Select is this with a trigger in front of it, a Combobox is this with a text input, and a command palette is this again: they differ in what opens the list and what filters it, not in what the list is.  **'value' is comma separated when 'multiple' is set**, the way 'Checkbox.Group''s is, and a string because that is what 'MixinControllerValue' holds. The form is sent one entry per answer, as a native '<select multiple>' sends it, so a server never has to know to split on a comma.  **Chosen and active are two different things.** Chosen is the answer; active is where the keyboard is. Only the second moves with the arrows, and 'aria-activedescendant' names it while focus stays on the list. */
   "helix-headless-listbox": DefineCustomElement<
     HelixHeadlessListbox,
     HelixHeadlessListboxVueProps,