@fusion.dev/helix 0.215.3 → 0.216.0

package/types/vue.d.ts

@@ -18,6 +18,7 @@ import type {
   HelixBeforeCloseEvent,
   HelixBeforeCollapseEvent,
   HelixBeforeEditEvent,
+  HelixBeforeListenEvent,
   HelixBeforeMoveEvent,
   HelixBeforeOpenEvent,
   HelixBeforePanelResizeEvent,
@@ -53,6 +54,8 @@ import type {
   HelixClearEvent,
   HelixCode,
   HelixCodeBlock,
+  HelixCodeEditor,
+  HelixCodeInput,
   HelixCollapseEvent,
   HelixColorInput,
   HelixColorPicker,
@@ -124,6 +127,7 @@ import type {
   HelixList,
   HelixListItem,
   HelixListbox,
+  HelixListenEvent,
   HelixLoadEvent,
   HelixLoadMoreEvent,
   HelixLoader,
@@ -148,6 +152,7 @@ import type {
   HelixMapTerrain,
   HelixMapTiltEvent,
   HelixMapZoomEvent,
+  HelixMarkdown,
   HelixMegamenu,
   HelixMenu,
   HelixMenuItem,
@@ -215,6 +220,7 @@ import type {
   HelixSelectedEvent,
   HelixSendEvent,
   HelixShortcutEvent,
+  HelixShortcutOverlay,
   HelixSkeleton,
   HelixSkipLink,
   HelixSlider,
@@ -843,6 +849,31 @@ beside its buttons and as each page arrives. `{first}`, `{last}` and
 beside its buttons and as each page arrives. `{first}`, `{last}` and
 `{count}` are replaced with the numbers, written in `locale`. */
   readingsLabel?: (HelixAreaChart["readingsLabel"]) | undefined;
+  /** Draws a Listen button that plays the chart as sound: each series in
+turn, its readings from left to right and from the left ear to the
+right, the value as pitch over two octaves, a soft tick at each
+gridline, and one timbre a series. With it, each reading the arrow keys
+step to plays its tone beside what the readout says, and L plays the
+whole chart while it has focus. Escape stops it. Nothing plays without a
+press, and the sound is made only then. */
+  sonify?: (HelixAreaChart["sonify"]) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  "sonify-duration"?: (HelixAreaChart["sonifyDuration"] | `${number}`) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  sonifyDuration?: (HelixAreaChart["sonifyDuration"]) | undefined;
+  /** The Listen button's words. */
+  "sonify-label"?: (HelixAreaChart["sonifyLabel"]) | undefined;
+  /** The Listen button's words. */
+  sonifyLabel?: (HelixAreaChart["sonifyLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  "sonify-stop-label"?: (HelixAreaChart["sonifyStopLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  sonifyStopLabel?: (HelixAreaChart["sonifyStopLabel"]) | undefined;
+  /** `visible` draws the chart's text summary under it, as one line.
+`hidden`, or absent, says the summary to a screen reader and draws it
+for no one else. Reflected, because the stylesheet draws it by the
+attribute, and a page that sets the property, as React does, writes none. */
+  summary?: (HelixAreaChart["summary"]) | undefined;
   /** How a band's edge gets from one reading to the next.
 
 Three values, and the class doc argues for each: `straight` is absent and
@@ -1476,6 +1507,31 @@ beside its buttons and as each page arrives. `{first}`, `{last}` and
 beside its buttons and as each page arrives. `{first}`, `{last}` and
 `{count}` are replaced with the numbers, written in `locale`. */
   readingsLabel?: (HelixBarChart["readingsLabel"]) | undefined;
+  /** Draws a Listen button that plays the chart as sound: each series in
+turn, its readings from left to right and from the left ear to the
+right, the value as pitch over two octaves, a soft tick at each
+gridline, and one timbre a series. With it, each reading the arrow keys
+step to plays its tone beside what the readout says, and L plays the
+whole chart while it has focus. Escape stops it. Nothing plays without a
+press, and the sound is made only then. */
+  sonify?: (HelixBarChart["sonify"]) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  "sonify-duration"?: (HelixBarChart["sonifyDuration"] | `${number}`) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  sonifyDuration?: (HelixBarChart["sonifyDuration"]) | undefined;
+  /** The Listen button's words. */
+  "sonify-label"?: (HelixBarChart["sonifyLabel"]) | undefined;
+  /** The Listen button's words. */
+  sonifyLabel?: (HelixBarChart["sonifyLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  "sonify-stop-label"?: (HelixBarChart["sonifyStopLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  sonifyStopLabel?: (HelixBarChart["sonifyStopLabel"]) | undefined;
+  /** `visible` draws the chart's text summary under it, as one line.
+`hidden`, or absent, says the summary to a screen reader and draws it
+for no one else. Reflected, because the stylesheet draws it by the
+attribute, and a page that sets the property, as React does, writes none. */
+  summary?: (HelixBarChart["summary"]) | undefined;
   /** Which gridlines are drawn across the plot, if any.
 
 Absent draws none. `value` rules the axis the columns are *measured* on,
@@ -3433,6 +3489,12 @@ export type HelixChatComposerElementEvent<E = Event> = TypedEvent<
   HelixChatComposer,
   E
 >;
+/** `helix-before-listen` event type */
+export type HelixChatComposerHelixBeforeListenElementEvent =
+  HelixChatComposerElementEvent<HelixBeforeListenEvent>;
+/** `helix-listen` event type */
+export type HelixChatComposerHelixListenElementEvent =
+  HelixChatComposerElementEvent<HelixListenEvent>;
 /** `helix-send` event type */
 export type HelixChatComposerHelixSendElementEvent =
   HelixChatComposerElementEvent<HelixSendEvent>;
@@ -3441,6 +3503,27 @@ export type HelixChatComposerHelixTypingElementEvent =
   HelixChatComposerElementEvent<HelixTypingEvent>;
 
 export type HelixChatComposerVueProps = {
+  /** What a screen reader hears as listening starts. */
+  "listening-label"?: (HelixChatComposer["listeningLabel"]) | undefined;
+  /** What a screen reader hears as listening starts. */
+  listeningLabel?: (HelixChatComposer["listeningLabel"]) | undefined;
+  /** What a screen reader hears as listening stops. */
+  "stopped-listening-label"?: (HelixChatComposer["stoppedListeningLabel"]) | undefined;
+  /** What a screen reader hears as listening stops. */
+  stoppedListeningLabel?: (HelixChatComposer["stoppedListeningLabel"]) | undefined;
+  /** Draws a button that listens for dictation and types what it hears at
+the caret. Nothing listens until the button is pressed, and the
+microphone is let go as listening stops. An input of type `password`,
+`email` or `number` draws no button. */
+  voice?: (HelixChatComposer["voice"]) | undefined;
+  /** The dictation button's name while it is not listening. */
+  "voice-label"?: (HelixChatComposer["voiceLabel"]) | undefined;
+  /** The dictation button's name while it is not listening. */
+  voiceLabel?: (HelixChatComposer["voiceLabel"]) | undefined;
+  /** The dictation button's name while it listens. */
+  "voice-stop-label"?: (HelixChatComposer["voiceStopLabel"]) | undefined;
+  /** The dictation button's name while it listens. */
+  voiceStopLabel?: (HelixChatComposer["voiceStopLabel"]) | undefined;
   /** A message about the draft, shown under the field. While set, the composer
 is invalid, does not send, and does not submit, as a field's `feedback`
 does, and the message is announced as it appears. */
@@ -3521,9 +3604,16 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixChatComposer["name"]) | undefined;
+  /** The engine this field listens through, in place of the one
+`registerSpeechEngine` gave the page, or the browser's own. */
+  speechEngine?: (HelixChatComposer["speechEngine"]) | undefined;
 };
 
 export type HelixChatComposerVueEvents = {
+  /** The dictation button was pressed. Cancelable: cancel it to keep the composer from listening. */
+  "helix-before-listen": HelixChatComposerHelixBeforeListenElementEvent;
+  /** Dictation settled on a phrase and put it in the draft, after the draft's own `input`. */
+  "helix-listen": HelixChatComposerHelixListenElementEvent;
   /** Fired when the user sends their turn, and cancelable. */
   "helix-send": HelixChatComposerHelixSendElementEvent;
   /** The user started or stopped writing, with `typing` saying which, as the composer's `typing` does. */
@@ -4342,6 +4432,476 @@ export type HelixCodeBlockVueEvents = {
   "helix-toggle": HelixCodeBlockHelixToggleElementEvent;
 };
 
+/** `HelixCodeEditor` component event */
+export type HelixCodeEditorElementEvent<E = Event> = TypedEvent<
+  HelixCodeEditor,
+  E
+>;
+/** `helix-before-change` event type */
+export type HelixCodeEditorHelixBeforeChangeElementEvent =
+  HelixCodeEditorElementEvent<HelixBeforeChangeEvent>;
+
+export type HelixCodeEditorVueProps = {
+  /** Covers the container instead of taking a height of its own, for an
+editor that fills a pane. The container needs a position, such as
+`position: relative`. */
+  fill?: (HelixCodeEditor["fill"]) | undefined;
+  /** How the frame stands off the page. Unset, it is outlined. `plain` draws
+no edge or corners, for a pane that draws its own. */
+  separation?: (HelixCodeEditor["separation"]) | undefined;
+  /** The value the control starts with. A form reset returns it to this value,
+and to the `value` attribute where this one is not written, as a native
+control resets to the `value` it declares. */
+  "default-value"?: (HelixCodeEditor["defaultValue"]) | undefined;
+  /** The value the control starts with. A form reset returns it to this value,
+and to the `value` attribute where this one is not written, as a native
+control resets to the `value` it declares. */
+  defaultValue?: (HelixCodeEditor["defaultValue"]) | undefined;
+  /** The control's current value, which its form submits.
+
+One property, not two, so `input.value` answers the question anyone
+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?: (HelixCodeEditor["value"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (string) | undefined;
+  /** The validation message shown under the control. It replaces the
+browser's message. */
+  feedback?: (HelixCodeEditor["feedback"]) | undefined;
+  /** Help text shown under the control. A validation message replaces it. */
+  hint?: (HelixCodeEditor["hint"]) | undefined;
+  /** The field's label, which is also its accessible name. Content in the
+`label` slot replaces it. */
+  label?: (HelixCodeEditor["label"]) | undefined;
+  /** Whether the field needs a value before the form can submit. */
+  required?: (HelixCodeEditor["required"]) | undefined;
+  /** The message shown when the field is required and empty.
+
+**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. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. 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"?: (HelixCodeEditor["valueMissingMessage"]) | undefined;
+  /** The message shown when the field is required and empty.
+
+**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. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. 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?: (HelixCodeEditor["valueMissingMessage"]) | undefined;
+  /** The name of the header's toolbar, read by screen readers. */
+  "controls-label"?: (HelixCodeEditor["controlsLabel"]) | undefined;
+  /** The name of the header's toolbar, read by screen readers. */
+  controlsLabel?: (HelixCodeEditor["controlsLabel"]) | undefined;
+  /** How one problem in the list reads. `{line}` is its line and `{message}` what it says. */
+  "diagnostic-label"?: (HelixCodeEditor["diagnosticLabel"]) | undefined;
+  /** How one problem in the list reads. `{line}` is its line and `{message}` what it says. */
+  diagnosticLabel?: (HelixCodeEditor["diagnosticLabel"]) | undefined;
+  /** The list of problems' name. */
+  "diagnostics-label"?: (HelixCodeEditor["diagnosticsLabel"]) | undefined;
+  /** The list of problems' name. */
+  diagnosticsLabel?: (HelixCodeEditor["diagnosticsLabel"]) | undefined;
+  /** The name of the find bar's Close button. */
+  "find-close-label"?: (HelixCodeEditor["findCloseLabel"]) | undefined;
+  /** The name of the find bar's Close button. */
+  findCloseLabel?: (HelixCodeEditor["findCloseLabel"]) | undefined;
+  /** The name of the find bar's toolbar, read by screen readers. */
+  "find-controls-label"?: (HelixCodeEditor["findControlsLabel"]) | undefined;
+  /** The name of the find bar's toolbar, read by screen readers. */
+  findControlsLabel?: (HelixCodeEditor["findControlsLabel"]) | undefined;
+  /** What the find bar says when its regular expression cannot be read. */
+  "find-invalid-label"?: (HelixCodeEditor["findInvalidLabel"]) | undefined;
+  /** What the find bar says when its regular expression cannot be read. */
+  findInvalidLabel?: (HelixCodeEditor["findInvalidLabel"]) | undefined;
+  /** The name of the Find button and the find bar's field. */
+  "find-label"?: (HelixCodeEditor["findLabel"]) | undefined;
+  /** The name of the Find button and the find bar's field. */
+  findLabel?: (HelixCodeEditor["findLabel"]) | undefined;
+  /** The name of the option that finds only the same case. */
+  "find-match-case-label"?: (HelixCodeEditor["findMatchCaseLabel"]) | undefined;
+  /** The name of the option that finds only the same case. */
+  findMatchCaseLabel?: (HelixCodeEditor["findMatchCaseLabel"]) | undefined;
+  /** The name of the button that selects the next match. */
+  "find-next-label"?: (HelixCodeEditor["findNextLabel"]) | undefined;
+  /** The name of the button that selects the next match. */
+  findNextLabel?: (HelixCodeEditor["findNextLabel"]) | undefined;
+  /** The name of the button that selects the previous match. */
+  "find-previous-label"?: (HelixCodeEditor["findPreviousLabel"]) | undefined;
+  /** The name of the button that selects the previous match. */
+  findPreviousLabel?: (HelixCodeEditor["findPreviousLabel"]) | undefined;
+  /** The name of the option that reads the search as a regular expression. */
+  "find-regex-label"?: (HelixCodeEditor["findRegexLabel"]) | undefined;
+  /** The name of the option that reads the search as a regular expression. */
+  findRegexLabel?: (HelixCodeEditor["findRegexLabel"]) | undefined;
+  /** The name of the button that shows the replace field under the find field. */
+  "find-replace-label"?: (HelixCodeEditor["findReplaceLabel"]) | undefined;
+  /** The name of the button that shows the replace field under the find field. */
+  findReplaceLabel?: (HelixCodeEditor["findReplaceLabel"]) | undefined;
+  /** The name of the option that finds only whole words. */
+  "find-whole-word-label"?: (HelixCodeEditor["findWholeWordLabel"]) | undefined;
+  /** The name of the option that finds only whole words. */
+  findWholeWordLabel?: (HelixCodeEditor["findWholeWordLabel"]) | undefined;
+  /** The language to highlight, such as `ts`, `css`, `md` or `rust`. Empty is plain text. */
+  language?: (HelixCodeEditor["language"]) | undefined;
+  /** Draws each line's number beside it, in an engine. */
+  "line-numbers"?: (HelixCodeEditor["lineNumbers"]) | undefined;
+  /** Draws each line's number beside it, in an engine. */
+  lineNumbers?: (HelixCodeEditor["lineNumbers"]) | undefined;
+  /** What the find bar says of its matches. `{index}` is the selected match,
+counting from 1, and `{count}` how many there are. */
+  "matches-label"?: (HelixCodeEditor["matchesLabel"]) | undefined;
+  /** What the find bar says of its matches. `{index}` is the selected match,
+counting from 1, and `{count}` how many there are. */
+  matchesLabel?: (HelixCodeEditor["matchesLabel"]) | undefined;
+  /** Shown while the editor is empty. */
+  placeholder?: (HelixCodeEditor["placeholder"]) | undefined;
+  /** Where the caret is, in the status line. `{line}` and `{column}` count from 1. */
+  "position-label"?: (HelixCodeEditor["positionLabel"]) | undefined;
+  /** Where the caret is, in the status line. `{line}` and `{column}` count from 1. */
+  positionLabel?: (HelixCodeEditor["positionLabel"]) | undefined;
+  /** How many problems there are, in the status line. `{count}` is the number. */
+  "problems-label"?: (HelixCodeEditor["problemsLabel"]) | undefined;
+  /** How many problems there are, in the status line. `{count}` is the number. */
+  problemsLabel?: (HelixCodeEditor["problemsLabel"]) | undefined;
+  /** Lets the reader select and copy, and not change, the text. */
+  readonly?: (HelixCodeEditor["readOnly"]) | undefined;
+  /** Lets the reader select and copy, and not change, the text. */
+  readOnly?: (HelixCodeEditor["readOnly"]) | undefined;
+  /** The name of the button that replaces every match. */
+  "replace-all-label"?: (HelixCodeEditor["replaceAllLabel"]) | undefined;
+  /** The name of the button that replaces every match. */
+  replaceAllLabel?: (HelixCodeEditor["replaceAllLabel"]) | undefined;
+  /** The name of the button that replaces the selected match. */
+  "replace-label"?: (HelixCodeEditor["replaceLabel"]) | undefined;
+  /** The name of the button that replaces the selected match. */
+  replaceLabel?: (HelixCodeEditor["replaceLabel"]) | undefined;
+  /** The name of the field the replacement is typed in. */
+  "replace-with-label"?: (HelixCodeEditor["replaceWithLabel"]) | undefined;
+  /** The name of the field the replacement is typed in. */
+  replaceWithLabel?: (HelixCodeEditor["replaceWithLabel"]) | undefined;
+  /** How many lines tall the plain field is before it scrolls, without an engine. */
+  rows?: (HelixCodeEditor["rows"]) | undefined;
+  /** Wraps long lines to the editor's width, in place of scrolling sideways. */
+  wrap?: (HelixCodeEditor["wrap"]) | undefined;
+  /** Whether the control is disabled and cannot be used.
+
+Reflected, because the styled tier selects on it, and mirrored to
+`aria-disabled` rather than removing the element from the accessibility
+tree, so a screen reader can still announce that the control exists.
+
+The mirror itself is in `willUpdate` below, here rather than in each
+control, because here is where `disabled` is. */
+  disabled?: (HelixCodeEditor["disabled"]) | undefined;
+  /** The name the control's value is submitted under.
+
+**Reflected, and it is the exception to "reflect only what CSS selects
+on".** The platform builds a form's entry list from the `name` *content
+attribute*, not from the property, so a control named through the property
+submitted under no name at all and was silently dropped. Measured: two
+inputs in one form, one named by attribute and one by property, and the
+form carried a single entry.
+
+Safe for a React consumer, which is what the rule is protecting: React
+renders a custom element's props as attributes on the server, so the name
+is already in the markup being hydrated and reflecting it writes what is
+there. It is only a change to the markup when a consumer assigns it
+imperatively later, and nothing is hydrating by then.
+
+Here rather than on each control. */
+  name?: (HelixCodeEditor["name"]) | undefined;
+  /** The problems in the text, each underlined and listed under the editor. */
+  diagnostics?: (HelixCodeEditor["diagnostics"]) | undefined;
+  /** What draws the editor, such as `codeMirrorEngine()` from
+`@fusion.dev/helix-editor`. Absent, the editor is a plain text field. */
+  engine?: (HelixCodeEditor["engine"]) | undefined;
+};
+
+export type HelixCodeEditorVueEvents = {
+  /** The reader finished an edit and focus left the code, in the engine or the plain field. */
+  change: HelixCodeEditorElementEvent;
+  /** The text is about to change. Cancelable: cancel it to keep the current text. */
+  "helix-before-change": HelixCodeEditorHelixBeforeChangeElementEvent;
+  /** Fired after the text changes. */
+  input: HelixCodeEditorElementEvent;
+};
+
+/** `HelixCodeInput` component event */
+export type HelixCodeInputElementEvent<E = Event> = TypedEvent<
+  HelixCodeInput,
+  E
+>;
+/** `helix-before-change` event type */
+export type HelixCodeInputHelixBeforeChangeElementEvent =
+  HelixCodeInputElementEvent<HelixBeforeChangeEvent>;
+/** `helix-before-listen` event type */
+export type HelixCodeInputHelixBeforeListenElementEvent =
+  HelixCodeInputElementEvent<HelixBeforeListenEvent>;
+/** `helix-clear` event type */
+export type HelixCodeInputHelixClearElementEvent =
+  HelixCodeInputElementEvent<HelixClearEvent>;
+/** `helix-listen` event type */
+export type HelixCodeInputHelixListenElementEvent =
+  HelixCodeInputElementEvent<HelixListenEvent>;
+
+export type HelixCodeInputVueProps = {
+  /** The grammar to highlight, such as `json`, `css`, `ts`, `html` or `sh`. Empty is plain text. */
+  language?: (HelixCodeInput["language"]) | undefined;
+  /** How the browser wraps the text, and whether the breaks are submitted with
+it. */
+  wrap?: (HelixCodeInput["wrap"]) | undefined;
+  /** What a screen reader hears as listening starts. */
+  "listening-label"?: (HelixCodeInput["listeningLabel"]) | undefined;
+  /** What a screen reader hears as listening starts. */
+  listeningLabel?: (HelixCodeInput["listeningLabel"]) | undefined;
+  /** What a screen reader hears as listening stops. */
+  "stopped-listening-label"?: (HelixCodeInput["stoppedListeningLabel"]) | undefined;
+  /** What a screen reader hears as listening stops. */
+  stoppedListeningLabel?: (HelixCodeInput["stoppedListeningLabel"]) | undefined;
+  /** Draws a button that listens for dictation and types what it hears at
+the caret. Nothing listens until the button is pressed, and the
+microphone is let go as listening stops. An input of type `password`,
+`email` or `number` draws no button. */
+  voice?: (HelixCodeInput["voice"]) | undefined;
+  /** The dictation button's name while it is not listening. */
+  "voice-label"?: (HelixCodeInput["voiceLabel"]) | undefined;
+  /** The dictation button's name while it is not listening. */
+  voiceLabel?: (HelixCodeInput["voiceLabel"]) | undefined;
+  /** The dictation button's name while it listens. */
+  "voice-stop-label"?: (HelixCodeInput["voiceStopLabel"]) | undefined;
+  /** The dictation button's name while it listens. */
+  voiceStopLabel?: (HelixCodeInput["voiceStopLabel"]) | undefined;
+  /** The value the control starts with. A form reset returns it to this value,
+and to the `value` attribute where this one is not written, as a native
+control resets to the `value` it declares. */
+  "default-value"?: (HelixCodeInput["defaultValue"]) | undefined;
+  /** The value the control starts with. A form reset returns it to this value,
+and to the `value` attribute where this one is not written, as a native
+control resets to the `value` it declares. */
+  defaultValue?: (HelixCodeInput["defaultValue"]) | undefined;
+  /** The control's current value, which its form submits.
+
+One property, not two, so `input.value` answers the question anyone
+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?: (HelixCodeInput["value"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (string) | undefined;
+  /** The validation message shown under the control. It replaces the
+browser's message. */
+  feedback?: (HelixCodeInput["feedback"]) | undefined;
+  /** Help text shown under the control. A validation message replaces it. */
+  hint?: (HelixCodeInput["hint"]) | undefined;
+  /** The field's label, which is also its accessible name. Content in the
+`label` slot replaces it. */
+  label?: (HelixCodeInput["label"]) | undefined;
+  /** Whether the field needs a value before the form can submit. */
+  required?: (HelixCodeInput["required"]) | undefined;
+  /** The message shown when the field is required and empty.
+
+**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. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. 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"?: (HelixCodeInput["valueMissingMessage"]) | undefined;
+  /** The message shown when the field is required and empty.
+
+**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. A family with a sentence of its
+own declares it as this property's English, a word property a page
+registers for its locale under the family's key. 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?: (HelixCodeInput["valueMissingMessage"]) | undefined;
+  /** What the browser can autofill in the field, as a standard `autocomplete`
+token.
+
+Empty leaves the attribute off, which is the browser's default. Set it to
+a token like `email` or `bday` to ask for autofill, or to `off` to refuse. */
+  autocomplete?: (HelixCodeInput["autocomplete"]) | undefined;
+  /** Grows the box to fit its content, so it does not scroll. */
+  "auto-grow"?: (HelixCodeInput["autoGrow"]) | undefined;
+  /** Grows the box to fit its content, so it does not scroll. */
+  autoGrow?: (HelixCodeInput["autoGrow"]) | undefined;
+  /** Draws a button that empties the field while it holds text. */
+  clearable?: (HelixCodeInput["clearable"]) | undefined;
+  /** The accessible name of the clear button, which shows only an icon. */
+  "clear-label"?: (HelixCodeInput["clearLabel"]) | undefined;
+  /** The accessible name of the clear button, which shows only an icon. */
+  clearLabel?: (HelixCodeInput["clearLabel"]) | undefined;
+  /** How many characters wide the box is, when the layout does not set its
+width.
+
+Optional and absent by default, which is the reflected-property rule: a
+`<textarea>` left alone is 20 columns wide and a styled one is whatever its
+box says, so writing a number here is a departure rather than the resting
+state. `wrap="hard"` needs it, the two being the pair that decides where
+the browser inserts the line breaks it submits. */
+  cols?: (HelixCodeInput["cols"]) | undefined;
+  /** The name of a second form entry that submits the direction of the text.
+
+**Submitted through `setFormValue`, because the inner control's own
+`dirname` cannot reach the form.** This host is form-associated and reports
+its value itself, so the `<textarea>` inside the shadow root participates in
+no form at all and forwarding the attribute would have looked right and
+submitted nothing. `ElementInternals` takes a `FormData`, which is how one
+element sends two entries, and that is what this does. */
+  dirname?: (HelixCodeInput["dirName"]) | undefined;
+  /** The name of a second form entry that submits the direction of the text.
+
+**Submitted through `setFormValue`, because the inner control's own
+`dirname` cannot reach the form.** This host is form-associated and reports
+its value itself, so the `<textarea>` inside the shadow root participates in
+no form at all and forwarding the attribute would have looked right and
+submitted nothing. `ElementInternals` takes a `FormData`, which is how one
+element sends two entries, and that is what this does. */
+  dirName?: (HelixCodeInput["dirName"]) | undefined;
+  /** The most characters the value can have. */
+  maxlength?: (HelixCodeInput["maxLength"] | `${number}`) | undefined;
+  /** The most characters the value can have. */
+  maxLength?: (HelixCodeInput["maxLength"]) | undefined;
+  /** How many lines an `auto-grow` field grows to before it scrolls. Absent,
+it grows with all of its text. */
+  "max-rows"?: (HelixCodeInput["maxRows"] | `${number}`) | undefined;
+  /** How many lines an `auto-grow` field grows to before it scrolls. Absent,
+it grows with all of its text. */
+  maxRows?: (HelixCodeInput["maxRows"]) | undefined;
+  /** The fewest characters the value can have.
+
+Forwarded to the real `<textarea>` rather than checked here, which is what
+makes the message the browser's and therefore the reader's own language.
+No `pattern`: the platform does not give a textarea one, and inventing it
+would be this library guessing where the point is to stop guessing. */
+  minlength?: (HelixCodeInput["minLength"] | `${number}`) | undefined;
+  /** The fewest characters the value can have.
+
+Forwarded to the real `<textarea>` rather than checked here, which is what
+makes the message the browser's and therefore the reader's own language.
+No `pattern`: the platform does not give a textarea one, and inventing it
+would be this library guessing where the point is to stop guessing. */
+  minLength?: (HelixCodeInput["minLength"]) | undefined;
+  /** Text shown while the field is empty.
+
+Not a label: it goes when typing starts. */
+  placeholder?: (HelixCodeInput["placeholder"]) | undefined;
+  /** Blocks typing in the field. The value is still submitted with the form. */
+  readonly?: (HelixCodeInput["readOnly"]) | undefined;
+  /** Blocks typing in the field. The value is still submitted with the form. */
+  readOnly?: (HelixCodeInput["readOnly"]) | undefined;
+  /** How many lines the box is before anything is typed. */
+  rows?: (HelixCodeInput["rows"]) | undefined;
+  /** Whether the control is disabled and cannot be used.
+
+Reflected, because the styled tier selects on it, and mirrored to
+`aria-disabled` rather than removing the element from the accessibility
+tree, so a screen reader can still announce that the control exists.
+
+The mirror itself is in `willUpdate` below, here rather than in each
+control, because here is where `disabled` is. */
+  disabled?: (HelixCodeInput["disabled"]) | undefined;
+  /** The name the control's value is submitted under.
+
+**Reflected, and it is the exception to "reflect only what CSS selects
+on".** The platform builds a form's entry list from the `name` *content
+attribute*, not from the property, so a control named through the property
+submitted under no name at all and was silently dropped. Measured: two
+inputs in one form, one named by attribute and one by property, and the
+form carried a single entry.
+
+Safe for a React consumer, which is what the rule is protecting: React
+renders a custom element's props as attributes on the server, so the name
+is already in the markup being hydrated and reflecting it writes what is
+there. It is only a change to the markup when a consumer assigns it
+imperatively later, and nothing is hydrating by then.
+
+Here rather than on each control. */
+  name?: (HelixCodeInput["name"]) | undefined;
+  /** Turns the code into highlighted markup for its `language`, for this field
+alone. Absent, the field draws with the highlighter `registerHighlighter`
+gave the page, and plain where there is none. The markup is drawn as
+given, so it escapes the code, as every highlighter does. */
+  highlight?: (HelixCodeInput["highlight"]) | undefined;
+  /** The engine this field listens through, in place of the one
+`registerSpeechEngine` gave the page, or the browser's own. */
+  speechEngine?: (HelixCodeInput["speechEngine"]) | undefined;
+  /** The direction of the selection, as a native textarea reports it.
+
+**The whole reason this renders a real `<textarea>` is the caret**, and the
+control is inside this shadow root, so `querySelector` does not find it and
+a consumer has no other way to ask where the selection is, let alone move
+it. A field that cannot be scripted at the caret cannot do an
+insert-at-cursor toolbar, which is the first thing anybody builds on a
+textarea.
+
+Written through to the control, and answering zero before there is one,
+which is where an empty field's caret would be anyway. */
+  selectionDirection?: (HelixCodeInput["selectionDirection"]) | undefined;
+  /** Where the selection ends, as an offset into the value. */
+  selectionEnd?: (HelixCodeInput["selectionEnd"]) | undefined;
+  /** Where the selection starts, as an offset into the value. */
+  selectionStart?: (HelixCodeInput["selectionStart"]) | undefined;
+  /** Your own rule for the value, run on every change once the browser finds
+nothing wrong. Return a message, or a list of them, to mark the field
+invalid, and `true`, `null`, or nothing to accept the value. */
+  validate?: (HelixCodeInput["validate"]) | undefined;
+};
+
+export type HelixCodeInputVueEvents = {
+  /** Sent from the textarea when the user finishes an edit. */
+  change: HelixCodeInputElementEvent;
+  /** Fired as the text changes, and cancelable. */
+  "helix-before-change": HelixCodeInputHelixBeforeChangeElementEvent;
+  /** The dictation button was pressed. Cancelable: cancel it to keep the field from listening. */
+  "helix-before-listen": HelixCodeInputHelixBeforeListenElementEvent;
+  /** Fired after the clear button has emptied the field, after `input` and `change`. */
+  "helix-clear": HelixCodeInputHelixClearElementEvent;
+  /** Dictation settled on a phrase and put it in the value, after the field's own `input`. */
+  "helix-listen": HelixCodeInputHelixListenElementEvent;
+  /** Fired after the value changes. */
+  input: HelixCodeInputElementEvent;
+};
+
 export type HelixCodeVueProps = {};
 
 export type HelixCodeVueEvents = {};
@@ -5411,6 +5971,19 @@ 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;
+  /** Lists the controls on screen below the palette's own commands, once the
+reader types: every labeled Helix button, field, tab, switch and the
+rest, by its name, with its shortcut. Choosing one closes the palette and
+presses the control, or moves focus into a field.
+
+A control that is disabled, inert, hidden or under `unlisted` is left out,
+and so is anything inside the palette. Off by default, so a palette used
+as a search box lists only what it holds. */
+  controls?: (HelixCommand["controls"]) | undefined;
+  /** The heading over the controls on screen. */
+  "controls-label"?: (HelixCommand["controlsLabel"]) | undefined;
+  /** The heading over the controls on screen. */
+  controlsLabel?: (HelixCommand["controlsLabel"]) | undefined;
   /** The text shown when the filter matches no commands. */
   "empty-text"?: (HelixCommand["emptyText"]) | undefined;
   /** The text shown when the filter matches no commands. */
@@ -5445,6 +6018,12 @@ Empty turns it off, for a consumer who opens the palette from a button or
 from their own shortcut handler. There is no list of defaults to fight
 with: one key, said once. */
   hotkey?: (HelixCommand["hotkey"]) | undefined;
+  /** What the hotkey does, as a list of the page's shortcuts says it, with
+`{label}` for the palette's `label`. */
+  "hotkey-label"?: (HelixCommand["hotkeyLabel"]) | undefined;
+  /** What the hotkey does, as a list of the page's shortcuts says it, with
+`{label}` for the palette's `label`. */
+  hotkeyLabel?: (HelixCommand["hotkeyLabel"]) | undefined;
   /** Draws the palette in the page, where it stands, with no dialog: a search
 over a list of commands, as React Aria's Autocomplete is drawn.
 
@@ -5510,6 +6089,9 @@ how many are left, written in the locale, and each language writes the
 forms it has: `{count, plural, one {# polecenie} few {# polecenia} many
 {# poleceń} other {# polecenia}}`. */
   resultsLabel?: (HelixCommand["resultsLabel"]) | undefined;
+  /** Draws a dictation button in the search field, which listens through the
+page's speech engine and types what it hears, as a field's `voice` does. */
+  voice?: (HelixCommand["voice"]) | undefined;
   /** Whether a command is kept by the filter: a function given the command's
 words and the filter, trimmed, that returns `true` to keep it showing, as
 React Aria's `Autocomplete` takes `filter`. See Listbox's `filterMatch`.
@@ -7703,6 +8285,31 @@ beside its buttons and as each page arrives. `{first}`, `{last}` and
 beside its buttons and as each page arrives. `{first}`, `{last}` and
 `{count}` are replaced with the numbers, written in `locale`. */
   readingsLabel?: (HelixDonutChart["readingsLabel"]) | undefined;
+  /** Draws a Listen button that plays the chart as sound: each series in
+turn, its readings from left to right and from the left ear to the
+right, the value as pitch over two octaves, a soft tick at each
+gridline, and one timbre a series. With it, each reading the arrow keys
+step to plays its tone beside what the readout says, and L plays the
+whole chart while it has focus. Escape stops it. Nothing plays without a
+press, and the sound is made only then. */
+  sonify?: (HelixDonutChart["sonify"]) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  "sonify-duration"?: (HelixDonutChart["sonifyDuration"] | `${number}`) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  sonifyDuration?: (HelixDonutChart["sonifyDuration"]) | undefined;
+  /** The Listen button's words. */
+  "sonify-label"?: (HelixDonutChart["sonifyLabel"]) | undefined;
+  /** The Listen button's words. */
+  sonifyLabel?: (HelixDonutChart["sonifyLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  "sonify-stop-label"?: (HelixDonutChart["sonifyStopLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  sonifyStopLabel?: (HelixDonutChart["sonifyStopLabel"]) | undefined;
+  /** `visible` draws the chart's text summary under it, as one line.
+`hidden`, or absent, says the summary to a screen reader and draws it
+for no one else. Reflected, because the stylesheet draws it by the
+attribute, and a page that sets the property, as React does, writes none. */
+  summary?: (HelixDonutChart["summary"]) | undefined;
   /** The size of the hole in the middle of the ring.
 
 Absent is a ring with room for a total in it. `small` and `large` move the
@@ -8467,6 +9074,9 @@ export type HelixFilterInputHelixBeforeChangeElementEvent =
 /** `helix-before-close` event type */
 export type HelixFilterInputHelixBeforeCloseElementEvent =
   HelixFilterInputElementEvent<HelixBeforeCloseEvent>;
+/** `helix-before-listen` event type */
+export type HelixFilterInputHelixBeforeListenElementEvent =
+  HelixFilterInputElementEvent<HelixBeforeListenEvent>;
 /** `helix-before-open` event type */
 export type HelixFilterInputHelixBeforeOpenElementEvent =
   HelixFilterInputElementEvent<HelixBeforeOpenEvent>;
@@ -8476,11 +9086,35 @@ export type HelixFilterInputHelixDismissElementEvent =
 /** `helix-facet` event type */
 export type HelixFilterInputHelixFacetElementEvent =
   HelixFilterInputElementEvent<HelixFacetEvent>;
+/** `helix-listen` event type */
+export type HelixFilterInputHelixListenElementEvent =
+  HelixFilterInputElementEvent<HelixListenEvent>;
 /** `helix-select` event type */
 export type HelixFilterInputHelixSelectElementEvent =
   HelixFilterInputElementEvent<HelixSelectEvent>;
 
 export type HelixFilterInputVueProps = {
+  /** What a screen reader hears as listening starts. */
+  "listening-label"?: (HelixFilterInput["listeningLabel"]) | undefined;
+  /** What a screen reader hears as listening starts. */
+  listeningLabel?: (HelixFilterInput["listeningLabel"]) | undefined;
+  /** What a screen reader hears as listening stops. */
+  "stopped-listening-label"?: (HelixFilterInput["stoppedListeningLabel"]) | undefined;
+  /** What a screen reader hears as listening stops. */
+  stoppedListeningLabel?: (HelixFilterInput["stoppedListeningLabel"]) | undefined;
+  /** Draws a button that listens for dictation and types what it hears at
+the caret. Nothing listens until the button is pressed, and the
+microphone is let go as listening stops. An input of type `password`,
+`email` or `number` draws no button. */
+  voice?: (HelixFilterInput["voice"]) | undefined;
+  /** The dictation button's name while it is not listening. */
+  "voice-label"?: (HelixFilterInput["voiceLabel"]) | undefined;
+  /** The dictation button's name while it is not listening. */
+  voiceLabel?: (HelixFilterInput["voiceLabel"]) | undefined;
+  /** The dictation button's name while it listens. */
+  "voice-stop-label"?: (HelixFilterInput["voiceStopLabel"]) | undefined;
+  /** The dictation button's name while it listens. */
+  voiceStopLabel?: (HelixFilterInput["voiceStopLabel"]) | undefined;
   /** Whether the element starts open. Ignored once `open` is written. */
   "default-open"?: (HelixFilterInput["defaultOpen"]) | undefined;
   /** Whether the element starts open. Ignored once `open` is written. */
@@ -8694,6 +9328,9 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixFilterInput["name"]) | undefined;
+  /** The engine this field listens through, in place of the one
+`registerSpeechEngine` gave the page, or the browser's own. */
+  speechEngine?: (HelixFilterInput["speechEngine"]) | undefined;
   /** Where the suggestions come from: a function given the term at the caret,
 the field it is a value of, the whole text, and an `AbortSignal`, which
 returns the suggestions or a promise of them. Each is a string, or a
@@ -8712,12 +9349,16 @@ export type HelixFilterInputVueEvents = {
   "helix-before-change": HelixFilterInputHelixBeforeChangeElementEvent;
   /** Fired before the suggestions close. Cancelable: call `preventDefault()` to keep them open. */
   "helix-before-close": HelixFilterInputHelixBeforeCloseElementEvent;
+  /** The dictation button was pressed. Cancelable: cancel it to keep the field from listening. */
+  "helix-before-listen": HelixFilterInputHelixBeforeListenElementEvent;
   /** Fired before the suggestions open. Cancelable: call `preventDefault()` to keep them closed. */
   "helix-before-open": HelixFilterInputHelixBeforeOpenElementEvent;
   /** Fired when the user removes a token with its remove button or with Backspace in an empty field. A `FilterChip` that names a declared field sends `helix-facet` instead. Cancelable: call `preventDefault()` to keep the token. */
   "helix-dismiss": HelixFilterInputHelixDismissElementEvent;
   /** Fired when a filter changes, whether it was typed, picked, or removed. Cancelable: call `preventDefault()` to leave the text and the chip as they were. */
   "helix-facet": HelixFilterInputHelixFacetElementEvent;
+  /** Dictation settled on a phrase and put it in the field, after the field's own `input`. */
+  "helix-listen": HelixFilterInputHelixListenElementEvent;
   /** Fired by an option in `suggestions` when it is chosen, and bubbles out of the field. Cancelable: call `preventDefault()` to stop other listeners acting on it. The field takes no action on an option you slotted, and you decide what it does. A suggestion from `source` is written over the term at the caret unless you cancel it. */
   "helix-select": HelixFilterInputHelixSelectElementEvent;
   /** Fired when the text changes. */
@@ -9551,6 +10192,31 @@ beside its buttons and as each page arrives. `{first}`, `{last}` and
 beside its buttons and as each page arrives. `{first}`, `{last}` and
 `{count}` are replaced with the numbers, written in `locale`. */
   readingsLabel?: (HelixHeatmap["readingsLabel"]) | undefined;
+  /** Draws a Listen button that plays the chart as sound: each series in
+turn, its readings from left to right and from the left ear to the
+right, the value as pitch over two octaves, a soft tick at each
+gridline, and one timbre a series. With it, each reading the arrow keys
+step to plays its tone beside what the readout says, and L plays the
+whole chart while it has focus. Escape stops it. Nothing plays without a
+press, and the sound is made only then. */
+  sonify?: (HelixHeatmap["sonify"]) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  "sonify-duration"?: (HelixHeatmap["sonifyDuration"] | `${number}`) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  sonifyDuration?: (HelixHeatmap["sonifyDuration"]) | undefined;
+  /** The Listen button's words. */
+  "sonify-label"?: (HelixHeatmap["sonifyLabel"]) | undefined;
+  /** The Listen button's words. */
+  sonifyLabel?: (HelixHeatmap["sonifyLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  "sonify-stop-label"?: (HelixHeatmap["sonifyStopLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  sonifyStopLabel?: (HelixHeatmap["sonifyStopLabel"]) | undefined;
+  /** `visible` draws the chart's text summary under it, as one line.
+`hidden`, or absent, says the summary to a screen reader and draws it
+for no one else. Reflected, because the stylesheet draws it by the
+attribute, and a page that sets the property, as React does, writes none. */
+  summary?: (HelixHeatmap["summary"]) | undefined;
   /** The name the `overview` gives the busiest reading, `{busiestLabel}` in
 `overview-label`. */
   "busiest-label"?: (HelixHeatmap["busiestLabel"]) | undefined;
@@ -10163,11 +10829,38 @@ export type HelixInputElementEvent<E = Event> = TypedEvent<HelixInput, E>;
 /** `helix-before-change` event type */
 export type HelixInputHelixBeforeChangeElementEvent =
   HelixInputElementEvent<HelixBeforeChangeEvent>;
+/** `helix-before-listen` event type */
+export type HelixInputHelixBeforeListenElementEvent =
+  HelixInputElementEvent<HelixBeforeListenEvent>;
 /** `helix-clear` event type */
 export type HelixInputHelixClearElementEvent =
   HelixInputElementEvent<HelixClearEvent>;
+/** `helix-listen` event type */
+export type HelixInputHelixListenElementEvent =
+  HelixInputElementEvent<HelixListenEvent>;
 
 export type HelixInputVueProps = {
+  /** What a screen reader hears as listening starts. */
+  "listening-label"?: (HelixInput["listeningLabel"]) | undefined;
+  /** What a screen reader hears as listening starts. */
+  listeningLabel?: (HelixInput["listeningLabel"]) | undefined;
+  /** What a screen reader hears as listening stops. */
+  "stopped-listening-label"?: (HelixInput["stoppedListeningLabel"]) | undefined;
+  /** What a screen reader hears as listening stops. */
+  stoppedListeningLabel?: (HelixInput["stoppedListeningLabel"]) | undefined;
+  /** Draws a button that listens for dictation and types what it hears at
+the caret. Nothing listens until the button is pressed, and the
+microphone is let go as listening stops. An input of type `password`,
+`email` or `number` draws no button. */
+  voice?: (HelixInput["voice"]) | undefined;
+  /** The dictation button's name while it is not listening. */
+  "voice-label"?: (HelixInput["voiceLabel"]) | undefined;
+  /** The dictation button's name while it is not listening. */
+  voiceLabel?: (HelixInput["voiceLabel"]) | undefined;
+  /** The dictation button's name while it listens. */
+  "voice-stop-label"?: (HelixInput["voiceStopLabel"]) | undefined;
+  /** The dictation button's name while it listens. */
+  voiceStopLabel?: (HelixInput["voiceStopLabel"]) | undefined;
   /** The value the control starts with. A form reset returns it to this value,
 and to the `value` attribute where this one is not written, as a native
 control resets to the `value` it declares. */
@@ -10366,6 +11059,9 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixInput["name"]) | undefined;
+  /** The engine this field listens through, in place of the one
+`registerSpeechEngine` gave the page, or the browser's own. */
+  speechEngine?: (HelixInput["speechEngine"]) | undefined;
   /** The direction of the selection, as the native input names it.
 
 The `<input>` is inside this shadow root, so a consumer had no way to ask
@@ -10393,8 +11089,12 @@ export type HelixInputVueEvents = {
   change: HelixInputElementEvent;
   /** The text is about to change. Cancelable: cancel it to keep the current text. */
   "helix-before-change": HelixInputHelixBeforeChangeElementEvent;
+  /** The dictation button was pressed. Cancelable: cancel it to keep the field from listening. */
+  "helix-before-listen": HelixInputHelixBeforeListenElementEvent;
   /** Fired after the clear button has emptied the field, after `input` and `change`. */
   "helix-clear": HelixInputHelixClearElementEvent;
+  /** Dictation settled on a phrase and put it in the value, after the field's own `input`. */
+  "helix-listen": HelixInputHelixListenElementEvent;
   /** Fired as the value changes. */
   input: HelixInputElementEvent;
 };
@@ -10934,6 +11634,31 @@ beside its buttons and as each page arrives. `{first}`, `{last}` and
 beside its buttons and as each page arrives. `{first}`, `{last}` and
 `{count}` are replaced with the numbers, written in `locale`. */
   readingsLabel?: (HelixLineChart["readingsLabel"]) | undefined;
+  /** Draws a Listen button that plays the chart as sound: each series in
+turn, its readings from left to right and from the left ear to the
+right, the value as pitch over two octaves, a soft tick at each
+gridline, and one timbre a series. With it, each reading the arrow keys
+step to plays its tone beside what the readout says, and L plays the
+whole chart while it has focus. Escape stops it. Nothing plays without a
+press, and the sound is made only then. */
+  sonify?: (HelixLineChart["sonify"]) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  "sonify-duration"?: (HelixLineChart["sonifyDuration"] | `${number}`) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  sonifyDuration?: (HelixLineChart["sonifyDuration"]) | undefined;
+  /** The Listen button's words. */
+  "sonify-label"?: (HelixLineChart["sonifyLabel"]) | undefined;
+  /** The Listen button's words. */
+  sonifyLabel?: (HelixLineChart["sonifyLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  "sonify-stop-label"?: (HelixLineChart["sonifyStopLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  sonifyStopLabel?: (HelixLineChart["sonifyStopLabel"]) | undefined;
+  /** `visible` draws the chart's text summary under it, as one line.
+`hidden`, or absent, says the summary to a screen reader and draws it
+for no one else. Reflected, because the stylesheet draws it by the
+attribute, and a page that sets the property, as React does, writes none. */
+  summary?: (HelixLineChart["summary"]) | undefined;
   /** Draws a wash under each line, down to the floor of the plot. The washes
 overlap and do not add up, so for parts that make a total, use
 `Area Chart`, which stacks them.
@@ -11337,12 +12062,18 @@ export type HelixListboxElementEvent<E = Event> = TypedEvent<HelixListbox, E>;
 /** `helix-before-change` event type */
 export type HelixListboxHelixBeforeChangeElementEvent =
   HelixListboxElementEvent<HelixBeforeChangeEvent>;
+/** `helix-before-listen` event type */
+export type HelixListboxHelixBeforeListenElementEvent =
+  HelixListboxElementEvent<HelixBeforeListenEvent>;
 /** `helix-before-reorder` event type */
 export type HelixListboxHelixBeforeReorderElementEvent =
   HelixListboxElementEvent<HelixBeforeReorderEvent>;
 /** `helix-filter` event type */
 export type HelixListboxHelixFilterElementEvent =
   HelixListboxElementEvent<HelixFilterEvent>;
+/** `helix-listen` event type */
+export type HelixListboxHelixListenElementEvent =
+  HelixListboxElementEvent<HelixListenEvent>;
 /** `helix-load-more` event type */
 export type HelixListboxHelixLoadMoreElementEvent =
   HelixListboxElementEvent<HelixLoadMoreEvent>;
@@ -11351,6 +12082,27 @@ export type HelixListboxHelixReorderElementEvent =
   HelixListboxElementEvent<HelixReorderEvent>;
 
 export type HelixListboxVueProps = {
+  /** What a screen reader hears as listening starts. */
+  "listening-label"?: (HelixListbox["listeningLabel"]) | undefined;
+  /** What a screen reader hears as listening starts. */
+  listeningLabel?: (HelixListbox["listeningLabel"]) | undefined;
+  /** What a screen reader hears as listening stops. */
+  "stopped-listening-label"?: (HelixListbox["stoppedListeningLabel"]) | undefined;
+  /** What a screen reader hears as listening stops. */
+  stoppedListeningLabel?: (HelixListbox["stoppedListeningLabel"]) | undefined;
+  /** Draws a button that listens for dictation and types what it hears at
+the caret. Nothing listens until the button is pressed, and the
+microphone is let go as listening stops. An input of type `password`,
+`email` or `number` draws no button. */
+  voice?: (HelixListbox["voice"]) | undefined;
+  /** The dictation button's name while it is not listening. */
+  "voice-label"?: (HelixListbox["voiceLabel"]) | undefined;
+  /** The dictation button's name while it is not listening. */
+  voiceLabel?: (HelixListbox["voiceLabel"]) | undefined;
+  /** The dictation button's name while it listens. */
+  "voice-stop-label"?: (HelixListbox["voiceStopLabel"]) | undefined;
+  /** The dictation button's name while it listens. */
+  voiceStopLabel?: (HelixListbox["voiceStopLabel"]) | undefined;
   /** The text shown and announced when there are no rows and none are loading. */
   "empty-text"?: (HelixListbox["emptyText"]) | undefined;
   /** The text shown and announced when there are no rows and none are loading. */
@@ -11580,6 +12332,9 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixListbox["name"]) | undefined;
+  /** The engine this field listens through, in place of the one
+`registerSpeechEngine` gave the page, or the browser's own. */
+  speechEngine?: (HelixListbox["speechEngine"]) | undefined;
   /** Whether an option is kept by the filter: a function given the option's
 words and the filter, trimmed, that returns `true` to keep it showing, as
 React Aria's `Autocomplete` takes `filter`. For matching that ignores
@@ -11624,10 +12379,14 @@ export type HelixListboxVueEvents = {
   change: HelixListboxElementEvent;
   /** Fired when the value is about to change, and cancelable. */
   "helix-before-change": HelixListboxHelixBeforeChangeElementEvent;
+  /** The dictation button was pressed. Cancelable: cancel it to keep the field from listening. */
+  "helix-before-listen": HelixListboxHelixBeforeListenElementEvent;
   /** Fired when an option is dropped at a new place, in a `reorderable` list with `@fusion.dev/helix/listbox/reorder` imported, with every value in the new order. Cancelable: cancel it to keep the option where it is. */
   "helix-before-reorder": HelixListboxHelixBeforeReorderElementEvent;
   /** Fired before the list is filtered, and cancelable. */
   "helix-filter": HelixListboxHelixFilterElementEvent;
+  /** Dictation settled on a phrase and put it in the search field, after the field's own `input`. */
+  "helix-listen": HelixListboxHelixListenElementEvent;
   /** Fired once the list is scrolled within a screen of its end, once for each number of options, and not while `loading` is set. Add the next page of options and set `loading` while you fetch it. */
   "helix-load-more": HelixListboxHelixLoadMoreElementEvent;
   /** Fired after `helix-before-reorder` when nobody canceled it. Move your options, or your `items`, to the order in `keys`. Cancelable: cancel it to say the move did not happen. */
@@ -12739,6 +13498,39 @@ export type HelixMapTerrainVueEvents = {
   "helix-map-part-change": HelixMapTerrainHelixMapPartChangeElementEvent;
 };
 
+export type HelixMarkdownVueProps = {
+  /** The heading of a `> [!CAUTION]` alert. */
+  "caution-heading"?: (HelixMarkdown["cautionHeading"]) | undefined;
+  /** The heading of a `> [!CAUTION]` alert. */
+  cautionHeading?: (HelixMarkdown["cautionHeading"]) | undefined;
+  /** The heading of a `> [!IMPORTANT]` alert. */
+  "important-heading"?: (HelixMarkdown["importantHeading"]) | undefined;
+  /** The heading of a `> [!IMPORTANT]` alert. */
+  importantHeading?: (HelixMarkdown["importantHeading"]) | undefined;
+  /** The heading of a `> [!NOTE]` alert. */
+  "note-heading"?: (HelixMarkdown["noteHeading"]) | undefined;
+  /** The heading of a `> [!NOTE]` alert. */
+  noteHeading?: (HelixMarkdown["noteHeading"]) | undefined;
+  /** Whether more text is coming. While it is set, the end of `text` is read
+as a block still arriving, and the element is busy to assistive
+technology. Clear it when the reply ends, and the last block is read as
+finished. */
+  streaming?: (HelixMarkdown["streaming"]) | undefined;
+  /** The Markdown. Set it to the whole reply so far each time more arrives: a
+text that starts with the one before is drawn by its new end alone. */
+  text?: (HelixMarkdown["text"]) | undefined;
+  /** The heading of a `> [!TIP]` alert. */
+  "tip-heading"?: (HelixMarkdown["tipHeading"]) | undefined;
+  /** The heading of a `> [!TIP]` alert. */
+  tipHeading?: (HelixMarkdown["tipHeading"]) | undefined;
+  /** The heading of a `> [!WARNING]` alert. */
+  "warning-heading"?: (HelixMarkdown["warningHeading"]) | undefined;
+  /** The heading of a `> [!WARNING]` alert. */
+  warningHeading?: (HelixMarkdown["warningHeading"]) | undefined;
+};
+
+export type HelixMarkdownVueEvents = {};
+
 /** `HelixMegamenu` component event */
 export type HelixMegamenuElementEvent<E = Event> = TypedEvent<HelixMegamenu, E>;
 /** `toggle` event type */
@@ -13070,6 +13862,12 @@ which import is missing. */
   "filter-label"?: (HelixMenu["filterLabel"]) | undefined;
   /** The filter field's name and placeholder. */
   filterLabel?: (HelixMenu["filterLabel"]) | undefined;
+  /** With `context`, the id of an area outside the menu whose context menu
+this is, for one menu that serves a region the page draws elsewhere, such
+as a table. A right-click, a long press, Shift+F10 or the menu key there
+opens it, as on the `trigger` slot's area. Names an element in the same
+tree, the way `Tooltip.for` does. */
+  for?: (HelixMenu["for"]) | undefined;
   /** Accessible name for the surface.
 
 Empty by default, which names the surface by its trigger, so a menu opened
@@ -13111,6 +13909,10 @@ the forms it has, as Listbox's `results-label` does. */
   /** How a submenu opens. `drill` shows it in place of the page showing, with
 a way back. `flyout` opens it in a panel of its own beside its row. */
   submenus?: (HelixMenu["submenus"]) | undefined;
+  /** With `context`, a selector for the things in the area a menu is about,
+such as `tr` for a table's rows. A request over one opens the menu with it
+as `contextTarget`, and a request over none of them is left to the page. */
+  targets?: (HelixMenu["targets"]) | undefined;
   /** Whether a row is kept by the filter: a function given the row's words and
 the filter, trimmed, that returns `true` to keep it showing, as React
 Aria's `Autocomplete` takes `filter`. See Listbox's `filterMatch`.
@@ -13118,6 +13920,11 @@ Aria's `Autocomplete` takes `filter`. See Listbox's `filterMatch`.
 Absent, a row is kept where its words hold the filter, in any case. A
 property only, there being no way to write a function in markup. */
   filterMatch?: (HelixMenu["filterMatch"]) | undefined;
+  /** The thing the open context menu is about: the element of `targets` the
+reader asked over, the area where there are no `targets`, or what
+`showAt` was given. Set before `helix-before-open`, so a listener can
+change the rows for it, and kept until the menu next opens. */
+  contextTarget?: (HelixMenu["contextTarget"]) | undefined;
   /** The values of the choice rows that are checked, anywhere in the menu, in
 document order.
 
@@ -16380,6 +17187,31 @@ beside its buttons and as each page arrives. `{first}`, `{last}` and
 beside its buttons and as each page arrives. `{first}`, `{last}` and
 `{count}` are replaced with the numbers, written in `locale`. */
   readingsLabel?: (HelixScatterChart["readingsLabel"]) | undefined;
+  /** Draws a Listen button that plays the chart as sound: each series in
+turn, its readings from left to right and from the left ear to the
+right, the value as pitch over two octaves, a soft tick at each
+gridline, and one timbre a series. With it, each reading the arrow keys
+step to plays its tone beside what the readout says, and L plays the
+whole chart while it has focus. Escape stops it. Nothing plays without a
+press, and the sound is made only then. */
+  sonify?: (HelixScatterChart["sonify"]) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  "sonify-duration"?: (HelixScatterChart["sonifyDuration"] | `${number}`) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  sonifyDuration?: (HelixScatterChart["sonifyDuration"]) | undefined;
+  /** The Listen button's words. */
+  "sonify-label"?: (HelixScatterChart["sonifyLabel"]) | undefined;
+  /** The Listen button's words. */
+  sonifyLabel?: (HelixScatterChart["sonifyLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  "sonify-stop-label"?: (HelixScatterChart["sonifyStopLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  sonifyStopLabel?: (HelixScatterChart["sonifyStopLabel"]) | undefined;
+  /** `visible` draws the chart's text summary under it, as one line.
+`hidden`, or absent, says the summary to a screen reader and draws it
+for no one else. Reflected, because the stylesheet draws it by the
+attribute, and a page that sets the property, as React does, writes none. */
+  summary?: (HelixScatterChart["summary"]) | undefined;
   /** The word for the strength of the relation, `{correlationLabel}` in
 `series-label`. */
   "correlation-label"?: (HelixScatterChart["correlationLabel"]) | undefined;
@@ -16792,6 +17624,30 @@ export type HelixSelectVueEvents = {
   input: HelixSelectElementEvent;
 };
 
+export type HelixShortcutOverlayVueProps = {
+  /** How long the key is held before the badges show, in milliseconds or as `0.6s`. */
+  delay?: (HelixShortcutOverlay["delay"]) | undefined;
+  /** What the sheet says when the page has no shortcuts. */
+  "empty-label"?: (HelixShortcutOverlay["emptyLabel"]) | undefined;
+  /** What the sheet says when the page has no shortcuts. */
+  emptyLabel?: (HelixShortcutOverlay["emptyLabel"]) | undefined;
+  /** The key a reader holds: `mod` (Command on an Apple keyboard, Control
+elsewhere), `alt`, `ctrl`, or `shift`. */
+  hold?: (HelixShortcutOverlay["hold"]) | undefined;
+  /** The sheet's name and heading. */
+  label?: (HelixShortcutOverlay["label"]) | undefined;
+  /** The chord that opens the sheet, `?` by default, which a press in a text
+field never answers. Empty leaves the key to the page, which wants it
+where the page already answers `?` itself. */
+  "sheet-keys"?: (HelixShortcutOverlay["sheetKeys"]) | undefined;
+  /** The chord that opens the sheet, `?` by default, which a press in a text
+field never answers. Empty leaves the key to the page, which wants it
+where the page already answers `?` itself. */
+  sheetKeys?: (HelixShortcutOverlay["sheetKeys"]) | undefined;
+};
+
+export type HelixShortcutOverlayVueEvents = {};
+
 export type HelixSkeletonVueProps = {
   /** How the placeholder shows it is waiting: a sweep when unset, `pulse` to
 fade the fill in and out, or `none` to sit still.
@@ -17414,6 +18270,31 @@ beside its buttons and as each page arrives. `{first}`, `{last}` and
 beside its buttons and as each page arrives. `{first}`, `{last}` and
 `{count}` are replaced with the numbers, written in `locale`. */
   readingsLabel?: (HelixSpatialBarChart["readingsLabel"]) | undefined;
+  /** Draws a Listen button that plays the chart as sound: each series in
+turn, its readings from left to right and from the left ear to the
+right, the value as pitch over two octaves, a soft tick at each
+gridline, and one timbre a series. With it, each reading the arrow keys
+step to plays its tone beside what the readout says, and L plays the
+whole chart while it has focus. Escape stops it. Nothing plays without a
+press, and the sound is made only then. */
+  sonify?: (HelixSpatialBarChart["sonify"]) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  "sonify-duration"?: (HelixSpatialBarChart["sonifyDuration"] | `${number}`) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  sonifyDuration?: (HelixSpatialBarChart["sonifyDuration"]) | undefined;
+  /** The Listen button's words. */
+  "sonify-label"?: (HelixSpatialBarChart["sonifyLabel"]) | undefined;
+  /** The Listen button's words. */
+  sonifyLabel?: (HelixSpatialBarChart["sonifyLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  "sonify-stop-label"?: (HelixSpatialBarChart["sonifyStopLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  sonifyStopLabel?: (HelixSpatialBarChart["sonifyStopLabel"]) | undefined;
+  /** `visible` draws the chart's text summary under it, as one line.
+`hidden`, or absent, says the summary to a screen reader and draws it
+for no one else. Reflected, because the stylesheet draws it by the
+attribute, and a page that sets the property, as React does, writes none. */
+  summary?: (HelixSpatialBarChart["summary"]) | undefined;
   /** Draws no box: no edges, grid, numbers, or names, so the readings stand
 alone and fill the plot, as a picture on a product's own page does. The
 table, the summary, the tooltip, and the keys still carry every value,
@@ -17601,6 +18482,31 @@ beside its buttons and as each page arrives. `{first}`, `{last}` and
 beside its buttons and as each page arrives. `{first}`, `{last}` and
 `{count}` are replaced with the numbers, written in `locale`. */
   readingsLabel?: (HelixSpatialHeatmap["readingsLabel"]) | undefined;
+  /** Draws a Listen button that plays the chart as sound: each series in
+turn, its readings from left to right and from the left ear to the
+right, the value as pitch over two octaves, a soft tick at each
+gridline, and one timbre a series. With it, each reading the arrow keys
+step to plays its tone beside what the readout says, and L plays the
+whole chart while it has focus. Escape stops it. Nothing plays without a
+press, and the sound is made only then. */
+  sonify?: (HelixSpatialHeatmap["sonify"]) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  "sonify-duration"?: (HelixSpatialHeatmap["sonifyDuration"] | `${number}`) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  sonifyDuration?: (HelixSpatialHeatmap["sonifyDuration"]) | undefined;
+  /** The Listen button's words. */
+  "sonify-label"?: (HelixSpatialHeatmap["sonifyLabel"]) | undefined;
+  /** The Listen button's words. */
+  sonifyLabel?: (HelixSpatialHeatmap["sonifyLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  "sonify-stop-label"?: (HelixSpatialHeatmap["sonifyStopLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  sonifyStopLabel?: (HelixSpatialHeatmap["sonifyStopLabel"]) | undefined;
+  /** `visible` draws the chart's text summary under it, as one line.
+`hidden`, or absent, says the summary to a screen reader and draws it
+for no one else. Reflected, because the stylesheet draws it by the
+attribute, and a page that sets the property, as React does, writes none. */
+  summary?: (HelixSpatialHeatmap["summary"]) | undefined;
   /** The name the `overview` gives the busiest reading, `{busiestLabel}` in
 `overview-label`. */
   "busiest-label"?: (HelixSpatialHeatmap["busiestLabel"]) | undefined;
@@ -17885,6 +18791,31 @@ beside its buttons and as each page arrives. `{first}`, `{last}` and
 beside its buttons and as each page arrives. `{first}`, `{last}` and
 `{count}` are replaced with the numbers, written in `locale`. */
   readingsLabel?: (HelixSpatialRibbonChart["readingsLabel"]) | undefined;
+  /** Draws a Listen button that plays the chart as sound: each series in
+turn, its readings from left to right and from the left ear to the
+right, the value as pitch over two octaves, a soft tick at each
+gridline, and one timbre a series. With it, each reading the arrow keys
+step to plays its tone beside what the readout says, and L plays the
+whole chart while it has focus. Escape stops it. Nothing plays without a
+press, and the sound is made only then. */
+  sonify?: (HelixSpatialRibbonChart["sonify"]) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  "sonify-duration"?: (HelixSpatialRibbonChart["sonifyDuration"] | `${number}`) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  sonifyDuration?: (HelixSpatialRibbonChart["sonifyDuration"]) | undefined;
+  /** The Listen button's words. */
+  "sonify-label"?: (HelixSpatialRibbonChart["sonifyLabel"]) | undefined;
+  /** The Listen button's words. */
+  sonifyLabel?: (HelixSpatialRibbonChart["sonifyLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  "sonify-stop-label"?: (HelixSpatialRibbonChart["sonifyStopLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  sonifyStopLabel?: (HelixSpatialRibbonChart["sonifyStopLabel"]) | undefined;
+  /** `visible` draws the chart's text summary under it, as one line.
+`hidden`, or absent, says the summary to a screen reader and draws it
+for no one else. Reflected, because the stylesheet draws it by the
+attribute, and a page that sets the property, as React does, writes none. */
+  summary?: (HelixSpatialRibbonChart["summary"]) | undefined;
   /** Draws no box: no edges, grid, numbers, or names, so the readings stand
 alone and fill the plot, as a picture on a product's own page does. The
 table, the summary, the tooltip, and the keys still carry every value,
@@ -18060,6 +18991,31 @@ beside its buttons and as each page arrives. `{first}`, `{last}` and
 beside its buttons and as each page arrives. `{first}`, `{last}` and
 `{count}` are replaced with the numbers, written in `locale`. */
   readingsLabel?: (HelixSpatialScatterChart["readingsLabel"]) | undefined;
+  /** Draws a Listen button that plays the chart as sound: each series in
+turn, its readings from left to right and from the left ear to the
+right, the value as pitch over two octaves, a soft tick at each
+gridline, and one timbre a series. With it, each reading the arrow keys
+step to plays its tone beside what the readout says, and L plays the
+whole chart while it has focus. Escape stops it. Nothing plays without a
+press, and the sound is made only then. */
+  sonify?: (HelixSpatialScatterChart["sonify"]) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  "sonify-duration"?: (HelixSpatialScatterChart["sonifyDuration"] | `${number}`) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  sonifyDuration?: (HelixSpatialScatterChart["sonifyDuration"]) | undefined;
+  /** The Listen button's words. */
+  "sonify-label"?: (HelixSpatialScatterChart["sonifyLabel"]) | undefined;
+  /** The Listen button's words. */
+  sonifyLabel?: (HelixSpatialScatterChart["sonifyLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  "sonify-stop-label"?: (HelixSpatialScatterChart["sonifyStopLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  sonifyStopLabel?: (HelixSpatialScatterChart["sonifyStopLabel"]) | undefined;
+  /** `visible` draws the chart's text summary under it, as one line.
+`hidden`, or absent, says the summary to a screen reader and draws it
+for no one else. Reflected, because the stylesheet draws it by the
+attribute, and a page that sets the property, as React does, writes none. */
+  summary?: (HelixSpatialScatterChart["summary"]) | undefined;
   /** Draws a line from each point straight down to the floor of the box, in
 its group's color, so where a point stands across and in depth reads off
 the floor's grid. A renderer draws them too. */
@@ -18241,6 +19197,31 @@ beside its buttons and as each page arrives. `{first}`, `{last}` and
 beside its buttons and as each page arrives. `{first}`, `{last}` and
 `{count}` are replaced with the numbers, written in `locale`. */
   readingsLabel?: (HelixSpatialSurfaceChart["readingsLabel"]) | undefined;
+  /** Draws a Listen button that plays the chart as sound: each series in
+turn, its readings from left to right and from the left ear to the
+right, the value as pitch over two octaves, a soft tick at each
+gridline, and one timbre a series. With it, each reading the arrow keys
+step to plays its tone beside what the readout says, and L plays the
+whole chart while it has focus. Escape stops it. Nothing plays without a
+press, and the sound is made only then. */
+  sonify?: (HelixSpatialSurfaceChart["sonify"]) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  "sonify-duration"?: (HelixSpatialSurfaceChart["sonifyDuration"] | `${number}`) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  sonifyDuration?: (HelixSpatialSurfaceChart["sonifyDuration"]) | undefined;
+  /** The Listen button's words. */
+  "sonify-label"?: (HelixSpatialSurfaceChart["sonifyLabel"]) | undefined;
+  /** The Listen button's words. */
+  sonifyLabel?: (HelixSpatialSurfaceChart["sonifyLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  "sonify-stop-label"?: (HelixSpatialSurfaceChart["sonifyStopLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  sonifyStopLabel?: (HelixSpatialSurfaceChart["sonifyStopLabel"]) | undefined;
+  /** `visible` draws the chart's text summary under it, as one line.
+`hidden`, or absent, says the summary to a screen reader and draws it
+for no one else. Reflected, because the stylesheet draws it by the
+attribute, and a page that sets the property, as React does, writes none. */
+  summary?: (HelixSpatialSurfaceChart["summary"]) | undefined;
   /** Draws the surface's contour lines on it, at each tick of its height, in
 the ramp's colors, so its shape reads as on a map and two places at the
 same height read as such. A renderer draws them too. */
@@ -18425,6 +19406,31 @@ beside its buttons and as each page arrives. `{first}`, `{last}` and
 beside its buttons and as each page arrives. `{first}`, `{last}` and
 `{count}` are replaced with the numbers, written in `locale`. */
   readingsLabel?: (HelixSpatialTreemap["readingsLabel"]) | undefined;
+  /** Draws a Listen button that plays the chart as sound: each series in
+turn, its readings from left to right and from the left ear to the
+right, the value as pitch over two octaves, a soft tick at each
+gridline, and one timbre a series. With it, each reading the arrow keys
+step to plays its tone beside what the readout says, and L plays the
+whole chart while it has focus. Escape stops it. Nothing plays without a
+press, and the sound is made only then. */
+  sonify?: (HelixSpatialTreemap["sonify"]) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  "sonify-duration"?: (HelixSpatialTreemap["sonifyDuration"] | `${number}`) | undefined;
+  /** How long each series takes to play, in milliseconds or as `3s`. */
+  sonifyDuration?: (HelixSpatialTreemap["sonifyDuration"]) | undefined;
+  /** The Listen button's words. */
+  "sonify-label"?: (HelixSpatialTreemap["sonifyLabel"]) | undefined;
+  /** The Listen button's words. */
+  sonifyLabel?: (HelixSpatialTreemap["sonifyLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  "sonify-stop-label"?: (HelixSpatialTreemap["sonifyStopLabel"]) | undefined;
+  /** The Listen button's words while the chart plays. */
+  sonifyStopLabel?: (HelixSpatialTreemap["sonifyStopLabel"]) | undefined;
+  /** `visible` draws the chart's text summary under it, as one line.
+`hidden`, or absent, says the summary to a screen reader and draws it
+for no one else. Reflected, because the stylesheet draws it by the
+attribute, and a page that sets the property, as React does, writes none. */
+  summary?: (HelixSpatialTreemap["summary"]) | undefined;
   /** The column of text that gathers the rows into groups, by its heading. None by default. */
   "group-by"?: (HelixSpatialTreemap["groupBy"]) | undefined;
   /** The column of text that gathers the rows into groups, by its heading. None by default. */
@@ -20406,11 +21412,38 @@ export type HelixTextareaElementEvent<E = Event> = TypedEvent<HelixTextarea, E>;
 /** `helix-before-change` event type */
 export type HelixTextareaHelixBeforeChangeElementEvent =
   HelixTextareaElementEvent<HelixBeforeChangeEvent>;
+/** `helix-before-listen` event type */
+export type HelixTextareaHelixBeforeListenElementEvent =
+  HelixTextareaElementEvent<HelixBeforeListenEvent>;
 /** `helix-clear` event type */
 export type HelixTextareaHelixClearElementEvent =
   HelixTextareaElementEvent<HelixClearEvent>;
+/** `helix-listen` event type */
+export type HelixTextareaHelixListenElementEvent =
+  HelixTextareaElementEvent<HelixListenEvent>;
 
 export type HelixTextareaVueProps = {
+  /** What a screen reader hears as listening starts. */
+  "listening-label"?: (HelixTextarea["listeningLabel"]) | undefined;
+  /** What a screen reader hears as listening starts. */
+  listeningLabel?: (HelixTextarea["listeningLabel"]) | undefined;
+  /** What a screen reader hears as listening stops. */
+  "stopped-listening-label"?: (HelixTextarea["stoppedListeningLabel"]) | undefined;
+  /** What a screen reader hears as listening stops. */
+  stoppedListeningLabel?: (HelixTextarea["stoppedListeningLabel"]) | undefined;
+  /** Draws a button that listens for dictation and types what it hears at
+the caret. Nothing listens until the button is pressed, and the
+microphone is let go as listening stops. An input of type `password`,
+`email` or `number` draws no button. */
+  voice?: (HelixTextarea["voice"]) | undefined;
+  /** The dictation button's name while it is not listening. */
+  "voice-label"?: (HelixTextarea["voiceLabel"]) | undefined;
+  /** The dictation button's name while it is not listening. */
+  voiceLabel?: (HelixTextarea["voiceLabel"]) | undefined;
+  /** The dictation button's name while it listens. */
+  "voice-stop-label"?: (HelixTextarea["voiceStopLabel"]) | undefined;
+  /** The dictation button's name while it listens. */
+  voiceStopLabel?: (HelixTextarea["voiceStopLabel"]) | undefined;
   /** The value the control starts with. A form reset returns it to this value,
 and to the `value` attribute where this one is not written, as a native
 control resets to the `value` it declares. */
@@ -20579,6 +21612,9 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixTextarea["name"]) | undefined;
+  /** The engine this field listens through, in place of the one
+`registerSpeechEngine` gave the page, or the browser's own. */
+  speechEngine?: (HelixTextarea["speechEngine"]) | undefined;
   /** The direction of the selection, as a native textarea reports it.
 
 **The whole reason this renders a real `<textarea>` is the caret**, and the
@@ -20606,8 +21642,12 @@ export type HelixTextareaVueEvents = {
   change: HelixTextareaElementEvent;
   /** Fired as the text changes, and cancelable. */
   "helix-before-change": HelixTextareaHelixBeforeChangeElementEvent;
+  /** The dictation button was pressed. Cancelable: cancel it to keep the field from listening. */
+  "helix-before-listen": HelixTextareaHelixBeforeListenElementEvent;
   /** Fired after the clear button has emptied the field, after `input` and `change`. */
   "helix-clear": HelixTextareaHelixClearElementEvent;
+  /** Dictation settled on a phrase and put it in the value, after the field's own `input`. */
+  "helix-listen": HelixTextareaHelixListenElementEvent;
   /** Fired after the value changes. */
   input: HelixTextareaElementEvent;
 };
@@ -21560,6 +22600,10 @@ keys joined by `+`, the last one the key, as `Announcement`'s `hotkey`
 reads them: `mod` is Command on Apple devices and Control elsewhere.
 Empty turns it off. */
   hotkey?: (HelixToast["hotkey"]) | undefined;
+  /** What the hotkey does, as a list of the page's shortcuts says it. */
+  "hotkey-label"?: (HelixToast["hotkeyLabel"]) | undefined;
+  /** What the hotkey does, as a list of the page's shortcuts says it. */
+  hotkeyLabel?: (HelixToast["hotkeyLabel"]) | undefined;
   /** Accessible name for the region, with `{hotkey}` filled in. Translate it with
 the rest of your interface. */
   label?: (HelixToast["label"]) | undefined;
@@ -21602,6 +22646,26 @@ the end of the line, or `start`, `top` or `bottom`. Unset is `end`. */
   /** The edge a touch or a pen swipes a message toward to dismiss it: `end`,
 the end of the line, or `start`, `top` or `bottom`. Unset is `end`. */
   swipeDirection?: (HelixToast["swipeDirection"]) | undefined;
+  /** What a message `undoable()` made says after its own words, with `{keys}`
+for the chord that undoes it, spoken as words. */
+  "undo-hint"?: (HelixToast["undoHint"]) | undefined;
+  /** What a message `undoable()` made says after its own words, with `{keys}`
+for the chord that undoes it, spoken as words. */
+  undoHint?: (HelixToast["undoHint"]) | undefined;
+  /** The keys that undo the newest message `undoable()` made, as `hotkey`
+reads them. Empty turns them off, for an app whose own undo holds them,
+and leaves the Undo button. A key the app already handled, by calling
+`preventDefault()`, is left to it. */
+  "undo-keys"?: (HelixToast["undoKeys"]) | undefined;
+  /** The keys that undo the newest message `undoable()` made, as `hotkey`
+reads them. Empty turns them off, for an app whose own undo holds them,
+and leaves the Undo button. A key the app already handled, by calling
+`preventDefault()`, is left to it. */
+  undoKeys?: (HelixToast["undoKeys"]) | undefined;
+  /** The words on the Undo button of a message `undoable()` made. */
+  "undo-label"?: (HelixToast["undoLabel"]) | undefined;
+  /** The words on the Undo button of a message `undoable()` made. */
+  undoLabel?: (HelixToast["undoLabel"]) | undefined;
 };
 
 export type HelixToastVueEvents = {
@@ -23957,6 +25021,8 @@ export type CustomCssProperties = {
   "--chat-composer-border-width"?: (string) | undefined;
   /** Maximum height the field grows to. */
   "--chat-composer-max-block-size"?: (string) | undefined;
+  /** How loud the microphone is while the field listens for dictation, from 0 to 1, which the element sets; the ring around the dictation button grows with it. */
+  "--dictation-level"?: (string) | undefined;
   /** Fill behind a slotted indicator, drawn as a chip so its icon and its text read as one unit. */
   "--chat-indicator-background-color"?: (string) | undefined;
   /** Fill behind a turn. */
@@ -24063,6 +25129,28 @@ export type CustomCssProperties = {
   "--code-block-mark-size"?: (string) | undefined;
   /** Written by the block on each `mark`: how far down the code its run of lines starts. Do not set it. */
   "--code-block-mark-start"?: (string) | undefined;
+  /** The ground the code is drawn on. Defaults to the page's background. */
+  "--code-editor-background-color"?: (string) | undefined;
+  /** The frame's height, as a length: 24rem unless set. Ignored with `fill`, where the container decides it. */
+  "--code-editor-block-size"?: (string) | undefined;
+  /** The frame's edge and the lines between its strips. */
+  "--code-editor-border-color"?: (string) | undefined;
+  /** The code's size. Defaults to `text-sm`. */
+  "--code-editor-font-size"?: (string) | undefined;
+  /** The fill of the header, the find bar, and the status line. */
+  "--code-editor-header-background-color"?: (string) | undefined;
+  /** The frame's corner radius. */
+  "--code-editor-radius"?: (string) | undefined;
+  /** Fill behind the code. */
+  "--code-input-background-color"?: (string) | undefined;
+  /** Edge of the field at rest. Hover, focus and an error still draw their own. */
+  "--code-input-border-color"?: (string) | undefined;
+  /** The code's size. Defaults to `text-sm`, and never under 16px on a touch screen. */
+  "--code-input-font-size"?: (string) | undefined;
+  /** Space between the edge of the field and the code. */
+  "--code-input-padding"?: (string) | undefined;
+  /** Corner radius of the field. */
+  "--code-input-radius"?: (string) | undefined;
   /** Fill behind the fragment. Defaults to the foreground color at 6%, which looks the same on a light page and a dark one. */
   "--code-background-color"?: (string) | undefined;
   /** The fragment's typeface. Defaults to the mono face. */
@@ -25529,6 +26617,16 @@ export type CustomCssProperties = {
   "--select-shadow"?: (string) | undefined;
   /** Maximum height of the panel. */
   "--select-surface-max-block-size"?: (string) | undefined;
+  /** The badge's fill. Defaults to `surface-inverse`. */
+  "--shortcut-overlay-badge-background-color"?: (string) | undefined;
+  /** The badge's edge. Defaults to `border-floating`, which a theme sets to zero where a shadow alone lifts a surface. */
+  "--shortcut-overlay-badge-border-width"?: (string) | undefined;
+  /** The badge's text. Defaults to `foreground-inverse`. */
+  "--shortcut-overlay-badge-color"?: (string) | undefined;
+  /** The widest a badge grows before its name ends in an ellipsis. Defaults to 16rem. */
+  "--shortcut-overlay-badge-max-inline-size"?: (string) | undefined;
+  /** The badge's lift. Defaults to `shadow-floating`. */
+  "--shortcut-overlay-badge-shadow"?: (string) | undefined;
   /** The height of the block shape, which is the shape when `shape` is unset. Defaults to the control height. */
   "--skeleton-block-size"?: (string) | undefined;
   /** The placeholder's fill. */
@@ -26511,6 +27609,18 @@ export interface WcToolkitVueGlobalComponents {
     HelixCodeBlockVueProps,
     HelixCodeBlockVueEvents
   >;
+  /** Drawn as Terminal and Code Block are: the code on the page's ground, with a header, a find bar and a status line each a strip on the raised surface, one frame around them. It is 24rem tall unless 'fill' is set or '--code-editor-block-size' says otherwise. An engine draws inside it: '@fusion.dev/helix-editor' themes CodeMirror's gutter, caret, selection and syntax from your tokens, and draws a problem's line number in its tone.  Set 'fill' for an editor that fills a pane, such as one side of a split view. */
+  "helix-code-editor": DefineCustomElement<
+    HelixCodeEditor,
+    HelixCodeEditorVueProps,
+    HelixCodeEditorVueEvents
+  >;
+  /** Uses the same frame as 'Textarea' and 'Input', so a form of mixed fields matches, with the code in the mono face at the size Code Block draws it. The colors are the syntax tokens, through the highlighter the page registered: 'import '@fusion.dev/helix-sandbox/code-block'' colors every Code Block and Code Input on the page. */
+  "helix-code-input": DefineCustomElement<
+    HelixCodeInput,
+    HelixCodeInputVueProps,
+    HelixCodeInputVueEvents
+  >;
   /** The text is one step smaller than the prose around it, because a monospace face looks larger than proportional text at the same nominal size. Set '--code-size' to change it. */
   "helix-code": DefineCustomElement<
     HelixCode,
@@ -26853,6 +27963,12 @@ export interface WcToolkitVueGlobalComponents {
     HelixMapTerrainVueProps,
     HelixMapTerrainVueEvents
   >;
+  /** The document is drawn by the page's prose recipe: put 'data-prose' on the element or on a container, and '@fusion.dev/helix-styles' sets its type, spacing, lists, and tables. A fence is drawn by 'Code Block' and an alert by 'Callout', in this tier.  While 'streaming', the block still arriving wraps its lines in the plain way, never 'pretty' or 'balance', since those move earlier line breaks as each word arrives. */
+  "helix-markdown": DefineCustomElement<
+    HelixMarkdown,
+    HelixMarkdownVueProps,
+    HelixMarkdownVueEvents
+  >;
   /** Styles the trigger and lays out the panel it opens as a grid of columns. What opens and closes the panel comes from the base class.  **The panel's contents are laid out by 'helix.css'**, through attributes you write on your own markup: 'data-megamenu-group' on each column, 'data-megamenu-heading' on a column's heading, and 'data-megamenu-item' on a link that carries a title in '<strong>' and a line of description in '<span>' or '<p>', with an icon before them. A plain '<a>' in a group is drawn as a navigation item. Without the attributes the panel holds your markup as you styled it. */
   "helix-megamenu": DefineCustomElement<
     HelixMegamenu,
@@ -27075,6 +28191,12 @@ export interface WcToolkitVueGlobalComponents {
     HelixSelectVueProps,
     HelixSelectVueEvents
   >;
+  /** Each badge is a small inverse plate, as a tooltip is, with the keys first and the control's name after them, centered under the control. The sheet is a 'Dialog' listing each shortcut's name with its keys at the end of the row. */
+  "helix-shortcut-overlay": DefineCustomElement<
+    HelixShortcutOverlay,
+    HelixShortcutOverlayVueProps,
+    HelixShortcutOverlayVueEvents
+  >;
   /** Animates a highlight sweeping across the block, which reads as work in progress. A block fading in and out can look broken, so 'effect="pulse"' is a choice rather than the default.  Around content with 'loading', the skeleton takes the content's box and paints over it, and the content is hidden until 'loading' is taken off.  **'lines' draws a paragraph.** With 'shape="text"' and 'lines="3"', one element stands in for three lines of text: each line a 'skeleton' part one 'em' tall, spaced a body line height apart, and the last one shorter, as the end of a paragraph is. */
   "helix-skeleton": DefineCustomElement<
     HelixSkeleton,