@fusion.dev/helix-headless 0.105.0 → 0.106.0

package/dist/slider/root/slider-root.d.ts

@@ -5,30 +5,27 @@ declare const HelixHeadlessSlider_base: (new (...args: any[]) => import("@fusion
  * @summary A value chosen from a range by dragging.
  *
  * @description
- * A real `<input type="range">`, so the drag, the arrow keys, Home and End, the
- * page keys and the touch target are the platform's. The last is the one nobody
- * notices: a native range has a hit area larger than its thumb, sized by the
- * platform for a finger.
+ * Renders a native `<input type="range">`, so the drag, the arrow keys, Home,
+ * End, the page keys, and the touch target come from the platform. A native
+ * range has a hit area larger than its thumb, sized for a finger.
  *
- * **The value is a string, like every other form control's.** A range submits
- * text and `MixinControllerValue` holds text, so the number is a reading of the
- * value. `valueAsNumber` is there for arithmetic.
+ * The value is a string, like every other form control's, and
+ * `MixinControllerValue` holds text. Use `valueAsNumber` for arithmetic.
  *
- * **Marks are drawn rather than left to `<datalist>`**, whose ticks cannot be
- * styled and which Firefox does not render for a range at all. A mark is
- * decoration; what a reader can land on is `step`, which the input enforces
- * whether or not anything is drawn. `markers` is a count rather than a flag, so
- * a slider from zero to a hundred cannot silently ask for a hundred and one.
+ * Marks are drawn by the component. The ticks of a `<datalist>` cannot be
+ * styled, and Firefox does not render them for a range. Marks are decoration.
+ * `step` sets where the value can land, and the input enforces it whether or
+ * not marks are drawn. `markers` is a count, so a slider from zero to a hundred
+ * does not draw a hundred and one marks by accident.
  *
- * **A range is two of them.** There is no native two-thumb range, so two are
- * stacked on one track and each thumb keeps its own.
+ * A range with two thumbs is two inputs stacked on one track, because there is
+ * no native two-thumb range. Each thumb keeps its own value.
  *
- * **`required` arrives with the field mixin and cannot fail here**, which is
- * worth saying rather than leaving a reader to find. A range is never empty:
- * the platform shows its own midpoint whatever is set, and `willUpdate` seeds
- * that midpoint into `defaultValue` so the value agrees with the handle from the
- * first render. HTML does not apply `required` to a range either, so it stays
- * off the control and the marker beside the label is all it does.
+ * `required` comes with the field mixin and cannot fail. A range is never
+ * empty: the platform shows its midpoint when no value is set, and `willUpdate`
+ * seeds that midpoint into `defaultValue`, so the value matches the handle from
+ * the first render. HTML does not apply `required` to a range either, so it is
+ * not set on the input. It only adds the marker beside the label.
  *
  * @since 0.1.0
  * @status stable
@@ -36,33 +33,33 @@ declare const HelixHeadlessSlider_base: (new (...args: any[]) => import("@fusion
  * @aliases Range, Range input
  * @documentation https://fusion.dev/helix/components/slider
  *
- * @event {Event} change - Relayed once the reader has let go.
- * @event {HelixBeforeChangeEvent} helix-before-change - Fired as the value changes, and cancelable.
- * @event {Event} input - Announced once the value has moved.
+ * @event {Event} change - Fired when the user releases the thumb.
+ * @event {HelixBeforeChangeEvent} helix-before-change - Fired as the value changes. Cancelable: call `preventDefault()` to keep the current value.
+ * @event {Event} input - Fired after the value changes.
  *
  * @csspart control - The range input.
- * @csspart feedback - What is wrong with it.
- * @csspart field - The row: the control and its readout.
- * @csspart hint - Help under the track, while nothing is wrong.
- * @csspart label - The question, over the track.
- * @csspart marker - One mark.
+ * @csspart feedback - The error message under the track.
+ * @csspart field - The row that holds the control and its readout.
+ * @csspart hint - The help text under the track, shown while there is no error.
+ * @csspart label - The label above the track.
+ * @csspart marker - One mark on the track.
  * @csspart marker-label - The value a mark stands at, when `marker-labels` is set.
  * @csspart markers - The row of marks along the track.
- * @csspart output - The current value, shown beside it.
+ * @csspart output - The current value, shown beside the track.
  *
  * @cssproperty --slider-fraction - The value as a fraction of the range, 0 to 1.
  * @cssproperty --slider-from - Where a range's filled span starts, as a fraction of the track, 0 to 1.
  * @cssproperty --slider-marker-at - Where one marker sits, as a percentage of the track.
  * @cssproperty --slider-to - Where a range's filled span ends, as a fraction of the track, 0 to 1.
  *
- * @cssstate invalid - While there is feedback to show: the platform's verdict, or the consumer's `feedback`.
+ * @cssstate invalid - The slider has an error to show, from the browser's validation or from your `feedback`.
  */
 export declare class HelixHeadlessSlider extends HelixHeadlessSlider_base {
     protected readonly aria: AriaForwardController;
     /** Typed or dragged, so every edit is announced. See `announcesInput`. */
     protected readonly announcesInput = true;
     /**
-     * Whether each mark says which value it stands at.
+     * Shows the value at each mark.
      */
     markerLabels: boolean;
     /**
@@ -82,11 +79,11 @@ export declare class HelixHeadlessSlider extends HelixHeadlessSlider_base {
      */
     markers: number;
     /**
-     * The largest value the reader can choose.
+     * The largest value that can be chosen.
      */
     max: number;
     /**
-     * What the upper thumb of a range is called, after the slider's own label.
+     * The name of a range's upper thumb, read after the slider's label.
      *
      * **Named with the label rather than instead of it.** Each thumb was
      * `aria-label="${label} maximum"`, which overrode the `<label>` and read the
@@ -96,13 +93,13 @@ export declare class HelixHeadlessSlider extends HelixHeadlessSlider_base {
      */
     maximumLabel: string;
     /**
-     * The smallest value the reader can choose.
+     * The smallest value that can be chosen.
      */
     min: number;
-    /** What the lower thumb of a range is called, after the slider's own label. */
+    /** The name of a range's lower thumb, read after the slider's label. */
     minimumLabel: string;
     /**
-     * Which way the track runs, `vertical` standing it on end.
+     * The direction the track runs. `vertical` stands it on end.
      *
      * For a level rather than a quantity: a fader, a channel, anything a reader
      * pictures as high and low rather than as less and more. Absent is
@@ -115,7 +112,7 @@ export declare class HelixHeadlessSlider extends HelixHeadlessSlider_base {
      */
     orientation?: 'horizontal' | 'vertical';
     /**
-     * Whether there are two thumbs and the value is a pair.
+     * Adds a second thumb, so the value is a pair.
      *
      * The pair is one string, `"10,50"`, which is what a form submits and what
      * `MixinControllerValue` already holds. `valueAsNumber` reads the lower of
@@ -123,7 +120,7 @@ export declare class HelixHeadlessSlider extends HelixHeadlessSlider_base {
      */
     range: boolean;
     /**
-     * Whether the chosen value is shown beside the track.
+     * Shows the chosen value beside the track.
      */
     showValue: boolean;
     /**
@@ -214,7 +211,7 @@ export declare class HelixHeadlessSlider extends HelixHeadlessSlider_base {
     private snapped;
     protected willUpdate(changed: PropertyValues): void;
     protected updated(changed: PropertyValues): void;
-    /** How far one press of an arrow key moves it. */
+    /** How far one press of an arrow key moves the thumb. */
     step: number;
     protected render(): TemplateResult;
 }

package/dist/sparkline/root/sparkline-root.d.ts

@@ -1,35 +1,29 @@
 import { type Curve, HelixElement, SourceController } from '@fusion.dev/helix-core';
 import { type PropertyValues, type TemplateResult } from 'lit';
 /**
- * @summary A line with no axes, for the shape of a series beside the number it belongs to.
+ * @summary A small chart with no axes that shows the shape of a series beside its number.
  *
  * @description
- * The one chart here that takes its numbers from an attribute, and the reversal
- * is deliberate. Every other chart reads a table because a reader might want to
- * interrogate it; nobody interrogates the squiggle next to a figure. A
- * fourteen-row table behind a bare trend line is fourteen dates read aloud in
- * place of the one sentence that carries the meaning, so `values` is the list
- * and `label` is the sentence.
+ * Takes its numbers from the `values` attribute. The other charts read a table,
+ * but a table behind a small trend line would be read aloud row by row. Set
+ * `values` to the data and `label` to the one sentence a screen reader
+ * announces.
  *
- * That is the library's own rule rather than a second data channel: a content
- * property is its slot's fallback, which is why `Tooltip` takes `content` and
- * `Avatar` takes `name`. `for` stays for the sparkline that genuinely has a
- * table behind it, and it wins where both are given.
+ * This follows the library's rule that a content property is the fallback for
+ * its slot, as with `Tooltip`'s `content` and `Avatar`'s `name`. Use `for` when
+ * a sparkline has a real table behind it. `for` wins when both are set.
  *
- * **No label means decorative, and that is a choice rather than an oversight.**
- * A sparkline beside a stat that already says "Sessions, 1,102" has nothing of
- * its own to announce, and an unnamed `role="img"` announces "graphic" and
- * stops. So an unlabeled sparkline is `aria-hidden`, and a labeled one is an
- * image named by its sentence.
+ * Without a `label` the sparkline is decorative and `aria-hidden`, for example
+ * beside a stat that already says "Sessions, 1,102". With a `label` it is an
+ * image named by that sentence.
  *
- * It goes *beside* a `Stat` rather than inside one: a change beside a figure is
- * a second fact, which is what `Stat`'s own spec says. `Trend` composes the same
- * way.
+ * Place it beside a `Stat`, because a change beside a figure is a second fact,
+ * as `Stat`'s own spec says. `Trend` is composed the same way.
  *
- * The properties below are written by this component and read by whoever draws
- * it. A consumer sets none of them: they carry a number this element computed
- * and CSS cannot, which is what lets a stylesheet on this tier draw the thing
- * without measuring anything itself.
+ * The component writes the properties listed below, and the stylesheet that
+ * draws the sparkline reads them. Do not set them yourself. They carry numbers
+ * the component computes and CSS cannot, so a stylesheet can draw the sparkline
+ * without measuring anything.
  *
  * @since 0.1.0
  * @status stable
@@ -38,8 +32,8 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * @documentation https://fusion.dev/helix/components/sparkline
  *
  * @csspart area - The region between the line and the bottom of its range.
- * @csspart bar - One column, under `plot="bar"`.
- * @csspart line - The path itself.
+ * @csspart bar - One column, drawn when `plot="bar"`.
+ * @csspart line - The line's path.
  * @csspart svg - The drawing.
  * @csspart terminus - The mark on the last value.
  * @csspart wash-end - The far stop of the area's gradient.
@@ -50,7 +44,7 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  */
 export declare class HelixHeadlessSparkline extends HelixElement {
     /**
-     * How the line gets from one reading to the next.
+     * How the line is drawn from one reading to the next.
      *
      * **`smooth` is the resting curve.** A straight segment asserts nothing about
      * the values between two readings and a curve invents them, which is why
@@ -79,7 +73,7 @@ export declare class HelixHeadlessSparkline extends HelixElement {
      */
     curve?: Curve;
     /**
-     * The id of a table to read instead, when there is one behind the line.
+     * The id of a table to read the readings from, when a table holds the data.
      *
      * The first column of numbers is the series drawn. This wins over `values`,
      * because a table is the readable representation and a list of numbers in an
@@ -90,7 +84,7 @@ export declare class HelixHeadlessSparkline extends HelixElement {
      */
     for: string;
     /**
-     * What the line says, in a sentence.
+     * A sentence that describes what the line shows.
      *
      * "Sessions rose from 1,240 to 1,318 and fell to 1,102 over fourteen days" is
      * the accessible representation of a sparkline, and a list of the fourteen

package/dist/speed-dial/item/speed-dial-item.d.ts

@@ -1,19 +1,16 @@
 import { HelixElement } from '@fusion.dev/helix-core';
 import { type TemplateResult } from 'lit';
 /**
- * @summary One action in a speed dial: a mark, and a name beside it.
+ * @summary One action in a speed dial: an icon and a name beside it.
  *
  * @description
- * **A command, which is why this is a `menuitem` and a megamenu's rows are not.**
- * The distinction is what the thing does, not what it looks like: a megamenu
- * holds destinations, so it is a disclosure of links, and this holds actions a
- * screen can take, which is exactly what `role="menu"` was written for. The
- * roles follow the contents.
+ * Each item is a command, so it has the `menuitem` role. A megamenu holds
+ * destinations, so it is a disclosure of links. A speed dial holds actions,
+ * which is what `role="menu"` is for.
  *
- * **The name is text, not a title.** A dial's actions are icons, and an icon
- * with a `title` is an action whose name only exists for whoever hovers it long
- * enough. The label is rendered beside the mark and is the accessible name by
- * being there, so it is read, searched and translated like anything else.
+ * The name is text rendered beside the icon, and it is the accessible name. A
+ * `title` on an icon shows only on hover. Visible text is read, searched, and
+ * translated like other text.
  *
  * @since 0.1.0
  * @status stable
@@ -22,21 +19,21 @@ import { type TemplateResult } from 'lit';
  * @documentation https://fusion.dev/helix/components/speed-dial
  *
  * @slot - The action's name.
- * @slot icon - The mark, which is what a dial is read by.
+ * @slot icon - The action's icon, the main way the action is recognized.
  *
- * @event {HelixSelectEvent} helix-select - Fired when the action is chosen. Cancelable: refusing it takes the decision and nothing moves.
+ * @event {HelixSelectEvent} helix-select - The action was chosen. Cancelable: cancel it to keep the dial open.
  *
- * @csspart icon - The mark's box.
- * @csspart item - The control.
- * @csspart label - The name beside it.
+ * @csspart icon - The box that holds the icon.
+ * @csspart item - The control for the action.
+ * @csspart label - The action's name, beside the icon.
  */
 export declare class HelixHeadlessSpeedDialItem extends HelixElement {
     /**
-     * Whether the action can be chosen.
+     * Whether the action is disabled, so it cannot be chosen.
      */
     disabled: boolean;
     /**
-     * What this action stands for, carried in the event when it is chosen.
+     * The action's value, sent in `helix-select` when the action is chosen.
      */
     value: string;
     /**
@@ -45,14 +42,17 @@ export declare class HelixHeadlessSpeedDialItem extends HelixElement {
      * protected. Not a consumer's to read or set.
      */
     readonly isSpeedDialItem = true;
-    /** Puts focus on the control inside, which is what a reader can reach. */
+    /** Puts focus on the control inside the item. */
     focus(): void;
-    /** `NavigableItem`, so the arrow keys are the shared controller's business. */
+    /**
+     * Moves focus to the action. Part of `NavigableItem`, which the shared
+     * keyboard controller uses for the arrow keys.
+     */
     focusItem(): void;
-    /** Chooses the action, which is the same act as pressing it. */
+    /** Chooses the action, the same as pressing it. */
     select(): void;
     /**
-     * Whether this is the row the set is on, which here is where focus is.
+     * Whether the action has focus, which is what selected means in a speed dial.
      *
      * Asked of the document rather than of the shadow root: focus lands on the
      * control inside this element and the platform retargets it, so from outside

package/dist/speed-dial/root/speed-dial-root.d.ts

@@ -2,29 +2,26 @@ import { HelixElement, KeyboardNavigationController, type Placement, PopoverCont
 import { type PropertyValues, type TemplateResult } from 'lit';
 declare const HelixHeadlessSpeedDial_base: (new (...args: any[]) => import("@fusion.dev/helix-core").MixinControllerOpenInterface) & typeof HelixElement;
 /**
- * @summary A button that fans out the few actions a screen is for.
+ * @summary A floating button that opens a short list of the main actions on a screen.
  *
  * @description
- * **A menu, and deliberately not a new one.** Its rows are commands, which is
- * what `role="menu"` and `menuitem` exist for, so this takes them and takes the
- * behavior with them: the arrow keys are `KeyboardNavigationController`, the
- * panel is `PopoverController`, and open and closed is `MixinControllerOpen`.
- * `Menu` is built from the same pieces. What is not shared is what actually
- * differs: a dial has no submenus, no headers, no checkable rows and no long
- * list to type ahead through, and shipping it as an appearance of `Menu` would
- * mean defining what a dial with a submenu in it does.
+ * A speed dial is a menu. Its items are commands, so it uses `role="menu"` and
+ * `menuitem`, and it is built from the same pieces as `Menu`:
+ * - `KeyboardNavigationController` for the arrow keys
+ * - `PopoverController` for the panel
+ * - `MixinControllerOpen` for open and closed
  *
- * **The trigger is a control the consumer slots**, and the floating action
- * button is the usual one: `IconButton` with `shape="circle"` and `raised`.
- * There is no `helix-fab`, because it would re-declare `emphasis`, `tone`,
- * `label` and a size around a control that already has all four. A round raised
- * button is a shape, and where it sits is `data-dock` in the base layer.
+ * It is a separate component because a speed dial has no submenus, headers,
+ * checkable items, or type-ahead.
  *
- * **Nothing is reserved from the keyboard.** A menu that drills has to keep the
- * horizontal pair for going in and coming back; a dial goes nowhere, so all four
- * arrows move through the actions and a reader who guesses either axis is
- * answered. That is the controller's own house position, and this is a component
- * with no reason to argue with it.
+ * You slot the trigger. The usual floating action button is `IconButton` with
+ * `shape="circle"` and `raised`. There is no `helix-fab`, because `IconButton`
+ * already has `emphasis`, `tone`, `label`, and a size. Position the button with
+ * `data-dock` in the base layer.
+ *
+ * All four arrow keys move through the actions, because a speed dial has no
+ * nested levels to reserve the horizontal pair for. This is the default
+ * behavior of the keyboard controller.
  *
  * @since 0.1.0
  * @status stable
@@ -33,21 +30,21 @@ declare const HelixHeadlessSpeedDial_base: (new (...args: any[]) => import("@fus
  * @documentation https://fusion.dev/helix/components/speed-dial
  *
  * @slot - The actions.
- * @slot trigger - The control that opens it. Falls back to a button named by `label`.
+ * @slot trigger - The control that opens the actions. Without one, a button named by `label` is drawn.
  *
- * @event {HelixBeforeCloseEvent} helix-before-close - Fired before it closes, and cancelable.
- * @event {HelixBeforeOpenEvent} helix-before-open - Fired before it opens, and cancelable.
- * @event {HelixSelectEvent} helix-select - Fired when an action is chosen. Dispatched by the action and listened for here, and the dial closes behind it once it has been heard. Cancelable: refusing it takes the decision and the dial stays open.
- * @event {Event} toggle - Says the state moved, carrying `newState` and `oldState`.
+ * @event {HelixBeforeCloseEvent} helix-before-close - The actions are about to close. Cancelable: cancel it to keep them open.
+ * @event {HelixBeforeOpenEvent} helix-before-open - The actions are about to open. Cancelable: cancel it to keep them closed.
+ * @event {HelixSelectEvent} helix-select - An action was chosen. The action sends the event, and the dial closes after it. Cancelable: cancel it to keep the dial open.
+ * @event {Event} toggle - The dial opened or closed. The event carries `newState` and `oldState`.
  *
  * @csspart actions - The region the actions are drawn in.
- * @csspart trigger - The default trigger, where none was slotted.
+ * @csspart trigger - The default trigger, drawn when none is slotted.
  *
  * @cssstate open - While the actions are out.
  */
 export declare class HelixHeadlessSpeedDial extends HelixHeadlessSpeedDial_base {
     /**
-     * Names the trigger and the set of actions it opens.
+     * Accessible name for the trigger and the set of actions it opens.
      */
     label: string;
     /**
@@ -55,7 +52,8 @@ export declare class HelixHeadlessSpeedDial extends HelixHeadlessSpeedDial_base
      */
     offset: number;
     /**
-     * Which way the actions fan out. They move if that side does not fit.
+     * The direction the actions open in. They move to another side if that side
+     * does not fit.
      *
      * Up by default, because the control this hangs off is usually docked to the
      * bottom of the window and there is nothing below it to fan into.

package/dist/splitter/root/splitter-root.d.ts

@@ -1,38 +1,32 @@
 import { HelixElement } from '@fusion.dev/helix-core';
 import { type PropertyValues, type TemplateResult } from 'lit';
 /**
- * @summary Two panes and a divider the reader can move.
+ * @summary Two panes and a divider that you can move.
  *
  * @description
- * **One axis, and nesting is how you get two.** A splitter inside a splitter
- * gives back the cross, and gives the three-pane and four-pane arrangements a
- * single divider never had.
+ * A splitter has one axis. Nest splitters to get two axes and three-pane or
+ * four-pane layouts.
  *
- * **Where two of them cross there is a corner, and it moves both.** A splitter
- * slotted into a pane of another, at right angles to it, grows a handle at the
- * crossing: `move` under the pointer, both arrow axes on the keyboard, and a
- * drag that carries the two positions at once. It appears at `firstUpdated`
- * rather than in the served markup, being an affordance rather than content,
- * and a splitter with no corner yet is a splitter with two working dividers.
+ * When a splitter is slotted into a pane of another at a right angle, a corner
+ * handle appears where the dividers cross. It shows the `move` cursor, responds
+ * to both arrow axes, and a drag moves both dividers at once. The corner is
+ * added at `firstUpdated` and is not in the server markup. Before it appears,
+ * both dividers work on their own.
  *
- * **The divider is a real `role="separator"` with `aria-valuenow`**, moved by
- * the arrow keys as well as by pointer, with `Home` and `End` taking it to its
- * bounds. A drag in progress is a state rather than `:hover`, so both dividers
- * a corner moves are lit for as long as it moves them.
+ * The divider has `role="separator"` and `aria-valuenow`. Drag it with a
+ * pointer or move it with the arrow keys, and press `Home` or `End` to move it
+ * to its bounds. A drag in progress is tracked as a state, so both dividers a
+ * corner moves stay lit for as long as they move.
  *
- * **It goes where it is put, all the way to either end.** `min` and `max` are
- * nothing and everything unless a consumer says otherwise, because a divider
- * that stops short of the edge gives a reader no way to put a pane away.
+ * By default, `min` and `max` let the divider reach either edge, so you can
+ * drag a pane fully closed. Set them to limit the range.
  *
- * **A pane can be shut, and that is not the same as a divider at the edge.**
- * The geometry is identical and the knowledge is not: only a shut pane knows
- * where to open back to. So `collapsed` is a second state rather than a reading
- * of the position, and the position it opens to is where the gesture that shut
- * it began, whichever gesture that was: a drag takes its reading on the press,
- * and every other door takes it in `settle`, nothing having been applied there
- * yet. `collapsed-size` keeps a sliver showing where a pane has a tab strip
- * worth leaving, and collapse overrides `min` and `max`, which is what those
- * are for.
+ * A pane can be collapsed, which is a separate state from a divider at the
+ * edge. `collapsed` names the shut pane, `start` or `end`, and the pane opens
+ * back to the position where the collapsing gesture began. A drag records that position
+ * on press, and every other way of collapsing records it in `settle`.
+ * `collapsed-size` keeps a sliver of the pane visible, such as a tab strip.
+ * Collapsing overrides `min` and `max`.
  *
  * @since 0.1.0
  * @status stable
@@ -40,16 +34,16 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * @aliases SplitPane, Resizable, SplitView
  * @documentation https://fusion.dev/helix/components/splitter
  *
- * @slot end - The pane after it.
+ * @slot end - The pane after the divider.
  * @slot start - The pane before the divider.
  *
- * @event {HelixBeforeCollapseEvent} helix-before-collapse - Fired before a pane shuts or reopens, whether or not the resize that reached it was allowed, and carrying its own position: a shut pane sits at `collapsed-size` rather than at the number the resize named. Cancelable: refusing it leaves the pane as it was and the divider where the gesture put it.
- * @event {HelixBeforeResizeEvent} helix-before-resize - Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the position and leaves the rest of the gesture, so a collapse the gesture reached is still announced and still yours to refuse. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own.
+ * @event {HelixBeforeCollapseEvent} helix-before-collapse - Fired before a pane shuts or reopens, whether or not the resize that caused it was allowed. It carries its own position, because a shut pane sits at `collapsed-size`. Cancelable: canceling it leaves the pane as it was and the divider where the gesture put it.
+ * @event {HelixBeforeResizeEvent} helix-before-resize - Fired before the divider settles, and only when the gesture moved it. A press that moved nothing, a drag that came back, an arrow key with no room left, and a corner that moved only the other divider do not fire it. Cancelable: canceling it leaves the position to you and keeps the rest of the gesture, so a collapse the gesture reached still fires `helix-before-collapse`, which you can also cancel. A dragged divider stays where it was dropped until you set your own `position`.
  *
  * @csspart corner - The handle where two dividers cross, added on the client.
- * @csspart end - The box holding the second.
+ * @csspart end - The box that holds the second pane.
  * @csspart separator - The divider itself.
- * @csspart start - The box holding the first pane.
+ * @csspart start - The box that holds the first pane.
  *
  * @cssproperty --splitter-corner-at - Where a nested splitter crosses this one, as a percentage.
  * @cssproperty --splitter-position - Where the divider sits, as a percentage of the box.
@@ -71,7 +65,7 @@ export declare class HelixHeadlessSplitter extends HelixElement {
     get collapsed(): 'end' | 'start' | undefined;
     set collapsed(next: 'end' | 'start' | undefined);
     /**
-     * What the divider says while a pane is shut, in place of a number.
+     * The divider's value while a pane is shut, as text in place of a number.
      *
      * **A shut pane is off the scale the divider reports**, which is `min` to
      * `max`, the sliver a drag keeps. The divider said a value outside its own
@@ -89,27 +83,27 @@ export declare class HelixHeadlessSplitter extends HelixElement {
      */
     collapsedSize: number;
     /**
-     * Accessible name for the handle where two dividers cross.
+     * The name of the handle where two dividers cross, read by screen readers.
      */
     cornerLabel: string;
     /**
-     * Which pane starts shut, where nothing declared it.
+     * Which pane starts shut, when `collapsed` is not set.
      */
     defaultCollapsed?: 'end' | 'start';
     /**
-     * Where the divider starts, where nothing declared it.
+     * Where the divider starts, when `position` is not set.
      */
     defaultPosition: number;
     /**
-     * Accessible name for the divider.
+     * The divider's name, read by screen readers.
      */
     label: string;
     /**
-     * Nearest it may come to the end, on the same terms as `min`.
+     * How close the divider can come to the end, in the same units as `min`.
      */
     max: number | string;
     /**
-     * Nearest the divider may come to the start.
+     * How close the divider can come to the start.
      *
      * A bare number is a percentage, which is what this always took. A CSS length
      * is resolved against the splitter's own box along its axis, so `min="15rem"`
@@ -178,7 +172,7 @@ export declare class HelixHeadlessSplitter extends HelixElement {
     get position(): number;
     set position(next: number);
     /**
-     * How far one arrow press moves it, as a percentage.
+     * How far one arrow key press moves the divider, as a percentage.
      */
     step: number;
     /** The position, whoever set it, and `undefined` until somebody has. */
@@ -270,7 +264,8 @@ export declare class HelixHeadlessSplitter extends HelixElement {
      */
     private origin;
     /**
-     * Moves the divider, and optionally says so.
+     * Moves the divider. With `settled` set, it also fires the events for a
+     * finished move.
      *
      * Public because a corner on a nested splitter has to drive the one it is
      * nested in, and that is the whole of what it needs: the pair are not
@@ -322,7 +317,8 @@ export declare class HelixHeadlessSplitter extends HelixElement {
      */
     private watchWidth;
     /**
-     * Public because a nested splitter compares axes with the one it is in.
+     * Whether the panes are stacked. Public because a nested splitter compares
+     * its axis with the one it is in.
      *
      * The one place the axis is decided, which is why `auto` costs a single line
      * here rather than a pass over seventeen readers: the drag, the arrow keys and

package/dist/stat/group/stat-group.d.ts

@@ -4,9 +4,9 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * @summary A row of related measurements.
  *
  * @description
- * A group rather than a list, because the figures are read together and their
- * order carries no meaning: a list would announce "1 of 4" for a set where the
- * position is not information.
+ * Screen readers announce the stats as a group. The figures are read together
+ * and their order has no meaning, so the group does not announce positions such
+ * as "1 of 4".
  *
  * @since 0.1.0
  * @status stable
@@ -17,7 +17,7 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  */
 export declare class HelixHeadlessStatGroup extends HelixElement {
     /**
-     * Accessible name for the set.
+     * Accessible name for the group.
      */
     label: string;
     protected willUpdate(changed: PropertyValues): void;