@fusion.dev/helix 0.170.0 → 0.172.0

package/types/vue.d.ts

@@ -3318,6 +3318,10 @@ export type HelixChatComposerHelixTypingElementEvent =
   HelixChatComposerElementEvent<HelixTypingEvent>;
 
 export type HelixChatComposerVueProps = {
+  /** 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. */
+  feedback?: (HelixChatComposer["feedback"]) | undefined;
   /** The field's name, read by screen readers. */
   label?: (HelixChatComposer["label"]) | undefined;
   /** The most characters a draft can have. The field stops taking more. */
@@ -4005,6 +4009,12 @@ export type HelixCodeBlockHelixToggleElementEvent =
   HelixCodeBlockElementEvent<HelixToggleEvent>;
 
 export type HelixCodeBlockVueProps = {
+  /** The lines to mark as inserted, as numbers and ranges counted from 1, such
+as `3-4`. Drawn as `mark-lines` is, in the added color. Not for a diff. */
+  "added-lines"?: (HelixCodeBlock["addedLines"]) | undefined;
+  /** The lines to mark as inserted, as numbers and ranges counted from 1, such
+as `3-4`. Drawn as `mark-lines` is, in the added color. Not for a diff. */
+  addedLines?: (HelixCodeBlock["addedLines"]) | undefined;
   /** The name of a block that scrolls, which is a tab stop while it does.
 
 Where the block has a name, the scroller says it too, such as "Code,
@@ -4163,6 +4173,12 @@ A false boolean reflects as the attribute's absence, so this costs no
 reflected property taking no default is satisfied by the default being
 `false`. */
   noCopy?: (HelixCodeBlock["noCopy"]) | undefined;
+  /** The lines to mark as deleted, as numbers and ranges counted from 1. Drawn
+as `mark-lines` is, in the removed color. Not for a diff. */
+  "removed-lines"?: (HelixCodeBlock["removedLines"]) | undefined;
+  /** The lines to mark as deleted, as numbers and ranges counted from 1. Drawn
+as `mark-lines` is, in the removed color. Not for a diff. */
+  removedLines?: (HelixCodeBlock["removedLines"]) | undefined;
   /** The words of a button that shows a folded run of unchanged lines, in a
 diff with `context-lines`. `{count}` is how many. */
   "show-unchanged-label"?: (HelixCodeBlock["showUnchangedLabel"]) | undefined;
@@ -4789,10 +4805,11 @@ would give one control two of each. What is left is the validity call and
 the anchor the browser points its bubble at.
 
 **Text that is not a color is bad input**, so a form does not submit
-`#00` from a half-typed value. The picker draws no message of its own, so
-reporting it as each keystroke arrives shows nothing until the form asks;
-Color Input shows its own message against the field the reader typed
-into. */
+`#00` from a half-typed value. The picker marks it, and says
+`badInputMessage` under itself, once the reader leaves the value field or
+presses Enter, and a missing color once the reader has committed one or a
+form has refused the picker. Color Input shows its own message against the
+field the reader typed into. */
   required?: (HelixColorPicker["required"]) | undefined;
   /** What the square's horizontal ramp is called. */
   "saturation-label"?: (HelixColorPicker["saturationLabel"]) | undefined;
@@ -5145,12 +5162,13 @@ language. */
   locale?: (HelixCombobox["locale"]) | undefined;
   /** Whether more than one option can be chosen.
 
-The list already does the work: `value` comes apart on commas, a press
-toggles rather than replaces, and the arrows move without choosing. What
-this adds is the tags, and keeping the panel open between picks.
+The list already does the work: `value` is the chosen values joined with
+commas, a press toggles rather than replaces, and the arrows move without
+choosing. What this adds is the tags, and keeping the panel open between
+picks.
 
-A comma is therefore not available inside an option's value, which is the
-listbox's contract and not this element's to change.
+An option's value may hold a comma, and it is read as one value, as
+`Select` and `Listbox` read it. So may an answer the reader created.
 
 **The list is told, and the field is not.** `aria-multiselectable` belongs
 to `listbox`, `grid`, `tree` and `tablist`, and `combobox` dropped it in
@@ -5337,6 +5355,18 @@ so a palette filtered on a server sends one `helix-filter` for a word.
 so a palette filtered on a server sends one `helix-filter` for a word.
 `0` filters on every keystroke. See Listbox's `filter-delay`. */
   filterDelay?: (HelixCommand["filterDelay"]) | undefined;
+  /** Where Home and End go from the filter field.
+
+Absent, they move the caret, as APG's combobox has them. `list` moves the
+highlight to the first or the last command, as React Aria's Autocomplete
+does, and Shift with either still selects the text. */
+  "home-end"?: (HelixCommand["homeEnd"]) | undefined;
+  /** Where Home and End go from the filter field.
+
+Absent, they move the caret, as APG's combobox has them. `list` moves the
+highlight to the first or the last command, as React Aria's Autocomplete
+does, and Shift with either still selects the text. */
+  homeEnd?: (HelixCommand["homeEnd"]) | undefined;
   /** The key that opens the palette, written as `mod+k`, `shift+p`, or `k`,
 in Kbd's chord spelling: `mod` is Command or Control, `ctrl`, `cmd`,
 `alt` and `shift` the keys they name.
@@ -5354,6 +5384,10 @@ and `open`, `toggle` and the dialog's parts do nothing. */
   inline?: (HelixCommand["inline"]) | undefined;
   /** Accessible name for the overlay, which has no visible heading. */
   label?: (HelixCommand["label"]) | undefined;
+  /** How the commands are laid out, as Listbox's `layout`: `grid` draws them in
+rows and columns, for a palette of icons or emoji, and the arrow keys
+follow the rows and the columns. Absent is one command under another. */
+  layout?: (HelixCommand["layout"]) | undefined;
   /** What the list says when its commands could not be loaded, such as after a
 request to a server fails. Empty, null or no attribute is no error, so
 removing the attribute clears it. Passed to the list, which shows it
@@ -6007,7 +6041,11 @@ thousand rows, where the page is a reasonable fetch and a poor render.
 
 Off by default. Windowing costs a scroll listener, a measurement per row
 drawn, and a `block-size` on the scrolling box, and a table of twenty rows
-should pay none of them. */
+should pay none of them.
+
+While windowed, the `table` part scrolls on this tier: it carries
+`data-scroller`, and `core` ships `[data-scroller] { overflow: auto }` into
+every shadow root. You still need to give it a block size. */
   windowed?: (HelixDataTable["windowed"]) | undefined;
   /** Every row of the result, in the order it arrived.
 
@@ -7961,6 +7999,13 @@ nothing between them, because a word every chip carries is a word nobody
 reads. The moment somebody picks a different comparison it appears, which
 makes an unusual filter look unusual. */
   operatorLabel?: (HelixFilterChip["operatorLabel"]) | undefined;
+  /** Whether the remove button is a tab stop of its own.
+
+`FilterInput` writes `false` on the chips in its `tags` slot: the field's
+text is its one tab stop, and the arrow keys move from the text to the
+chips, as in a `multiple` Combobox. No attribute: it is coordination
+between elements, as `Tag.dismissTabStop` is. */
+  dismissTabStop?: (HelixFilterChip["dismissTabStop"]) | undefined;
 };
 
 export type HelixFilterChipVueEvents = {
@@ -8201,6 +8246,18 @@ and this one was the English a form in another language still spoke in
 the bubble it raises on submit: `feedback` replaces the message under
 the field and does not reach that one. */
   valueMissingMessage?: (HelixFilterInput["valueMissingMessage"]) | undefined;
+  /** Whether the field keeps a `FilterChip` for each filter in its `tags` slot,
+from the `helix-facet` events it hears.
+
+Off, you build the chips, which is what you do when your own model holds
+the filters. On, a filter typed, picked, or changed adds or updates the
+chip for its field, one with no values takes it away (unless its
+comparison takes none, such as "is empty"), and removing the chip clears
+the filter. A `helix-facet` you cancel changes no chip.
+
+The chips are elements the field adds to its own children, so leave this
+off where a framework renders those children and would remove them. */
+  chips?: (HelixFilterInput["chips"]) | undefined;
   /** Shows a button that empties the field.
 
 The text only. The tokens are the consumer's markup and this element is not
@@ -8222,6 +8279,29 @@ what you slot and you narrow it. */
 being typed, as React Aria's Autocomplete filters. Off, the panel shows
 what you slot and you narrow it. */
   filterSuggestions?: (HelixFilterInput["filterSuggestions"]) | undefined;
+  /** Whether the suggestions are still loading, such as while a request for the
+values of a typed key is out.
+
+The panel opens on `loading-text`, or the `loading` slot, while the field
+has focus, and a screen reader hears it. Slot the options and clear this
+when they arrive. */
+  loading?: (HelixFilterInput["loading"]) | undefined;
+  /** Text the panel shows while the suggestions load. */
+  "loading-text"?: (HelixFilterInput["loadingText"]) | undefined;
+  /** Text the panel shows while the suggestions load. */
+  loadingText?: (HelixFilterInput["loadingText"]) | undefined;
+  /** Text the panel shows when `filter-suggestions` hides every suggestion, such
+as "No matching filters".
+
+Empty, or no `no-results` slot, and the panel closes instead, as it does
+when it has nothing to offer. */
+  "no-results-text"?: (HelixFilterInput["noResultsText"]) | undefined;
+  /** Text the panel shows when `filter-suggestions` hides every suggestion, such
+as "No matching filters".
+
+Empty, or no `no-results` slot, and the panel closes instead, as it does
+when it has nothing to offer. */
+  noResultsText?: (HelixFilterInput["noResultsText"]) | undefined;
   /** The text shown while the field is empty.
 
 Not a label: it goes when typing starts. */
@@ -12244,6 +12324,14 @@ or on Alt+Down or Alt+Up. */
 
 It moves if that side does not fit. */
   placement?: (HelixMenu["placement"]) | undefined;
+  /** What a screen reader hears when the filter narrows the rows. `{count}` is
+how many rows are left, written in the locale, and each language writes
+the forms it has, as Listbox's `results-label` does. */
+  "results-label"?: (HelixMenu["resultsLabel"]) | undefined;
+  /** What a screen reader hears when the filter narrows the rows. `{count}` is
+how many rows are left, written in the locale, and each language writes
+the forms it has, as Listbox's `results-label` does. */
+  resultsLabel?: (HelixMenu["resultsLabel"]) | undefined;
   /** 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;
@@ -12254,11 +12342,21 @@ 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 values of the choice rows that are checked, anywhere in the menu, in
+document order.
+
+Set it to check exactly those rows and uncheck every other choice row, as
+React Aria's `selectedKeys` controls a menu's selection from one place.
+Each row keeps its own `checked` too, which this reads and writes. `change`
+is sent on the menu when a reader's choice changes it. */
+  checkedValues?: (HelixMenu["checkedValues"]) | undefined;
 };
 
 export type HelixMenuVueEvents = {
   /** The menu opened or closed. The event carries `newState` and `oldState`. */
   toggle: HelixMenuToggleElementEvent;
+  /** A reader's choice checked or unchecked rows. Read `checkedValues` for the rows that are checked now. */
+  change: HelixMenuElementEvent;
   /** The menu is about to close. Cancelable: cancel it to keep it open. */
   "helix-before-close": HelixMenuHelixBeforeCloseElementEvent;
   /** The menu is about to open. Cancelable: cancel it to keep it closed. */
@@ -12883,9 +12981,13 @@ speaks it: `feedback` replaces the message under the field and does not
 reach the bubble. Unset is the sentence registered for the page's
 language, then the English. */
   badInputMessage?: (HelixNumberInput["badInputMessage"]) | undefined;
-  /** The name of the step down button, read by screen readers. */
+  /** The name of the step down button, read by screen readers. The field's
+label follows it, so a reader hears "Decrease Quantity", as React Aria
+names its steppers. */
   "decrement-label"?: (HelixNumberInput["decrementLabel"]) | undefined;
-  /** The name of the step down button, read by screen readers. */
+  /** The name of the step down button, read by screen readers. The field's
+label follows it, so a reader hears "Decrease Quantity", as React Aria
+names its steppers. */
   decrementLabel?: (HelixNumberInput["decrementLabel"]) | undefined;
   /** `Intl.NumberFormat` options the number is shown with while the field is
 not being edited: a currency, a percent, a unit, or a number of decimals.
@@ -12903,9 +13005,13 @@ Written as JSON in the attribute.
 <helix-number-input format-options='{"style":"currency","currency":"EUR"}'></helix-number-input>
 ``` */
   formatOptions?: (HelixNumberInput["formatOptions"]) | undefined;
-  /** The name of the step up button, read by screen readers. */
+  /** The name of the step up button, read by screen readers. The field's
+label follows it, so a reader hears "Increase Quantity", as React Aria
+names its steppers. */
   "increment-label"?: (HelixNumberInput["incrementLabel"]) | undefined;
-  /** The name of the step up button, read by screen readers. */
+  /** The name of the step up button, read by screen readers. The field's
+label follows it, so a reader hears "Increase Quantity", as React Aria
+names its steppers. */
   incrementLabel?: (HelixNumberInput["incrementLabel"]) | undefined;
   /** How many steps `PageUp` and `PageDown` move.
 
@@ -14076,17 +14182,42 @@ hydration, or diffed by a framework, it comes back holding whatever the
 last reader did rather than what the author wrote. `:state(open)` carries
 the resolved state for stylesheets, which is what the mirror is for. */
   open?: (HelixPopover["open"]) | undefined;
+  /** The element the panel opens against, where that is not the trigger: its
+`id` in the same document or shadow root, or the element itself. Left
+empty, the panel opens against the trigger, or against the button whose
+command opened it. */
+  anchor?: (HelixPopover["anchor"]) | undefined;
   /** Draws a point on the panel's edge facing the trigger.
 
 Off by default, which is the house style: a panel that opens from its
 trigger already reads as belonging to it. */
   arrow?: (HelixPopover["arrow"]) | undefined;
+  /** How close to the window's edges the panel may come, in pixels, when it
+slides, shrinks or moves to the other side to fit. Left unset, it slides
+and shrinks to 8 pixels from an edge and moves to the other side only
+once it would cross one. */
+  "container-padding"?: (HelixPopover["containerPadding"] | `${number}`) | undefined;
+  /** How close to the window's edges the panel may come, in pixels, when it
+slides, shrinks or moves to the other side to fit. Left unset, it slides
+and shrinks to 8 pixels from an edge and moves to the other side only
+once it would cross one. */
+  containerPadding?: (HelixPopover["containerPadding"]) | undefined;
+  /** How far to slide the panel along the side it is on, in pixels: to the
+right on the top or the bottom, and down on the left or the right. */
+  "cross-offset"?: (HelixPopover["crossOffset"] | `${number}`) | undefined;
+  /** How far to slide the panel along the side it is on, in pixels: to the
+right on the top or the bottom, and down on the left or the right. */
+  crossOffset?: (HelixPopover["crossOffset"]) | undefined;
   /** The panel's name where nothing else names it: no `label`, no heading in
 the panel, and no `aria-labelledby` on the host. */
   "fallback-label"?: (HelixPopover["fallbackLabel"]) | undefined;
   /** The panel's name where nothing else names it: no `label`, no heading in
 the panel, and no `aria-labelledby` on the host. */
   fallbackLabel?: (HelixPopover["fallbackLabel"]) | undefined;
+  /** Whether the panel moves to the other side of the trigger when its own
+side has no room. On by default. Write `flip="false"` to keep it on its
+side, where it shrinks to fit, as React Aria's `shouldFlip` turns off. */
+  flip?: (HelixPopover["flip"]) | undefined;
   /** The panel's name, read by screen readers. Left empty, the first heading in
 the panel names it, and then `fallback-label`. */
   label?: (HelixPopover["label"]) | undefined;
@@ -14964,6 +15095,11 @@ it, here or anywhere: a frame is a document of its own and what is written
 on this host reaches nothing inside it, which is the same reason
 `colorMode` has to be sent rather than set. */
   direction?: (HelixSandboxPreview["direction"]) | undefined;
+  /** The packages an example can import by name in the built-in document,
+each mapped to the address of an ES module, as an import map's `imports`.
+Set it as JSON in the attribute or as an object. Not read where `src` is
+set. */
+  imports?: (HelixSandboxPreview["imports"]) | undefined;
   /** The frame's name, read by screen readers. */
   label?: (HelixSandboxPreview["label"]) | undefined;
   /** How the example is placed in the frame.
@@ -15231,6 +15367,10 @@ the pane's `label`. */
   /** The pane's file name, such as `index.html`, on its tab where a sandbox
 holds several panes. Empty puts the pane's `name` on the tab. */
   label?: (HelixSandboxSource["label"]) | undefined;
+  /** Whether each line of the source is numbered, in a gutter beside it. */
+  "line-numbers"?: (HelixSandboxSource["lineNumbers"]) | undefined;
+  /** Whether each line of the source is numbered, in a gutter beside it. */
+  lineNumbers?: (HelixSandboxSource["lineNumbers"]) | undefined;
   /** Which source this pane holds. Every `helix-before-edit` event includes it.
 
 `html` and `css` are what the sandbox root routes on; any other name is
@@ -16777,7 +16917,8 @@ Ignored once `active` is written. */
 Ignored once `active` is written. */
   defaultActive?: (HelixSteps["defaultActive"]) | undefined;
   /** Whether the arrow keys move focus between the stages' names, along the
-way the steps run. Off by default, so the arrows keep scrolling the page. */
+way the steps run, and the names are one tab stop. Off by default, so the
+arrows keep scrolling the page. */
   arrows?: (HelixSteps["arrows"]) | undefined;
   /** What marks a stage `complete`.
 
@@ -16874,7 +17015,9 @@ with the page. */
   /** Whether a reader may pass the stage without finishing it, in a sequence
 with `linear`. Ark UI's skippable step. */
   optional?: (HelixStep["optional"]) | undefined;
-  /** The value the step sends in `helix-select`. */
+  /** The value the step sends in `helix-select`, and what names the step in its
+sequence's `active`. Without one, the sequence names the step by its place,
+counted from 1. */
   value?: (HelixStep["value"]) | undefined;
 };
 
@@ -22889,6 +23032,8 @@ export type CustomCssProperties = {
   "--sandbox-source-invalid-color"?: (string) | undefined;
   /** Color of a `keyword` run, under `tokenize`. Defaults to `--helix-color-syntax-keyword`. */
   "--sandbox-source-keyword-color"?: (string) | undefined;
+  /** Color of the line numbers, under `line-numbers`. Defaults to `--helix-color-foreground-subtle`. */
+  "--sandbox-source-line-number-color"?: (string) | undefined;
   /** Minimum height of the pane. */
   "--sandbox-source-min-block-size"?: (string) | undefined;
   /** Color of a `name` run, under `tokenize`. Defaults to `--helix-color-syntax-name`. */
@@ -24301,7 +24446,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixRatingVueProps,
     HelixRatingVueEvents
   >;
-  /** A sandboxed '<iframe>' that loads 'src', a document you provide. That document imports what the examples need, listens for a render message, and writes the markup into itself.  **Without 'src', the frame loads a built-in document**, so a sandbox renders with nothing to host. It runs HTML, CSS, and scripts, and reports the console, uncaught errors, its height, and presses as a frame on 'servePreview' does. It defines no element, so an example that uses Helix components needs a 'src' that imports them.  **Examples render in a frame**, so an example's styles and scripts do not affect the page around the sandbox, and 'position: fixed' stays inside the pane. The frame starts empty, with its own stylesheets and its own custom element registry, so 'src' must load the styles and components the examples use.  **The source is untrusted, and the frame keeps it isolated.** The frame uses 'sandbox="allow-scripts"' and never 'allow-same-origin'. Together, the two let a document on the same origin remove its own sandbox, which is the same as having none.  **A preview says where it is.** It is ':state(loading)' from the moment it has a 'src' until that document can take the example, and again through 'reload()'. It is ':state(failed)' once the example throws an error it does not catch, until the next source is sent, which a frame on 'servePreview' reports. A page draws its own spinner or message from either, such as a sibling shown by 'helix-sandbox-preview:state(failed) + .message'.  **A failed preview shows the error over the example**, in the 'error' part, until the next source is sent. The terminal says it too, so the part is not announced. Hide it with '::part(error) { display: none }' where the page draws its own.  **'controls' draws two buttons in the preview's corner**: one reloads the frame's document, as 'reload()' does, and one opens the example in a new tab, as 'open()' does. The tab runs it in a frame sandboxed as this one is. */
+  /** A sandboxed '<iframe>' that loads 'src', a document you provide. That document imports what the examples need, listens for a render message, and writes the markup into itself.  **Without 'src', the frame loads a built-in document**, so a sandbox renders with nothing to host. It runs HTML, CSS, and scripts, and reports the console, uncaught errors, its height, and presses as a frame on 'servePreview' does. It defines no element, so an example that uses Helix components needs a 'src' that imports them.  **'imports' lets an example import packages by name** in the built-in document, as an import map: each name maps to the address of an ES module, such as '{"canvas-confetti": "https://esm.sh/canvas-confetti@1.9.3"}', and 'import confetti from 'canvas-confetti'' in the 'js' pane then loads it. A CDN that serves npm packages as modules, such as esm.sh or jsDelivr's '+esm', gives every package an address. A new map loads the document again, since a browser reads one only as a document starts. A 'src' document declares its own.  **Examples render in a frame**, so an example's styles and scripts do not affect the page around the sandbox, and 'position: fixed' stays inside the pane. The frame starts empty, with its own stylesheets and its own custom element registry, so 'src' must load the styles and components the examples use.  **The source is untrusted, and the frame keeps it isolated.** The frame uses 'sandbox="allow-scripts"' and never 'allow-same-origin'. Together, the two let a document on the same origin remove its own sandbox, which is the same as having none.  **A preview says where it is.** It is ':state(loading)' from the moment it has a 'src' until that document can take the example, and again through 'reload()'. It is ':state(failed)' once the example throws an error it does not catch, until the next source is sent, which a frame on 'servePreview' reports. A page draws its own spinner or message from either, such as a sibling shown by 'helix-sandbox-preview:state(failed) + .message'.  **A failed preview shows the error over the example**, in the 'error' part, until the next source is sent. The terminal says it too, so the part is not announced. Hide it with '::part(error) { display: none }' where the page draws its own.  **'controls' draws two buttons in the preview's corner**: one reloads the frame's document, as 'reload()' does, and one opens the example in a new tab, as 'open()' does. The tab runs it in a frame sandboxed as this one is. */
   "helix-sandbox-preview": DefineCustomElement<
     HelixSandboxPreview,
     HelixSandboxPreviewVueProps,
@@ -24313,7 +24458,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixSandboxVueProps,
     HelixSandboxVueEvents
   >;
-  /** A real '<textarea>', so undo, selection, spellcheck suppression, mobile keyboards, and screen reader support come from the platform.  Tab inserts two spaces, so you can indent code. To move focus out of the field, press Escape and then Tab. Shift+Tab moves focus back as it does anywhere else. The field's description says so to a screen reader.  **'tokenize' colors the source** with a highlighter you bring, such as one built on Lezer, Prism or Shiki. It is a function from the source to runs of text, each with an optional kind, and the pane draws the runs under a transparent field, so typing, selection and undo stay the textarea's. The kinds are 'callable', 'comment', 'constant', 'invalid', 'keyword', 'name', 'string' and 'tag', each colored by the '--helix-color-syntax-*' token of its name and a hook of its own, such as '--sandbox-source-keyword-color'. A run of any other kind is drawn in the field's own color. Every run with a kind is a 'token' part, and carries its kind as 'data-kind'. A 'tokenize' that throws leaves the source drawn plain and the field editable, and the error is reported to the page as an uncaught one. */
+  /** A real '<textarea>', so undo, selection, spellcheck suppression, mobile keyboards, and screen reader support come from the platform.  Tab inserts two spaces, so you can indent code. To move focus out of the field, press Escape and then Tab. Shift+Tab moves focus back as it does anywhere else. The field's description says so to a screen reader.  **'tokenize' colors the source** with a highlighter you bring, such as one built on Lezer, Prism or Shiki. It is a function from the source to runs of text, each with an optional kind, and the pane draws the runs under a transparent field, so typing, selection and undo stay the textarea's. The kinds are 'callable', 'comment', 'constant', 'invalid', 'keyword', 'name', 'string' and 'tag', each colored by the '--helix-color-syntax-*' token of its name and a hook of its own, such as '--sandbox-source-keyword-color'. A run of any other kind is drawn in the field's own color. Every run with a kind is a 'token' part, and carries its kind as 'data-kind'. A 'tokenize' that throws leaves the source drawn plain and the field editable, and the error is reported to the page as an uncaught one.  **'line-numbers' numbers each line** in a gutter beside the source. A line that wraps keeps one number. The numbers are drawn, and hidden from screen readers, which read the field.  Enter keeps the indentation of the line it breaks, and the new line is undone with the next undo as typing is.  **The source can be written inside the pane** where 'value' is not set: its text, or the markup of a '<template>' it holds, without the indentation the page gave it. Markup goes in a template so the page does not render it or run its scripts. Text inside the pane is read once, when it connects. */
   "helix-sandbox-source": DefineCustomElement<
     HelixSandboxSource,
     HelixSandboxSourceVueProps,

package/types/words.d.ts

@@ -1886,13 +1886,17 @@ declare module '@fusion.dev/helix-core' {
        */
       badInputMessage: Message
       /**
-       * The name of the step down button, read by screen readers.
+       * The name of the step down button, read by screen readers. The field's
+       * label follows it, so a reader hears "Decrease Quantity", as React Aria
+       * names its steppers.
        *
        * English: `Decrease`
        */
       decrementLabel: Message
       /**
-       * The name of the step up button, read by screen readers.
+       * The name of the step up button, read by screen readers. The field's
+       * label follows it, so a reader hears "Increase Quantity", as React Aria
+       * names its steppers.
        *
        * English: `Increase`
        */