@fusion.dev/helix 0.103.2 → 0.104.0

package/types/vue.d.ts

@@ -15,6 +15,9 @@ import type {
   HelixButtonGroup,
   HelixButton,
   HelixCallout,
+  HelixCanvasEdge,
+  HelixCanvasNode,
+  HelixCanvas,
   HelixCard,
   HelixCarousel,
   HelixChatComposer,
@@ -145,6 +148,18 @@ import type {
   HelixBeforeOpenEvent,
   HelixDismissEvent,
   HelixScrolledEvent,
+  HelixBeforeMoveEvent,
+  HelixBeforeReconnectEvent,
+  HelixBeforeRelabelEvent,
+  HelixCanvasEditEvent,
+  HelixCanvasPanEvent,
+  HelixCanvasViewEvent,
+  HelixCanvasZoomEvent,
+  HelixConnectEvent,
+  HelixMoveEvent,
+  HelixReconnectEvent,
+  HelixRelabelEvent,
+  HelixRemoveEvent,
   HelixSelectEvent,
   HelixSendEvent,
   HelixBeforePinEvent,
@@ -231,6 +246,10 @@ export type HelixAccordionItemHelixBeforeOpenElementEvent =
   HelixAccordionItemElementEvent<HelixBeforeOpenEvent>;
 
 export type HelixAccordionItemVueProps = {
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixAccordionItem["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixAccordionItem["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -244,10 +263,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?: (HelixAccordionItem["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixAccordionItem["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixAccordionItem["defaultOpen"]) | undefined;
   /** Where the open indicator sits, or whether there is one.
 
 `auto` resolves to `end`, which is where a reader scanning a list of
@@ -1269,6 +1284,502 @@ there is no `severity` beside it. */
 
 export type HelixCalloutVueEvents = {};
 
+export type HelixCanvasEdgeVueProps = {
+  /** The card it leaves. */
+  from?: (HelixCanvasEdge["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"?: (HelixCanvasEdge["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?: (HelixCanvasEdge["fromEnd"]) | undefined;
+  /** Which side of that card it leaves, where the document says. */
+  "from-side"?: (HelixCanvasEdge["fromSide"]) | undefined;
+  /** Which side of that card it leaves, where the document says. */
+  fromSide?: (HelixCanvasEdge["fromSide"]) | undefined;
+  /** What the connector says, drawn at its middle. */
+  label?: (HelixCanvasEdge["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?: (HelixCanvasEdge["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?: (HelixCanvasEdge["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?: (HelixCanvasEdge["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?: (HelixCanvasEdge["readOnly"]) | undefined;
+  /** The card it arrives at. */
+  to?: (HelixCanvasEdge["to"]) | undefined;
+  /** What sits at the end it arrives at. Absent is an arrow, as the format says. */
+  "to-end"?: (HelixCanvasEdge["toEnd"]) | undefined;
+  /** What sits at the end it arrives at. Absent is an arrow, as the format says. */
+  toEnd?: (HelixCanvasEdge["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?: (HelixCanvasEdge["tone"]) | undefined;
+  /** Which side of that card it arrives at, where the document says. */
+  "to-side"?: (HelixCanvasEdge["toSide"]) | undefined;
+  /** Which side of that card it arrives at, where the document says. */
+  toSide?: (HelixCanvasEdge["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?: (HelixCanvasEdge["variant"]) | undefined;
+};
+
+export type HelixCanvasEdgeVueEvents = {};
+
+export type HelixCanvasNodeVueProps = {
+  /** What the card's ground is made of: `glass` or `frosted`, which let the
+board's ruling show through, or `transparent`.
+
+Absent is an opaque surface, a resting value being an attribute's absence. */
+  material?: (HelixCanvasNode["material"]) | undefined;
+  /** How the card stands off the board.
+
+Outlined is where it rests, a surface with its color as the edge. `filled`
+puts the color into the ground, `elevated` lifts it and keeps the edge, and
+`plain` draws no box, for a label sitting on the board. */
+  separation?: (HelixCanvasNode["separation"]) | undefined;
+  /** 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?: (HelixCanvasNode["group"]) | undefined;
+  /** How tall the card is, in the document's own units. */
+  height?: (HelixCanvasNode["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?: (HelixCanvasNode["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?: (HelixCanvasNode["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?: (HelixCanvasNode["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?: (HelixCanvasNode["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?: (HelixCanvasNode["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?: (HelixCanvasNode["tone"]) | undefined;
+  /** How wide the card is, in the document's own units. */
+  width?: (HelixCanvasNode["width"]) | undefined;
+  /** Where its left edge sits, in the document's own units. */
+  x?: (HelixCanvasNode["x"]) | undefined;
+  /** Where its top edge sits, in the document's own units. */
+  y?: (HelixCanvasNode["y"]) | undefined;
+};
+
+export type HelixCanvasNodeVueEvents = {};
+
+/** `HelixCanvas` component event */
+export type HelixCanvasElementEvent<E = Event> = TypedEvent<HelixCanvas, E>;
+/** `helix-before-move` event type */
+export type HelixCanvasHelixBeforeMoveElementEvent =
+  HelixCanvasElementEvent<HelixBeforeMoveEvent>;
+/** `helix-before-reconnect` event type */
+export type HelixCanvasHelixBeforeReconnectElementEvent =
+  HelixCanvasElementEvent<HelixBeforeReconnectEvent>;
+/** `helix-before-relabel` event type */
+export type HelixCanvasHelixBeforeRelabelElementEvent =
+  HelixCanvasElementEvent<HelixBeforeRelabelEvent>;
+/** `helix-canvas-edit` event type */
+export type HelixCanvasHelixCanvasEditElementEvent =
+  HelixCanvasElementEvent<HelixCanvasEditEvent>;
+/** `helix-canvas-pan` event type */
+export type HelixCanvasHelixCanvasPanElementEvent =
+  HelixCanvasElementEvent<HelixCanvasPanEvent>;
+/** `helix-canvas-view` event type */
+export type HelixCanvasHelixCanvasViewElementEvent =
+  HelixCanvasElementEvent<HelixCanvasViewEvent>;
+/** `helix-canvas-zoom` event type */
+export type HelixCanvasHelixCanvasZoomElementEvent =
+  HelixCanvasElementEvent<HelixCanvasZoomEvent>;
+/** `helix-connect` event type */
+export type HelixCanvasHelixConnectElementEvent =
+  HelixCanvasElementEvent<HelixConnectEvent>;
+/** `helix-move` event type */
+export type HelixCanvasHelixMoveElementEvent =
+  HelixCanvasElementEvent<HelixMoveEvent>;
+/** `helix-reconnect` event type */
+export type HelixCanvasHelixReconnectElementEvent =
+  HelixCanvasElementEvent<HelixReconnectEvent>;
+/** `helix-relabel` event type */
+export type HelixCanvasHelixRelabelElementEvent =
+  HelixCanvasElementEvent<HelixRelabelEvent>;
+/** `helix-remove` event type */
+export type HelixCanvasHelixRemoveElementEvent =
+  HelixCanvasElementEvent<HelixRemoveEvent>;
+/** `helix-select` event type */
+export type HelixCanvasHelixSelectElementEvent =
+  HelixCanvasElementEvent<HelixSelectEvent>;
+
+export type HelixCanvasVueProps = {
+  /** Rules the plane, so a reader can see it move.
+
+**Baked in rather than a family of its own**, which was the question worth
+asking: a grid has no content, no position and nothing to slot, so an
+element for it would be an element with no reason to exist. It is the
+board's own surface, and what a consumer varies about it is a length.
+
+**On the plane and not on the well**, which is what makes it worth having:
+the ruling is drawn in the document's own units, so it moves and scales with
+the cards and a drag has something to move against. A grid on the frame
+would sit still while the board slid over it, which reads as the board
+standing still.
+
+Absent is no ruling, a resting value being an attribute's absence. */
+  grid?: (HelixCanvas["grid"]) | undefined;
+  /** How the board stands off the page: `plain` for no frame at all.
+
+Framed is where it rests. Plain is for a board that fills a panel or an
+app's working area, where the container is already the frame. */
+  separation?: (HelixCanvas["separation"]) | 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?: (HelixCanvas["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"?: (HelixCanvas["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?: (HelixCanvas["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"?: (HelixCanvas["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?: (HelixCanvas["controlsPlacement"]) | undefined;
+  /** What the control that fills the screen is called. */
+  "fullscreen-label"?: (HelixCanvas["fullscreenLabel"]) | undefined;
+  /** What the control that fills the screen is called. */
+  fullscreenLabel?: (HelixCanvas["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"?: (HelixCanvas["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?: (HelixCanvas["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"?: (HelixCanvas["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?: (HelixCanvas["panDownLabel"]) | undefined;
+  /** What the control that pans left is called, on screen. */
+  "pan-left-label"?: (HelixCanvas["panLeftLabel"]) | undefined;
+  /** What the control that pans left is called, on screen. */
+  panLeftLabel?: (HelixCanvas["panLeftLabel"]) | undefined;
+  /** What the control that pans right is called, on screen. */
+  "pan-right-label"?: (HelixCanvas["panRightLabel"]) | undefined;
+  /** What the control that pans right is called, on screen. */
+  panRightLabel?: (HelixCanvas["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"?: (HelixCanvas["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?: (HelixCanvas["panStep"]) | undefined;
+  /** What the control that pans up is called. */
+  "pan-up-label"?: (HelixCanvas["panUpLabel"]) | undefined;
+  /** What the control that pans up is called. */
+  panUpLabel?: (HelixCanvas["panUpLabel"]) | undefined;
+  /** What the control that zooms in is called. */
+  "zoom-in-label"?: (HelixCanvas["zoomInLabel"]) | undefined;
+  /** What the control that zooms in is called. */
+  zoomInLabel?: (HelixCanvas["zoomInLabel"]) | undefined;
+  /** What the control that zooms out is called. */
+  "zoom-out-label"?: (HelixCanvas["zoomOutLabel"]) | undefined;
+  /** What the control that zooms out is called. */
+  zoomOutLabel?: (HelixCanvas["zoomOutLabel"]) | undefined;
+  /** How a card says where its connections come from, with `{cards}`. */
+  "comes-from-label"?: (HelixCanvas["comesFromLabel"]) | undefined;
+  /** How a card says where its connections come from, with `{cards}`. */
+  comesFromLabel?: (HelixCanvas["comesFromLabel"]) | undefined;
+  /** What it says when a connection is asked for, with `{from}` and `{to}`. */
+  "connected-label"?: (HelixCanvas["connectedLabel"]) | undefined;
+  /** What it says when a connection is asked for, with `{from}` and `{to}`. */
+  connectedLabel?: (HelixCanvas["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"?: (HelixCanvas["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?: (HelixCanvas["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"?: (HelixCanvas["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?: (HelixCanvas["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?: (HelixCanvas["label"]) | undefined;
+  /** What the field a label is edited in is called, with `{name}` for what it
+labels. */
+  "label-editor-label"?: (HelixCanvas["labelEditorLabel"]) | undefined;
+  /** What the field a label is edited in is called, with `{name}` for what it
+labels. */
+  labelEditorLabel?: (HelixCanvas["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"?: (HelixCanvas["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?: (HelixCanvas["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?: (HelixCanvas["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?: (HelixCanvas["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?: (HelixCanvas["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?: (HelixCanvas["readOnly"]) | undefined;
+  /** What the live region says when a reader picks up a connection's end, with
+`{from}` and `{to}`. */
+  "reconnecting-label"?: (HelixCanvas["reconnectingLabel"]) | undefined;
+  /** What the live region says when a reader picks up a connection's end, with
+`{from}` and `{to}`. */
+  reconnectingLabel?: (HelixCanvas["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?: (HelixCanvas["selected"]) | undefined;
+  /** What it says when a reader stops connecting without asking. */
+  "stopped-label"?: (HelixCanvas["stoppedLabel"]) | undefined;
+  /** What it says when a reader stops connecting without asking. */
+  stoppedLabel?: (HelixCanvas["stoppedLabel"]) | 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?: (HelixCanvas["view"]) | undefined;
+};
+
+export type HelixCanvasVueEvents = {
+  /** Cards are about to move. Refuse it to keep the positions in your own state. */
+  "helix-before-move": HelixCanvasHelixBeforeMoveElementEvent;
+  /** 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": HelixCanvasHelixBeforeReconnectElementEvent;
+  /** 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": HelixCanvasHelixBeforeRelabelElementEvent;
+  /** The reader asked to edit a card: a double-click, or Enter or F2. Open your own editor for it. */
+  "helix-canvas-edit": HelixCanvasHelixCanvasEditElementEvent;
+  /** 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": HelixCanvasHelixCanvasPanElementEvent;
+  /** Where the board is looking changed, however it changed. The detail is the new view. */
+  "helix-canvas-view": HelixCanvasHelixCanvasViewElementEvent;
+  /** 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": HelixCanvasHelixCanvasZoomElementEvent;
+  /** A reader asked for two cards to be joined. Add the `helix-canvas-edge` to do it. */
+  "helix-connect": HelixCanvasHelixConnectElementEvent;
+  /** Cards moved and the move is finished: a drag let go, a click that put a card down, or a key pressed. */
+  "helix-move": HelixCanvasHelixMoveElementEvent;
+  /** A connection's end moved, and the move is finished. */
+  "helix-reconnect": HelixCanvasHelixReconnectElementEvent;
+  /** A connection's label or a group's name changed. */
+  "helix-relabel": HelixCanvasHelixRelabelElementEvent;
+  /** A reader asked for cards or connections to go. Remove the elements it names. */
+  "helix-remove": HelixCanvasHelixRemoveElementEvent;
+  /** 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": HelixCanvasHelixSelectElementEvent;
+};
+
 export type HelixCardVueProps = {
   /** What the card is made of.
 
@@ -1548,19 +2059,6 @@ one leaves the other alone. */
   indicatorPlacement?: (HelixCarousel["indicatorPlacement"]) | undefined;
   /** Whether the carousel advances on its own. */
   autoplay?: (HelixCarousel["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?: (HelixCarousel["index"]) | undefined;
   /** Whether the previous and next controls are shown.
 
 `auto`, which is the resting behavior and what an absent attribute means,
@@ -1589,12 +2087,45 @@ touch device exactly as it does on a desktop. */
   "default-index"?: (HelixCarousel["defaultIndex"] | `${number}`) | undefined;
   /** Slide to start on, where nothing declared one. */
   defaultIndex?: (HelixCarousel["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?: (HelixCarousel["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"?: (HelixCarousel["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?: (HelixCarousel["indicatorLabel"]) | undefined;
+  /** What the row of indicators is called, with the carousel's `{label}` filled in. */
+  "indicators-label"?: (HelixCarousel["indicatorsLabel"]) | undefined;
+  /** What the row of indicators is called, with the carousel's `{label}` filled in. */
+  indicatorsLabel?: (HelixCarousel["indicatorsLabel"]) | undefined;
   /** How long each slide is held, in milliseconds. */
   interval?: (HelixCarousel["interval"]) | undefined;
   /** Accessible name for the carousel. */
   label?: (HelixCarousel["label"]) | undefined;
   /** Whether moving past either end wraps to the other. */
   loop?: (HelixCarousel["loop"]) | undefined;
+  /** What the control that moves forward is called. */
+  "next-label"?: (HelixCarousel["nextLabel"]) | undefined;
+  /** What the control that moves forward is called. */
+  nextLabel?: (HelixCarousel["nextLabel"]) | undefined;
   /** Which way the track runs.
 
 Behavior rather than presentation, which is why it is here: the scroll
@@ -1728,6 +2259,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?: (HelixCarousel["perView"]) | undefined;
+  /** What the control that moves back is called. */
+  "previous-label"?: (HelixCarousel["previousLabel"]) | undefined;
+  /** What the control that moves back is called. */
+  previousLabel?: (HelixCarousel["previousLabel"]) | undefined;
+  /** What each slide is called, with `{index}` and `{count}` filled in. */
+  "slide-label"?: (HelixCarousel["slideLabel"]) | undefined;
+  /** What each slide is called, with `{index}` and `{count}` filled in. */
+  slideLabel?: (HelixCarousel["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"?: (HelixCarousel["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?: (HelixCarousel["slideRoleLabel"]) | undefined;
+  /** What the rotation control is called while it would start rotation. */
+  "start-label"?: (HelixCarousel["startLabel"]) | undefined;
+  /** What the rotation control is called while it would start rotation. */
+  startLabel?: (HelixCarousel["startLabel"]) | undefined;
+  /** And while it would stop it. */
+  "stop-label"?: (HelixCarousel["stopLabel"]) | undefined;
+  /** And while it would stop it. */
+  stopLabel?: (HelixCarousel["stopLabel"]) | undefined;
 };
 
 export type HelixCarouselVueEvents = {
@@ -1882,9 +2435,17 @@ say that without the component knowing what a row looks like. */
   "loading-text"?: (HelixChat["loadingText"]) | undefined;
   /** What is said while they are on their way. */
   loadingText?: (HelixChat["loadingText"]) | 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. */
   "default-pinned"?: (HelixChat["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?: (HelixChat["defaultPinned"]) | undefined;
   /** Whether there are older turns than the ones here, and whether they are coming.
 
@@ -1964,6 +2525,26 @@ export type HelixCheckboxGroupVueProps = {
   label?: (HelixCheckboxGroup["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixCheckboxGroup["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"?: (HelixCheckboxGroup["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?: (HelixCheckboxGroup["valueMissingMessage"]) | undefined;
   /** The checked values, comma separated. */
   value?: (HelixCheckboxGroup["value"]) | undefined;
   /** Whether the control is non-interactive.
@@ -2056,6 +2637,26 @@ stylesheets. */
   label?: (HelixCheckbox["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixCheckbox["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"?: (HelixCheckbox["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?: (HelixCheckbox["valueMissingMessage"]) | undefined;
   /** Whether the box shows as neither checked nor unchecked.
 
 Presentation only. It never submits, and the first change resolves it. */
@@ -2180,6 +2781,26 @@ export type HelixColorInputHelixBeforeOpenElementEvent =
   HelixColorInputElementEvent<HelixBeforeOpenEvent>;
 
 export type HelixColorInputVueProps = {
+  /** 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"?: (HelixColorInput["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?: (HelixColorInput["badInputMessage"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixColorInput["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixColorInput["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -2193,10 +2814,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?: (HelixColorInput["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixColorInput["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixColorInput["defaultOpen"]) | undefined;
   /** The value the markup declared, which is where a reset returns to. */
   "default-value"?: (HelixColorInput["defaultValue"]) | undefined;
   /** The value the markup declared, which is where a reset returns to. */
@@ -2216,6 +2833,26 @@ a reset should return to. */
   label?: (HelixColorInput["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixColorInput["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"?: (HelixColorInput["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?: (HelixColorInput["valueMissingMessage"]) | undefined;
   /** Whether the color carries an alpha channel. */
   alpha?: (HelixColorInput["alpha"]) | undefined;
   /** What the browser may autofill in the text field, as a platform token.
@@ -2348,11 +2985,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?: (HelixColorPicker["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"?: (HelixColorPicker["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?: (HelixColorPicker["brightnessLabel"]) | undefined;
+  /** What the sample says for a moment after it copied the value. */
+  "copied-label"?: (HelixColorPicker["copiedLabel"]) | undefined;
+  /** What the sample says for a moment after it copied the value. */
+  copiedLabel?: (HelixColorPicker["copiedLabel"]) | undefined;
+  /** What the sample is called, which copies the value, with `{value}` filled in. */
+  "copy-label"?: (HelixColorPicker["copyLabel"]) | undefined;
+  /** What the sample is called, which copies the value, with `{value}` filled in. */
+  copyLabel?: (HelixColorPicker["copyLabel"]) | undefined;
+  /** What the eyedropper is called. */
+  "eyedropper-label"?: (HelixColorPicker["eyedropperLabel"]) | undefined;
+  /** What the eyedropper is called. */
+  eyedropperLabel?: (HelixColorPicker["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?: (HelixColorPicker["format"]) | undefined;
+  /** What the syntax toggle is called, with `{format}` filled in. */
+  "format-label"?: (HelixColorPicker["formatLabel"]) | undefined;
+  /** What the syntax toggle is called, with `{format}` filled in. */
+  formatLabel?: (HelixColorPicker["formatLabel"]) | undefined;
+  /** What the hue channel is called. */
+  "hue-label"?: (HelixColorPicker["hueLabel"]) | undefined;
+  /** What the hue channel is called. */
+  hueLabel?: (HelixColorPicker["hueLabel"]) | undefined;
   /** Whether the current selection fails validation.
 
 A flag rather than a message, the split Date Picker also draws. A flat
@@ -2395,6 +3062,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?: (HelixColorPicker["noValue"]) | undefined;
+  /** What the opacity channel is called, where `alpha` offers one. */
+  "opacity-label"?: (HelixColorPicker["opacityLabel"]) | undefined;
+  /** What the opacity channel is called, where `alpha` offers one. */
+  opacityLabel?: (HelixColorPicker["opacityLabel"]) | undefined;
+  /** What the row of `swatches` is called. */
+  "presets-label"?: (HelixColorPicker["presetsLabel"]) | undefined;
+  /** What the row of `swatches` is called. */
+  presetsLabel?: (HelixColorPicker["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
@@ -2468,8 +3143,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?: (HelixColorPicker["required"]) | undefined;
+  /** What the square's horizontal ramp is called. */
+  "saturation-label"?: (HelixColorPicker["saturationLabel"]) | undefined;
+  /** What the square's horizontal ramp is called. */
+  saturationLabel?: (HelixColorPicker["saturationLabel"]) | undefined;
   /** Colors offered under the picker, as a comma-separated list. */
   swatches?: (HelixColorPicker["swatches"]) | undefined;
+  /** What the group holding the eyedropper and the syntax toggle is called. */
+  "tools-label"?: (HelixColorPicker["toolsLabel"]) | undefined;
+  /** What the group holding the eyedropper and the syntax toggle is called. */
+  toolsLabel?: (HelixColorPicker["toolsLabel"]) | undefined;
+  /** What the text field holding the value is called. */
+  "value-label"?: (HelixColorPicker["valueLabel"]) | undefined;
+  /** What the text field holding the value is called. */
+  valueLabel?: (HelixColorPicker["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"?: (HelixColorPicker["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?: (HelixColorPicker["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -2532,6 +3231,10 @@ export type HelixComboboxHelixFilterElementEvent =
   HelixComboboxElementEvent<HelixFilterEvent>;
 
 export type HelixComboboxVueProps = {
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixCombobox["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixCombobox["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -2545,10 +3248,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?: (HelixCombobox["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixCombobox["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixCombobox["defaultOpen"]) | undefined;
   /** What the control is called once everything is showing. */
   "collapse-label"?: (HelixCombobox["collapseLabel"]) | undefined;
   /** What the control is called once everything is showing. */
@@ -2582,6 +3281,26 @@ a reset should return to. */
   label?: (HelixCombobox["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixCombobox["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"?: (HelixCombobox["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?: (HelixCombobox["valueMissingMessage"]) | undefined;
   /** What the browser may autofill in the text field, as a platform token.
 
 **Defaults to `off`, which is not the platform's default and is the
@@ -2637,9 +3356,15 @@ element is responsible for. */
   multiple?: (HelixCombobox["multiple"]) | undefined;
   /** Text shown while nothing has been chosen. */
   placeholder?: (HelixCombobox["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"?: (HelixCombobox["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?: (HelixCombobox["removeLabel"]) | undefined;
   /** Whether the field finishes the word as it is typed.
 
@@ -2715,6 +3440,10 @@ export type HelixCommandHelixSelectElementEvent =
   HelixCommandElementEvent<HelixSelectEvent>;
 
 export type HelixCommandVueProps = {
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixCommand["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixCommand["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -2728,10 +3457,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?: (HelixCommand["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixCommand["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixCommand["defaultOpen"]) | undefined;
   /** Words shown where the filter has matched nothing. */
   "empty-text"?: (HelixCommand["emptyText"]) | undefined;
   /** Words shown where the filter has matched nothing. */
@@ -3030,20 +3755,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?: (HelixDataTable["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?: (HelixDataTable["sort"]) | undefined;
-  /** Accessible name for the grid. */
-  label?: (HelixDataTable["label"]) | undefined;
   /** What the rows are narrowed to, as one query across every column.
 
 One query rather than a predicate per column, which is what a reader means
 by a search box above a table. It matches on each column's ordering value,
 so search and sort cannot disagree about what a column holds. */
   filter?: (HelixDataTable["filter"]) | undefined;
+  /** Accessible name for the grid. */
+  label?: (HelixDataTable["label"]) | undefined;
   /** Whether this element does the work or asks the consumer to.
 
 `client` filters, sorts and pages `rows` itself. `server` applies none of
@@ -3053,25 +3772,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?: (HelixDataTable["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?: (HelixDataTable["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?: (HelixDataTable["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"?: (HelixDataTable["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?: (HelixDataTable["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?: (HelixDataTable["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?: (HelixDataTable["reorderable"]) | undefined;
-  /** The columns' order, as their fields separated by spaces.
-
-A reader's move fires `helix-reorder` first, and refusing it leaves the
-columns where they were, which is how a consumer who stores the order takes
-the decision. `default-order` seeds an order this element then owns. A field not named
-keeps its place after the named ones, and a column with no field never
-moves. */
-  order?: (HelixDataTable["order"]) | undefined;
   /** The field naming a row's stable identity.
 
 **Needed before selection exists, not after.** Lit keys the rendered rows by
@@ -3111,22 +3853,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?: (HelixDataTable["selected"]) | undefined;
-  /** How many rows a page holds. Zero is every row, which is what "no paging" means.
-
-**It announces nothing, and that is not an omission.** Nothing in this
-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"?: (HelixDataTable["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?: (HelixDataTable["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?: (HelixDataTable["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
@@ -3152,13 +3884,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?: (HelixDataTable["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?: (HelixDataTable["paginated"]) | undefined;
   /** The whole result, in the order it arrived.
 
 A property and not an attribute: it is an array. Left alone this element
@@ -3224,6 +3949,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?: (HelixDateInput["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"?: (HelixDateInput["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?: (HelixDateInput["badInputMessage"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixDateInput["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixDateInput["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -3237,10 +3982,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?: (HelixDateInput["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixDateInput["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixDateInput["defaultOpen"]) | undefined;
   /** What the control is called once everything is showing. */
   "collapse-label"?: (HelixDateInput["collapseLabel"]) | undefined;
   /** What the control is called once everything is showing. */
@@ -3274,6 +4015,26 @@ a reset should return to. */
   label?: (HelixDateInput["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixDateInput["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"?: (HelixDateInput["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?: (HelixDateInput["valueMissingMessage"]) | undefined;
   /** What the browser may autofill here, as one of the platform's own tokens.
 
 Empty leaves the attribute off, which is the browser's default and is what
@@ -3359,6 +4120,40 @@ window has no room for that width it shows one month until there is. */
   months?: (HelixDateInput["months"]) | undefined;
   /** What the field says before a date is in it. */
   placeholder?: (HelixDateInput["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"?: (HelixDateInput["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?: (HelixDateInput["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"?: (HelixDateInput["rangeOverflowMessage"]) | undefined;
+  /** What a reader is told when a date is after `max`, with `{max}` filled in
+as the field writes it. */
+  rangeOverflowMessage?: (HelixDateInput["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"?: (HelixDateInput["rangeUnderflowMessage"]) | undefined;
+  /** What a reader is told when a date is before `min`, with `{min}` filled
+in as the field writes it. */
+  rangeUnderflowMessage?: (HelixDateInput["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"?: (HelixDateInput["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?: (HelixDateInput["removeLabel"]) | undefined;
   /** How far apart the selectable dates are, in days.
 
 `<input type="date" step>`'s own unit, handed to the calendar this renders
@@ -3451,6 +4246,18 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixDatePicker["value"]) | 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. */
+  "bad-input-message"?: (HelixDatePicker["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?: (HelixDatePicker["badInputMessage"]) | undefined;
   /** Month to open on, where nothing declared one. */
   "default-month"?: (HelixDatePicker["defaultMonth"]) | undefined;
   /** Month to open on, where nothing declared one. */
@@ -3471,12 +4278,6 @@ a reset should return to. */
   invalid?: (HelixDatePicker["invalid"]) | undefined;
   /** Accessible name for the grid. */
   label?: (HelixDatePicker["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?: (HelixDatePicker["month"]) | undefined;
   /** Locale for month and day names.
 
 Absent uses the runtime's own. */
@@ -3487,6 +4288,12 @@ Absent uses the runtime's own. */
   min?: (HelixDatePicker["min"]) | undefined;
   /** How many dates can be held at once. */
   mode?: (HelixDatePicker["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?: (HelixDatePicker["month"]) | undefined;
   /** How many months to show, side by side. */
   months?: (HelixDatePicker["months"]) | undefined;
   /** Accessible name for the control that pages forward. */
@@ -3545,6 +4352,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?: (HelixDatePicker["step"]) | undefined;
+  /** What a reader is told when a date is required and none is chosen. */
+  "value-missing-message"?: (HelixDatePicker["valueMissingMessage"]) | undefined;
+  /** What a reader is told when a date is required and none is chosen. */
+  valueMissingMessage?: (HelixDatePicker["valueMissingMessage"]) | undefined;
   /** Whether the control is non-interactive.
 
 Reflected, because the styled tier selects on it, and mirrored to
@@ -3720,6 +4531,10 @@ write the same two arrangements, and a fourth way to get one of them wrong.
 Unset is `start` and stays unset, so a reflected default cannot appear on a
 host whose server output never had it. */
   textAlign?: (HelixDialog["textAlign"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixDialog["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixDialog["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -3733,10 +4548,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?: (HelixDialog["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixDialog["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixDialog["defaultOpen"]) | undefined;
   /** Which close requests the browser answers on its own.
 
 `<dialog closedby>`, forwarded, and safe to forward because every path it
@@ -3948,6 +4759,10 @@ content is only readable because it has a ground; dropping it makes an
 unreadable drawer rather than a lighter one. `frosted` and `glass` are the
 two honest points here. */
   material?: (HelixDrawer["material"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixDrawer["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixDrawer["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -3961,10 +4776,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?: (HelixDrawer["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixDrawer["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixDrawer["defaultOpen"]) | undefined;
   /** Which close requests the browser answers on its own.
 
 `<dialog closedby>`, forwarded, and safe to forward because every path it
@@ -4149,6 +4960,26 @@ export type HelixFileInputVueProps = {
   label?: (HelixFileInput["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixFileInput["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"?: (HelixFileInput["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?: (HelixFileInput["valueMissingMessage"]) | undefined;
   /** Which files the picker offers, as a native `accept` list. */
   accept?: (HelixFileInput["accept"]) | undefined;
   /** Which camera or microphone a mobile picker should offer, if any. */
@@ -4159,9 +4990,17 @@ Absent uses the runtime's own. */
   locale?: (HelixFileInput["locale"]) | undefined;
   /** Whether more than one file can be chosen. */
   multiple?: (HelixFileInput["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"?: (HelixFileInput["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?: (HelixFileInput["removeLabel"]) | undefined;
   /** What the trigger reads, where nothing is slotted into it. */
   "trigger-label"?: (HelixFileInput["triggerLabel"]) | undefined;
@@ -4394,6 +5233,10 @@ export type HelixFilterInputHelixSelectElementEvent =
   HelixFilterInputElementEvent<HelixSelectEvent>;
 
 export type HelixFilterInputVueProps = {
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixFilterInput["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixFilterInput["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -4407,10 +5250,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?: (HelixFilterInput["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixFilterInput["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixFilterInput["defaultOpen"]) | undefined;
   /** What the control is called once everything is showing. */
   "collapse-label"?: (HelixFilterInput["collapseLabel"]) | undefined;
   /** What the control is called once everything is showing. */
@@ -4444,6 +5283,26 @@ a reset should return to. */
   label?: (HelixFilterInput["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixFilterInput["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"?: (HelixFilterInput["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?: (HelixFilterInput["valueMissingMessage"]) | undefined;
   /** Whether the field offers a button that empties it.
 
 The text only. The tokens are the consumer's markup and this element is not
@@ -5127,6 +5986,26 @@ a reset should return to. */
   label?: (HelixInput["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixInput["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"?: (HelixInput["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?: (HelixInput["valueMissingMessage"]) | undefined;
   /** What the browser may autofill here, as one of the platform's own tokens.
 
 Empty leaves the attribute off, which is the browser's default. Set it to
@@ -5434,6 +6313,10 @@ Ignored once `active` is written. */
 
 Ignored once `active` is written. */
   defaultActive?: (HelixLightbox["defaultActive"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixLightbox["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixLightbox["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -5447,10 +6330,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?: (HelixLightbox["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixLightbox["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixLightbox["defaultOpen"]) | undefined;
   /** How long the reader may be still before the chrome hides, in milliseconds.
 
 Zero keeps it up, which is what a viewer with a caption worth reading
@@ -5770,6 +6649,26 @@ a reset should return to. */
   label?: (HelixListbox["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixListbox["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"?: (HelixListbox["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?: (HelixListbox["valueMissingMessage"]) | undefined;
   /** What the browser may autofill in the text field, as a platform token.
 
 **Defaults to `off`, which is not the platform's default and is the
@@ -5777,6 +6676,10 @@ 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?: (HelixListbox["autocomplete"]) | undefined;
+  /** What to start narrowed to, where nothing declared it. */
+  "default-filter"?: (HelixListbox["defaultFilter"]) | undefined;
+  /** What to start narrowed to, where nothing declared it. */
+  defaultFilter?: (HelixListbox["defaultFilter"]) | undefined;
   /** What the list is narrowed to, if anything.
 
 Filtering hides rather than removes, so nothing about the value changes and
@@ -5784,10 +6687,6 @@ 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?: (HelixListbox["filter"]) | undefined;
-  /** What to start narrowed to, where nothing declared it. */
-  "default-filter"?: (HelixListbox["defaultFilter"]) | undefined;
-  /** What to start narrowed to, where nothing declared it. */
-  defaultFilter?: (HelixListbox["defaultFilter"]) | undefined;
   /** Whether the list renders a field for narrowing itself.
 
 The field lives here rather than in whatever frames the list, because the
@@ -5880,56 +6779,63 @@ export type HelixMapHelixMapZoomElementEvent =
   HelixMapElementEvent<HelixMapZoomEvent>;
 
 export type HelixMapVueProps = {
-  /** Which of the controls this frame draws, as a list of what to keep.
-
-**A list rather than a switch, because the overlap is not symmetric.**
-Every map library draws zoom controls and none of them draws pan buttons:
-MapLibre's navigation control is zoom and a compass, Leaflet's is zoom,
-Google's is zoom. So a consumer slotting one of those has our zoom twice
-over and our pan pad not at all, and a single switch would make them choose
-between a duplicate and nothing.
-
-`none` draws none of them, which is the right answer where the slotted map
-already has controls a reader can find: what this family 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
-frame.
-
-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 frame that named no list at all would be laid out as
-though it had dropped everything. */
+  /** 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?: (HelixMap["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"?: (HelixMap["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?: (HelixMap["controlsLabel"]) | undefined;
   /** Which corner the controls sit in.
 
-**Configurable because there is no safe default**, and this is a collision
-rather than a taste: MapLibre puts its own controls at the top end, Leaflet
-and OpenLayers at the top start, Google's zoom at the bottom end. Whichever
-corner this took would land on somebody's, which is why every one of those
-libraries made it a setting too.
+**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, which is this library's rule that a resting value is
-an attribute's absence: a default that reflected would write an attribute
-onto every host that no server sent and nobody asked for. */
+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"?: (HelixMap["controlsPlacement"]) | undefined;
   /** Which corner the controls sit in.
 
-**Configurable because there is no safe default**, and this is a collision
-rather than a taste: MapLibre puts its own controls at the top end, Leaflet
-and OpenLayers at the top start, Google's zoom at the bottom end. Whichever
-corner this took would land on somebody's, which is why every one of those
-libraries made it a setting too.
+**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, which is this library's rule that a resting value is
-an attribute's absence: a default that reflected would write an attribute
-onto every host that no server sent and nobody asked for. */
+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?: (HelixMap["controlsPlacement"]) | undefined;
   /** What the control that fills the screen is called. */
   "fullscreen-label"?: (HelixMap["fullscreenLabel"]) | undefined;
@@ -5937,16 +6843,66 @@ onto every host that no server sent and nobody asked for. */
   fullscreenLabel?: (HelixMap["fullscreenLabel"]) | undefined;
   /** How long the reader may be still before the chrome hides, in milliseconds.
 
-Zero keeps it up, which is the default: a map's controls are how a keyboard
-reader operates it, and chrome that hides itself by default would be this
-component undoing its own argument. Set it for a display map nobody drives. */
+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"?: (HelixMap["idleDelay"] | `${number}`) | undefined;
   /** How long the reader may be still before the chrome hides, in milliseconds.
 
-Zero keeps it up, which is the default: a map's controls are how a keyboard
-reader operates it, and chrome that hides itself by default would be this
-component undoing its own argument. Set it for a display map nobody drives. */
+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?: (HelixMap["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"?: (HelixMap["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?: (HelixMap["panDownLabel"]) | undefined;
+  /** What the control that pans left is called, on screen. */
+  "pan-left-label"?: (HelixMap["panLeftLabel"]) | undefined;
+  /** What the control that pans left is called, on screen. */
+  panLeftLabel?: (HelixMap["panLeftLabel"]) | undefined;
+  /** What the control that pans right is called, on screen. */
+  "pan-right-label"?: (HelixMap["panRightLabel"]) | undefined;
+  /** What the control that pans right is called, on screen. */
+  panRightLabel?: (HelixMap["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"?: (HelixMap["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?: (HelixMap["panStep"]) | undefined;
+  /** What the control that pans up is called. */
+  "pan-up-label"?: (HelixMap["panUpLabel"]) | undefined;
+  /** What the control that pans up is called. */
+  panUpLabel?: (HelixMap["panUpLabel"]) | undefined;
+  /** What the control that zooms in is called. */
+  "zoom-in-label"?: (HelixMap["zoomInLabel"]) | undefined;
+  /** What the control that zooms in is called. */
+  zoomInLabel?: (HelixMap["zoomInLabel"]) | undefined;
+  /** What the control that zooms out is called. */
+  "zoom-out-label"?: (HelixMap["zoomOutLabel"]) | undefined;
+  /** What the control that zooms out is called. */
+  zoomOutLabel?: (HelixMap["zoomOutLabel"]) | undefined;
   /** Accessible name for the map, which is the one thing a consumer must write.
 
 There is no sensible default. "Map" names the widget rather than the place,
@@ -5960,32 +6916,6 @@ arrow keys no reader could ever press. `aria-keyshortcuts` says which keys
 rather than spelling them into the name, which would otherwise be read out
 at every encounter. */
   label?: (HelixMap["label"]) | undefined;
-  /** What the controls are called, for a page not in English. */
-  "pan-label"?: (HelixMap["panLabel"]) | undefined;
-  /** What the controls are called, for a page not in English. */
-  panLabel?: (HelixMap["panLabel"]) | undefined;
-  /** How far one press moves the map, as a fraction of what is on screen.
-
-A fraction rather than a distance, because this frame does not know the
-scale of what is inside it: a quarter of the viewport is the same gesture at
-street level and at country level, and a consumer who wants metres can
-multiply by their own. */
-  "pan-step"?: (HelixMap["panStep"] | `${number}`) | undefined;
-  /** How far one press moves the map, as a fraction of what is on screen.
-
-A fraction rather than a distance, because this frame does not know the
-scale of what is inside it: a quarter of the viewport is the same gesture at
-street level and at country level, and a consumer who wants metres can
-multiply by their own. */
-  panStep?: (HelixMap["panStep"]) | undefined;
-  /** What the zoom controls are called. */
-  "zoom-in-label"?: (HelixMap["zoomInLabel"]) | undefined;
-  /** What the zoom controls are called. */
-  zoomInLabel?: (HelixMap["zoomInLabel"]) | undefined;
-  /** What the zoom control that goes the other way is called. */
-  "zoom-out-label"?: (HelixMap["zoomOutLabel"]) | undefined;
-  /** What the zoom control that goes the other way is called. */
-  zoomOutLabel?: (HelixMap["zoomOutLabel"]) | undefined;
 };
 
 export type HelixMapVueEvents = {
@@ -6005,6 +6935,10 @@ export type HelixMegamenuHelixBeforeOpenElementEvent =
   HelixMegamenuElementEvent<HelixBeforeOpenEvent>;
 
 export type HelixMegamenuVueProps = {
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixMegamenu["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixMegamenu["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -6018,10 +6952,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?: (HelixMegamenu["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixMegamenu["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixMegamenu["defaultOpen"]) | undefined;
   /** The width, in pixels, under which a card becomes a band. Zero never does.
 
 A card is a panel hung off one word, and there is no room to hang anything
@@ -6230,6 +7160,10 @@ say that without the component knowing what a row looks like. */
   "loading-text"?: (HelixMenu["loadingText"]) | undefined;
   /** What is said while they are on their way. */
   loadingText?: (HelixMenu["loadingText"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixMenu["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixMenu["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -6243,10 +7177,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?: (HelixMenu["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixMenu["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixMenu["defaultOpen"]) | undefined;
   /** What the row returning from a submenu reads. */
   "back-label"?: (HelixMenu["backLabel"]) | undefined;
   /** What the row returning from a submenu reads. */
@@ -6406,6 +7336,10 @@ export type HelixNotificationGroupHelixBeforeOpenElementEvent =
   HelixNotificationGroupElementEvent<HelixBeforeOpenEvent>;
 
 export type HelixNotificationGroupVueProps = {
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixNotificationGroup["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixNotificationGroup["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -6419,10 +7353,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?: (HelixNotificationGroup["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixNotificationGroup["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixNotificationGroup["defaultOpen"]) | undefined;
   /** Whether the group can be collapsed to its first row.
 
 Off by default, because a group is a heading before it is a control: a feed
@@ -6504,6 +7434,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?: (HelixNotification["at"]) | undefined;
+  /** State to open with, where nothing declared one. */
+  "default-read"?: (HelixNotification["defaultRead"]) | undefined;
+  /** State to open with, where nothing declared one. */
+  defaultRead?: (HelixNotification["defaultRead"]) | undefined;
+  /** Locale for the timestamp.
+
+Empty is the runtime's own. */
+  locale?: (HelixNotification["locale"]) | undefined;
   /** Whether the reader has seen it.
 
 Set it and this element defers: a reader's click fires `helix-read` and
@@ -6518,14 +7456,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?: (HelixNotification["read"]) | undefined;
-  /** State to open with, where nothing declared one. */
-  "default-read"?: (HelixNotification["defaultRead"]) | undefined;
-  /** State to open with, where nothing declared one. */
-  defaultRead?: (HelixNotification["defaultRead"]) | undefined;
-  /** Locale for the timestamp.
-
-Empty is the runtime's own. */
-  locale?: (HelixNotification["locale"]) | undefined;
 };
 
 export type HelixNotificationVueEvents = {
@@ -6610,6 +7540,26 @@ a reset should return to. */
   label?: (HelixNumberInput["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixNumberInput["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"?: (HelixNumberInput["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?: (HelixNumberInput["valueMissingMessage"]) | undefined;
   /** What the browser may autofill here, as one of the platform's own tokens.
 
 Empty leaves the attribute off, which is the browser's default and is what
@@ -6617,6 +7567,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?: (HelixNumberInput["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"?: (HelixNumberInput["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?: (HelixNumberInput["badInputMessage"]) | undefined;
   /** Accessible name for the control that steps down. */
   "decrement-label"?: (HelixNumberInput["decrementLabel"]) | undefined;
   /** Accessible name for the control that steps down. */
@@ -6649,6 +7613,14 @@ Absent has no floor. */
 
 Not a label: it goes when typing starts. */
   placeholder?: (HelixNumberInput["placeholder"]) | undefined;
+  /** What a reader is told when the number is above `max`, with `{max}` filled in. */
+  "range-overflow-message"?: (HelixNumberInput["rangeOverflowMessage"]) | undefined;
+  /** What a reader is told when the number is above `max`, with `{max}` filled in. */
+  rangeOverflowMessage?: (HelixNumberInput["rangeOverflowMessage"]) | undefined;
+  /** What a reader is told when the number is below `min`, with `{min}` filled in. */
+  "range-underflow-message"?: (HelixNumberInput["rangeUnderflowMessage"]) | undefined;
+  /** What a reader is told when the number is below `min`, with `{min}` filled in. */
+  rangeUnderflowMessage?: (HelixNumberInput["rangeUnderflowMessage"]) | undefined;
   /** Whether the field refuses input while still submitting its value. */
   readonly?: (HelixNumberInput["readOnly"]) | undefined;
   /** Whether the field refuses input while still submitting its value. */
@@ -6717,6 +7689,22 @@ export type HelixObjectInspectorHelixCopyElementEvent =
   HelixObjectInspectorElementEvent<HelixCopyEvent>;
 
 export type HelixObjectInspectorVueProps = {
+  /** 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"?: (HelixObjectInspector["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?: (HelixObjectInspector["copyLabel"]) | undefined;
+  /** What the copy control is called where there is no key, on the value itself. */
+  "copy-value-label"?: (HelixObjectInspector["copyValueLabel"]) | undefined;
+  /** What the copy control is called where there is no key, on the value itself. */
+  copyValueLabel?: (HelixObjectInspector["copyValueLabel"]) | undefined;
   /** How many levels start open.
 
 One by default: the root is open and everything under it closed, so a
@@ -7018,21 +8006,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?: (HelixPagination["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?: (HelixPagination["page"]) | undefined;
   /** Accessible name for the control that jumps to the first page. */
   "first-label"?: (HelixPagination["firstLabel"]) | undefined;
   /** Accessible name for the control that jumps to the first page. */
@@ -7069,6 +8042,21 @@ different address from `?page=1234`. */
   "next-label"?: (HelixPagination["nextLabel"]) | undefined;
   /** Accessible name for the control that moves forward. */
   nextLabel?: (HelixPagination["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?: (HelixPagination["page"]) | undefined;
   /** Accessible name for one page, with `{page}` and `{pages}` filled in. */
   "page-label"?: (HelixPagination["pageLabel"]) | undefined;
   /** Accessible name for one page, with `{page}` and `{pages}` filled in. */
@@ -7144,12 +8132,6 @@ export type HelixPaginationSizeVueProps = {
   "default-value"?: (HelixPaginationSize["defaultValue"] | `${number}`) | undefined;
   /** Size to start on, where nothing declared one. */
   defaultValue?: (HelixPaginationSize["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?: (HelixPaginationSize["value"]) | undefined;
   /** The words beside the control. */
   label?: (HelixPaginationSize["label"]) | undefined;
   /** Locale for the numbers.
@@ -7162,6 +8144,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?: (HelixPaginationSize["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?: (HelixPaginationSize["value"]) | undefined;
 };
 
 export type HelixPaginationSizeVueEvents = {
@@ -7229,6 +8217,26 @@ a reset should return to. */
   label?: (HelixPinInput["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixPinInput["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"?: (HelixPinInput["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?: (HelixPinInput["valueMissingMessage"]) | undefined;
   /** What the browser may autofill, reaching the first cell only.
 
 `one-time-code` is why this defaults to anything at all: it is the token
@@ -7258,6 +8266,12 @@ Empty by default, because a row of boxes already reads as a row of boxes. */
   readonly?: (HelixPinInput["readOnly"]) | undefined;
   /** Whether the boxes refuse input while still submitting their value. */
   readOnly?: (HelixPinInput["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"?: (HelixPinInput["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?: (HelixPinInput["tooShortMessage"]) | undefined;
   /** What a box accepts, which decides the keyboard a phone offers.
 
 `numeric` and `alphanumeric` also refuse anything else on the way in,
@@ -7339,6 +8353,10 @@ Unset is a surface with an inset, which is what a panel of content wants.
 `plain` removes both, for a panel holding something that brings its own,
 such as a list whose rows run to the edges. */
   separation?: (HelixPopover["separation"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixPopover["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixPopover["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -7352,10 +8370,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?: (HelixPopover["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixPopover["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixPopover["defaultOpen"]) | undefined;
   /** Accessible name for the panel. */
   label?: (HelixPopover["label"]) | undefined;
   /** Space between the trigger and the panel, in pixels. */
@@ -7540,6 +8554,26 @@ a reset should return to. */
   label?: (HelixRadioGroup["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixRadioGroup["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"?: (HelixRadioGroup["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?: (HelixRadioGroup["valueMissingMessage"]) | undefined;
   /** Which way the choices run. A column reads one line per answer.
 
 **Optional rather than defaulted, which is not a style preference.** A
@@ -7771,6 +8805,26 @@ a reset should return to. */
   label?: (HelixRating["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixRating["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"?: (HelixRating["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?: (HelixRating["valueMissingMessage"]) | undefined;
   /** How many marks there are. */
   max?: (HelixRating["max"]) | undefined;
   /** The lowest score a reader can give, which is what clearing returns to.
@@ -8281,6 +9335,10 @@ are left alone rather than swept, because each has a different thing inside
 the frame and guessing at a set of them is how an axis ends up meaning four
 things, which is the fault `appearance` was retired for. */
   emphasis?: (HelixSelect["emphasis"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixSelect["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixSelect["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -8294,10 +9352,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?: (HelixSelect["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixSelect["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixSelect["defaultOpen"]) | undefined;
   /** The value the markup declared, which is where a reset returns to. */
   "default-value"?: (HelixSelect["defaultValue"]) | undefined;
   /** The value the markup declared, which is where a reset returns to. */
@@ -8317,6 +9371,26 @@ a reset should return to. */
   label?: (HelixSelect["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixSelect["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"?: (HelixSelect["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?: (HelixSelect["valueMissingMessage"]) | undefined;
   /** What it says where there are none. */
   "empty-text"?: (HelixSelect["emptyText"]) | undefined;
   /** What it says where there are none. */
@@ -8442,6 +9516,26 @@ a reset should return to. */
   label?: (HelixSlider["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixSlider["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"?: (HelixSlider["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?: (HelixSlider["valueMissingMessage"]) | undefined;
   /** Whether each mark says which value it stands at. */
   "marker-labels"?: (HelixSlider["markerLabels"]) | undefined;
   /** Whether each mark says which value it stands at. */
@@ -8462,8 +9556,28 @@ is the honest picture of the range being offered. */
   markers?: (HelixSlider["markers"]) | undefined;
   /** The largest value the reader can choose. */
   max?: (HelixSlider["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"?: (HelixSlider["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?: (HelixSlider["maximumLabel"]) | undefined;
   /** The smallest value the reader can choose. */
   min?: (HelixSlider["min"]) | undefined;
+  /** What the lower thumb of a range is called, after the slider's own label. */
+  "minimum-label"?: (HelixSlider["minimumLabel"]) | undefined;
+  /** What the lower thumb of a range is called, after the slider's own label. */
+  minimumLabel?: (HelixSlider["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
@@ -8702,6 +9816,10 @@ export type HelixSpeedDialHelixSelectElementEvent =
   HelixSpeedDialElementEvent<HelixSelectEvent>;
 
 export type HelixSpeedDialVueProps = {
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixSpeedDial["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixSpeedDial["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -8715,10 +9833,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?: (HelixSpeedDial["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixSpeedDial["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixSpeedDial["defaultOpen"]) | undefined;
   /** Names the trigger and the set of actions it opens. */
   label?: (HelixSpeedDial["label"]) | undefined;
   /** Space between the trigger and the actions, in pixels. */
@@ -8767,6 +9881,32 @@ line can be grabbed. The grip adds no hit area of its own.
 Both are writable, so a generated page can say which it means rather than
 relying on the absence of an attribute. */
   variant?: (HelixSplitter["variant"]) | 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?: (HelixSplitter["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"?: (HelixSplitter["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?: (HelixSplitter["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
@@ -8781,28 +9921,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?: (HelixSplitter["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?: (HelixSplitter["position"]) | undefined;
   /** Accessible name for the handle where two dividers cross. */
   "corner-label"?: (HelixSplitter["cornerLabel"]) | undefined;
   /** Accessible name for the handle where two dividers cross. */
   cornerLabel?: (HelixSplitter["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?: (HelixSplitter["collapsed"]) | undefined;
   /** Which pane starts shut, where nothing declared it. */
   "default-collapsed"?: (HelixSplitter["defaultCollapsed"]) | undefined;
   /** Which pane starts shut, where nothing declared it. */
@@ -8858,6 +9980,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?: (HelixSplitter["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?: (HelixSplitter["position"]) | undefined;
   /** How far one arrow press moves it, as a percentage. */
   step?: (HelixSplitter["step"]) | undefined;
 };
@@ -9024,6 +10152,26 @@ stylesheets. */
   label?: (HelixSwitch["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixSwitch["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"?: (HelixSwitch["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?: (HelixSwitch["valueMissingMessage"]) | undefined;
   /** Value submitted when the switch is on. */
   value?: (HelixSwitch["value"]) | undefined;
   /** Whether the control is non-interactive.
@@ -9094,6 +10242,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?: (HelixTableColumn["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"?: (HelixTableColumn["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?: (HelixTableColumn["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
@@ -9101,6 +10261,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?: (HelixTableColumn["resizable"]) | undefined;
+  /** What the separator that resizes the column is called, with the heading's
+words as `{name}`. */
+  "resize-label"?: (HelixTableColumn["resizeLabel"]) | undefined;
+  /** What the separator that resizes the column is called, with the heading's
+words as `{name}`. */
+  resizeLabel?: (HelixTableColumn["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
@@ -9195,6 +10361,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?: (HelixTableColumn["width"]) | undefined;
+  /** How the separator reads out the column's width, with `{width}` filled in. */
+  "width-label"?: (HelixTableColumn["widthLabel"]) | undefined;
+  /** How the separator reads out the column's width, with `{width}` filled in. */
+  widthLabel?: (HelixTableColumn["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
@@ -9511,6 +10681,26 @@ a reset should return to. */
   label?: (HelixTextarea["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixTextarea["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"?: (HelixTextarea["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?: (HelixTextarea["valueMissingMessage"]) | undefined;
   /** What the browser may autofill here, as one of the platform's own tokens.
 
 Empty leaves the attribute off, which is the browser's default. Set it to
@@ -9670,6 +10860,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?: (HelixTimeInput["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"?: (HelixTimeInput["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?: (HelixTimeInput["badInputMessage"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixTimeInput["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixTimeInput["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -9683,10 +10893,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?: (HelixTimeInput["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixTimeInput["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixTimeInput["defaultOpen"]) | undefined;
   /** What the control is called once everything is showing. */
   "collapse-label"?: (HelixTimeInput["collapseLabel"]) | undefined;
   /** What the control is called once everything is showing. */
@@ -9720,6 +10926,26 @@ a reset should return to. */
   label?: (HelixTimeInput["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixTimeInput["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"?: (HelixTimeInput["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?: (HelixTimeInput["valueMissingMessage"]) | undefined;
   /** What the browser may autofill here, as one of the platform's own tokens.
 
 Empty leaves the attribute off, which is the browser's default and is what
@@ -9742,6 +10968,40 @@ on why a wheel cannot do either. */
   mode?: (HelixTimeInput["mode"]) | undefined;
   /** What the field says before a time is in it. */
   placeholder?: (HelixTimeInput["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"?: (HelixTimeInput["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?: (HelixTimeInput["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"?: (HelixTimeInput["rangeOverflowMessage"]) | undefined;
+  /** What a reader is told when a time is after `max`, with `{max}` filled in
+as the field writes it. */
+  rangeOverflowMessage?: (HelixTimeInput["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"?: (HelixTimeInput["rangeUnderflowMessage"]) | undefined;
+  /** What a reader is told when a time is before `min`, with `{min}` filled
+in as the field writes it. */
+  rangeUnderflowMessage?: (HelixTimeInput["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"?: (HelixTimeInput["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?: (HelixTimeInput["removeLabel"]) | undefined;
   /** How far apart the offered times are, in minutes. */
   step?: (HelixTimeInput["step"]) | undefined;
   /** Whether the field writes the time out, or holds the value as it is.
@@ -9850,6 +11110,18 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixTimePicker["value"]) | 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. */
+  "bad-input-message"?: (HelixTimePicker["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?: (HelixTimePicker["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
@@ -9940,6 +11212,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?: (HelixTimePicker["step"]) | undefined;
+  /** What a reader is told when a time is required and none is chosen. */
+  "value-missing-message"?: (HelixTimePicker["valueMissingMessage"]) | undefined;
+  /** What a reader is told when a time is required and none is chosen. */
+  valueMissingMessage?: (HelixTimePicker["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
@@ -10063,10 +11339,6 @@ would catch. */
 Read once when the item is first rendered. Changing it afterwards does not
 restart a message the reader is already partway through. */
   duration?: (HelixToastItem["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?: (HelixToastItem["tone"]) | undefined;
   /** Whether the message is still showing.
 
 The item always applies: it goes when it is asked to, having announced
@@ -10079,6 +11351,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?: (HelixToastItem["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?: (HelixToastItem["tone"]) | undefined;
 };
 
 export type HelixToastItemVueEvents = {
@@ -10174,6 +11450,26 @@ a reset should return to. */
   label?: (HelixToggleGroup["label"]) | undefined;
   /** Whether the form refuses to submit without it. */
   required?: (HelixToggleGroup["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"?: (HelixToggleGroup["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?: (HelixToggleGroup["valueMissingMessage"]) | undefined;
   /** Where the group's label sits, `start` putting it on the track's line.
 
 Absent is above, which is what a field looks like and what almost every
@@ -10348,6 +11644,10 @@ content is only readable because it has a ground; dropping it makes an
 unreadable tooltip rather than a lighter one. `frosted` and `glass` are the
 two honest points here. */
   material?: (HelixTooltip["material"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixTooltip["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixTooltip["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -10361,10 +11661,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?: (HelixTooltip["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixTooltip["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixTooltip["defaultOpen"]) | undefined;
   /** The text shown in the bubble.
 
 The common case, and the fallback for the `content` slot: slot something
@@ -10473,6 +11769,14 @@ export type HelixTourVueProps = {
   "back-label"?: (HelixTour["backLabel"]) | undefined;
   /** Label for the control that goes back, handed to every stop. */
   backLabel?: (HelixTour["backLabel"]) | undefined;
+  /** Stop to start on, where nothing declared one. */
+  "default-index"?: (HelixTour["defaultIndex"] | `${number}`) | undefined;
+  /** Stop to start on, where nothing declared one. */
+  defaultIndex?: (HelixTour["defaultIndex"]) | undefined;
+  /** Label for the control that goes on from the last stop. */
+  "done-label"?: (HelixTour["doneLabel"]) | undefined;
+  /** Label for the control that goes on from the last stop. */
+  doneLabel?: (HelixTour["doneLabel"]) | undefined;
   /** Which stop the reader is on.
 
 **Moved through `requestChange`, never by assignment from `move`.** That
@@ -10484,14 +11788,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?: (HelixTour["index"]) | undefined;
-  /** Stop to start on, where nothing declared one. */
-  "default-index"?: (HelixTour["defaultIndex"] | `${number}`) | undefined;
-  /** Stop to start on, where nothing declared one. */
-  defaultIndex?: (HelixTour["defaultIndex"]) | undefined;
-  /** Label for the control that goes on from the last stop. */
-  "done-label"?: (HelixTour["doneLabel"]) | undefined;
-  /** Label for the control that goes on from the last stop. */
-  doneLabel?: (HelixTour["doneLabel"]) | undefined;
   /** Accessible name for the run, such as "Getting started". */
   label?: (HelixTour["label"]) | undefined;
   /** Label for the control that goes on. */
@@ -10580,6 +11876,10 @@ export type HelixTreeItemHelixBeforeOpenElementEvent =
   HelixTreeItemElementEvent<HelixBeforeOpenEvent>;
 
 export type HelixTreeItemVueProps = {
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  "default-open"?: (HelixTreeItem["defaultOpen"]) | undefined;
+  /** Whether the markup declared it open. Ignored once `open` is written. */
+  defaultOpen?: (HelixTreeItem["defaultOpen"]) | undefined;
   /** Whether the element is open.
 
 One property, not two, so `dialog.open` answers the question anyone
@@ -10593,10 +11893,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?: (HelixTreeItem["open"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  "default-open"?: (HelixTreeItem["defaultOpen"]) | undefined;
-  /** Whether the markup declared it open. Ignored once `open` is written. */
-  defaultOpen?: (HelixTreeItem["defaultOpen"]) | undefined;
   /** Where this node goes, which makes its row a real link.
 
 Unset by default, and unreflected: a tree of choosable nodes is not a tree
@@ -10965,6 +12261,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?: (HelixVideo["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"?: (HelixVideo["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?: (HelixVideo["captionsLabel"]) | undefined;
+  /** The row that turns captions off, where the video has several tracks to choose from. */
+  "captions-off-label"?: (HelixVideo["captionsOffLabel"]) | undefined;
+  /** The row that turns captions off, where the video has several tracks to choose from. */
+  captionsOffLabel?: (HelixVideo["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
@@ -11002,6 +12314,10 @@ meaning something else. */
   disableremoteplayback?: (HelixVideo["disableRemotePlayback"]) | undefined;
   /** Whether the browser may offer playback on a remote device. */
   disableRemotePlayback?: (HelixVideo["disableRemotePlayback"]) | undefined;
+  /** What the control that saves the file is called. */
+  "download-label"?: (HelixVideo["downloadLabel"]) | undefined;
+  /** What the control that saves the file is called. */
+  downloadLabel?: (HelixVideo["downloadLabel"]) | undefined;
   /** And what they are told when it will not play at all. */
   "error-label"?: (HelixVideo["errorLabel"]) | undefined;
   /** And what they are told when it will not play at all. */
@@ -11066,6 +12382,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?: (HelixVideo["extraControls"]) | undefined;
+  /** What the control that skips ahead is called, with `{seconds}` filled in. */
+  "forward-label"?: (HelixVideo["forwardLabel"]) | undefined;
+  /** What the control that skips ahead is called, with `{seconds}` filled in. */
+  forwardLabel?: (HelixVideo["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"?: (HelixVideo["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?: (HelixVideo["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
@@ -11094,6 +12426,18 @@ regardless, because a reader who stopped it is deciding what to do next. */
   loadingLabel?: (HelixVideo["loadingLabel"]) | undefined;
   /** Whether it starts again at the end. */
   loop?: (HelixVideo["loop"]) | undefined;
+  /** What the button that opens `overflow-controls` is called. */
+  "more-label"?: (HelixVideo["moreLabel"]) | undefined;
+  /** What the button that opens `overflow-controls` is called. */
+  moreLabel?: (HelixVideo["moreLabel"]) | undefined;
+  /** What the control that silences the video is called, pressed while it is silent. */
+  "mute-label"?: (HelixVideo["muteLabel"]) | undefined;
+  /** What the control that silences the video is called, pressed while it is silent. */
+  muteLabel?: (HelixVideo["muteLabel"]) | undefined;
+  /** What the control that asks for the next video is called. */
+  "next-label"?: (HelixVideo["nextLabel"]) | undefined;
+  /** What the control that asks for the next video is called. */
+  nextLabel?: (HelixVideo["nextLabel"]) | undefined;
   /** Controls that go behind one button instead of onto the bar, named the same
 way.
 
@@ -11130,6 +12474,14 @@ bar: two of the same control is worse than either placement. */
   "pause-label"?: (HelixVideo["pauseLabel"]) | undefined;
   /** And while it would stop it. */
   pauseLabel?: (HelixVideo["pauseLabel"]) | undefined;
+  /** How the volume is read out, with `{percent}` filled in. */
+  "percent-label"?: (HelixVideo["percentLabel"]) | undefined;
+  /** How the volume is read out, with `{percent}` filled in. */
+  percentLabel?: (HelixVideo["percentLabel"]) | undefined;
+  /** What the control that floats the video over other windows is called. */
+  "pip-label"?: (HelixVideo["pipLabel"]) | undefined;
+  /** What the control that floats the video over other windows is called. */
+  pipLabel?: (HelixVideo["pipLabel"]) | undefined;
   /** What the play control is called while it would start the video. */
   "play-label"?: (HelixVideo["playLabel"]) | undefined;
   /** What the play control is called while it would start the video. */
@@ -11142,6 +12494,26 @@ bar: two of the same control is worse than either placement. */
   poster?: (HelixVideo["poster"]) | undefined;
   /** How much to fetch before anything is asked for. */
   preload?: (HelixVideo["preload"]) | undefined;
+  /** What the control that asks for the previous video is called. */
+  "previous-label"?: (HelixVideo["previousLabel"]) | undefined;
+  /** What the control that asks for the previous video is called. */
+  previousLabel?: (HelixVideo["previousLabel"]) | undefined;
+  /** What the control that casts the video to another device is called. */
+  "remote-label"?: (HelixVideo["remoteLabel"]) | undefined;
+  /** What the control that casts the video to another device is called. */
+  remoteLabel?: (HelixVideo["remoteLabel"]) | undefined;
+  /** What the control that skips back is called, with `{seconds}` filled in. */
+  "rewind-label"?: (HelixVideo["rewindLabel"]) | undefined;
+  /** What the control that skips back is called, with `{seconds}` filled in. */
+  rewindLabel?: (HelixVideo["rewindLabel"]) | undefined;
+  /** What the scrubber is called. */
+  "seek-label"?: (HelixVideo["seekLabel"]) | undefined;
+  /** What the scrubber is called. */
+  seekLabel?: (HelixVideo["seekLabel"]) | undefined;
+  /** What the control that changes the speed is called. */
+  "speed-label"?: (HelixVideo["speedLabel"]) | undefined;
+  /** What the control that changes the speed is called. */
+  speedLabel?: (HelixVideo["speedLabel"]) | undefined;
   /** The speeds offered, slowest first, as multipliers of normal. */
   speeds?: (HelixVideo["speeds"]) | undefined;
   /** Where the video is, for the common case of one file. */
@@ -11178,6 +12550,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?: (HelixVideo["startControl"]) | undefined;
+  /** What the menu of tracks is called, where the video has several. */
+  "subtitles-label"?: (HelixVideo["subtitlesLabel"]) | undefined;
+  /** What the menu of tracks is called, where the video has several. */
+  subtitlesLabel?: (HelixVideo["subtitlesLabel"]) | undefined;
+  /** How the scrubber reads out where the video is, with `{position}` and
+`{duration}` filled in. */
+  "time-label"?: (HelixVideo["timeLabel"]) | undefined;
+  /** How the scrubber reads out where the video is, with `{position}` and
+`{duration}` filled in. */
+  timeLabel?: (HelixVideo["timeLabel"]) | undefined;
+  /** What the volume slider is called. */
+  "volume-label"?: (HelixVideo["volumeLabel"]) | undefined;
+  /** What the volume slider is called. */
+  volumeLabel?: (HelixVideo["volumeLabel"]) | undefined;
   /** Where playback has reached, in seconds.
 
 Writing seeks, through the same clamp `seek` uses, because a `currentTime`
@@ -11347,6 +12733,40 @@ export type CustomCssProperties = {
   "--callout-background-color"?: (string) | undefined;
   /** Corner radius of the callout. */
   "--callout-radius"?: (string) | undefined;
+  /** How large the corners a selected card is resized from are. */
+  "--canvas-grip-size"?: (string) | undefined;
+  /** How large the points a connection is drawn from are. */
+  "--canvas-handle-size"?: (string) | undefined;
+  /** How tall the grip a selected card is moved by is. */
+  "--canvas-move-block-size"?: (string) | undefined;
+  /** How wide the grip a selected card is moved by is. */
+  "--canvas-move-inline-size"?: (string) | undefined;
+  /** How far in from the card's corner that grip sits. */
+  "--canvas-move-inset"?: (string) | undefined;
+  /** The ground the card is drawn on. */
+  "--canvas-node-background-color"?: (string) | undefined;
+  /** A color with no meaning, where a tone will not do: a hex a document chose. */
+  "--canvas-node-color"?: (string) | undefined;
+  /** Space between the card's edge and what it holds. */
+  "--canvas-node-padding"?: (string) | undefined;
+  /** The lift under the card, which `separation="elevated"` sets. */
+  "--canvas-node-shadow"?: (string) | undefined;
+  /** The well behind the board. */
+  "--canvas-background-color"?: (string) | undefined;
+  /** How tall the frame is. */
+  "--canvas-block-size"?: (string) | undefined;
+  /** Color of the frame's edge. */
+  "--canvas-border-color"?: (string) | undefined;
+  /** Color of a connector with no tone. Written in an edge's own `style`, it colors that edge alone. */
+  "--canvas-edge-color"?: (string) | undefined;
+  /** How wide a connector is to a pointer, which is wider than it is drawn. */
+  "--canvas-edge-target-width"?: (string) | undefined;
+  /** How far apart the ruling is, in the document's own units, so it scales with the zoom. */
+  "--canvas-grid-size"?: (string) | undefined;
+  /** How wide the field a label is edited in is. */
+  "--canvas-label-editor-inline-size"?: (string) | undefined;
+  /** The ground under the pan and zoom buttons, one name with `Map`. */
+  "--viewport-control-background-color"?: (string) | undefined;
   /** How the regions pack when the card is stretched taller than its content. `start` by default, so the slack is at the bottom; `space-between` puts a footer on the floor. */
   "--card-align"?: (string) | undefined;
   /** Filter applied behind a `frosted` or `glass` card. Follows the theme's material policy; set it to override the strength on one card. */
@@ -11777,8 +13197,6 @@ export type CustomCssProperties = {
   "--map-block-size"?: (string) | undefined;
   /** Color of the frame's edge. */
   "--map-border-color"?: (string) | undefined;
-  /** The ground under the pan and zoom buttons. */
-  "--map-control-background-color"?: (string) | undefined;
   /** A filter behind the panel, which is `none` until one is asked for: this family carries no `material`, so the pair is two hooks rather than a word. */
   "--megamenu-backdrop"?: (string) | undefined;
   /** The panel's own fill. */
@@ -12389,6 +13807,24 @@ export interface WcToolkitVueGlobalComponents {
     HelixCalloutVueProps,
     HelixCalloutVueEvents
   >;
+  /** Draws nothing and takes no room: the board draws every connector into one layer under the cards, which is the only place a line between two of them can be drawn. What this element carries is which cards and which sides. */
+  "helix-canvas-edge": DefineCustomElement<
+    HelixCanvasEdge,
+    HelixCanvasEdgeVueProps,
+    HelixCanvasEdgeVueEvents
+  >;
+  /** The card is the host, because the board places the host: its coordinates are written onto this element, so a wrapper inside would have to be told the same things twice.  **Before it is placed it is a card in the flow**, which is what a page without JavaScript has: the text somebody wrote, in the order they wrote it, rather than a heap at the origin. */
+  "helix-canvas-node": DefineCustomElement<
+    HelixCanvasNode,
+    HelixCanvasNodeVueProps,
+    HelixCanvasNodeVueEvents
+  >;
+  /** **Cards and connections say what they mean with 'tone'**, the word every other family uses, and the tones resolve to semantic tokens, so a board follows the page into dark mode rather than carrying somebody else's hex into it. JSON Canvas's six color presets arrive as tones through 'fromJsonCanvas'.  The plane is the one thing that moves: panning and zooming write three custom properties and one transform reads them, so the cards are placed once in the document's own coordinates and never laid out again. */
+  "helix-canvas": DefineCustomElement<
+    HelixCanvas,
+    HelixCanvasVueProps,
+    HelixCanvasVueEvents
+  >;
   /** Regions are bare slots with no wrapper element: 'media', 'header', the default slot for content, and 'footer'. An omitted one occupies no space without the card having to detect that it is missing, so a card with only content needs no wrapper markup at all. Style slotted content directly rather than reaching for a part: a header is whatever element you slotted, not a wrapper around it.  'media' runs edge to edge and clips to the card's corners, so an image needs no inset correction. Set 'orientation="horizontal"' to move it alongside the header, content, and footer stack rather than above it, or 'media-placement="end"' to put it under the content instead of over it, which is what a chart concluding a card wants. */
   "helix-card": DefineCustomElement<
     HelixCard,