@fusion.dev/helix 0.104.1 → 0.106.0

package/dist/object-inspector/root/object-inspector-root.d.ts

@@ -2,15 +2,14 @@ import { HelixHeadlessObjectInspector } from '@fusion.dev/helix-headless/object-
 import type { CSSResultGroup } from 'lit';
 import '../../copy-button/index.js';
 /**
- * @summary A value read as a tree: collapse what you do not need, count what
- * you collapsed, copy the part you do.
+ * @summary A structured value shown as a tree, where you can close branches,
+ * see how many entries each holds, and copy any part.
  *
  * @description
- * Code Block's frame around a tree of entries. Each type takes its ink from the
- * syntax set the code blocks already use, a key in one, a string in another and
- * a number, a boolean and a null in theirs, and each row is one line with a long
- * string ending in an ellipsis, so every row is one height and a windowed tree
- * never has to measure them one by one.
+ * The styled tier draws the tree in the Code Block frame. Keys and each type of
+ * value take their colors from the syntax colors code blocks use. Each row is
+ * one line, and a long string ends in an ellipsis, so every row has the same
+ * height and a windowed tree does not measure rows one by one.
  *
  * @since 0.1.0
  * @status stable
@@ -18,11 +17,11 @@ import '../../copy-button/index.js';
  * @aliases JSON viewer, Object viewer, Inspector, Data explorer
  * @documentation https://fusion.dev/helix/components/object-inspector
  *
- * @cssproperty --object-inspector-background-color - Ground under the tree.
- * @cssproperty --object-inspector-block-size - Height of the scrolling box, when windowed.
- * @cssproperty --object-inspector-border-color - The edge around the tree and its header.
- * @cssproperty --object-inspector-header-background-color - The bar carrying the label.
- * @cssproperty --object-inspector-radius - Corner radius of the tree.
+ * @cssproperty --object-inspector-background-color - The background of the tree.
+ * @cssproperty --object-inspector-block-size - The height of the scrolling box when `windowed` is set.
+ * @cssproperty --object-inspector-border-color - The color of the edge around the tree and its header.
+ * @cssproperty --object-inspector-header-background-color - The background of the bar that holds the label.
+ * @cssproperty --object-inspector-radius - The corner radius of the tree.
  */
 export declare class HelixObjectInspector extends HelixHeadlessObjectInspector {
     static tier: string;

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

@@ -1,12 +1,11 @@
 import { HelixHeadlessOptionGroup } from '@fusion.dev/helix-headless/option';
 import type { CSSResultGroup } from 'lit';
 /**
- * @summary A named run of options inside a listbox.
+ * @summary A labeled group of options inside a listbox.
  *
  * @description
- * The heading is set small and quiet, because it is a divider that happens to
- * have words on it: a run of options is read as a list and the heading is what
- * tells you which list, not something to read on its own.
+ * The heading is small and muted. It labels the run of options below it and is
+ * not meant to be read as content of its own.
  *
  * @since 0.1.0
  * @status stable

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

@@ -4,10 +4,9 @@ import type { CSSResultGroup } from 'lit';
  * @summary One choice in a listbox.
  *
  * @description
- * Two states that look different on purpose: chosen, which is a fact about the
- * value, and active, which is where the keyboard is. A list that draws them the
- * same way leaves a reader arrowing through it unable to tell what they have
- * picked from what they are looking at.
+ * Selected and active look different. Selected is the value, and active is
+ * where the keyboard is. If both looked the same, you could not tell what you
+ * picked from where you are while moving through the list with the arrow keys.
  *
  * @since 0.1.0
  * @status stable
@@ -15,10 +14,10 @@ import type { CSSResultGroup } from 'lit';
  * @aliases Item, Choice
  * @documentation https://fusion.dev/helix/components/option
  *
- * @cssproperty --option-active-color - Wash behind the option the keyboard is on.
- * @cssproperty --option-block-padding - Space above and below it. `Command` raises this, a palette being a page of rows read at speed rather than a select's short list.
- * @cssproperty --option-padding - Space before the label, shared with a group heading.
- * @cssproperty --option-radius - Corner radius of the row. A listbox and a select flatten it.
+ * @cssproperty --option-active-color - The background of the option the keyboard is on.
+ * @cssproperty --option-block-padding - The space above and below the option. `Command` increases it for its longer list of rows.
+ * @cssproperty --option-padding - The space before the label, shared with a group heading.
+ * @cssproperty --option-radius - The corner radius of the row. A listbox and a select remove it.
  */
 export declare class HelixOption extends HelixHeadlessOption {
     static styles: CSSResultGroup;

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

@@ -2,44 +2,37 @@ import { HelixElement } from '@fusion.dev/helix-core';
 import type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';
 import { type OrbState } from '../shapes.js';
 /**
- * @summary Says what an agent is doing, as a shape rather than a word.
+ * @summary An animated shape that shows what an agent is doing.
  *
  * @description
- * A cloud of dots, drawn to a canvas, with one shape per state. `connecting`
- * and `thinking` are the same leaning sash and differ in how agitated it is;
- * `waiting` and `done` are the same settled ball at different tempos, which is
- * the difference between not having started and having finished. `fetching` is
- * a globe with a light going round it, `listening` a closed sphere with a
- * ripple crossing it, and `working` a ring.
+ * A cloud of dots drawn to a canvas, with one shape per state:
  *
- * **None of them is a separate drawing.** Each is the same banded grid given
- * different numbers, so changing state interpolates the numbers and every frame
- * in between is a whole shape. A loader that cuts between pictures says the
- * work restarted; one that carries a shape into the next says it moved on.
+ * - `connecting` and `thinking`: the same leaning sash, differing in how
+ *   agitated it is.
+ * - `waiting` and `done`: the same settled ball at different tempos.
+ * - `fetching`: a globe with a light moving around it.
+ * - `listening`: a closed sphere with a ripple crossing it.
+ * - `working`: a ring.
  *
- * **A change is measured before it is played.** Two states differing in one
- * small number are given less time than a sash becoming a ring, and the
- * silhouette leads what the shape is doing, so a light is never seen orbiting
- * something that has not finished becoming round.
+ * Every state is the same banded grid with different parameters. Changing state
+ * interpolates the parameters, so every frame in between is a complete shape. A
+ * small change gets less time than a large one, such as a sash becoming a ring.
+ * The outline changes first, so the light starts orbiting only after the shape
+ * is round.
  *
- * **Nothing spins.** The whole cloud holds still and everything that moves is
- * moving inside it, which is what makes it read as thought rather than as a
- * thing being rotated. The one exception is the light, which travels because a
- * ring of evenly spaced dots is unchanged by rotation: without something fixed
- * in space passing over them, a state that turns has nothing a reader can see
- * turning.
+ * The cloud does not rotate, and all movement happens inside it. The exception
+ * is the light, which travels because a ring of evenly spaced dots looks the
+ * same when rotated, so a turning state needs something fixed passing over it.
  *
- * **The palette is read from the tokens**, not given as colors: a dot's ink is
- * mixed toward the ground by how far away it is, and both ends come from
- * `--orb-color` and `--orb-ground`. That is what makes depth survive a theme
- * change without the consumer restating anything.
+ * Colors come from `--orb-color` and `--orb-ground`. Each dot's color is mixed
+ * toward the ground color by its depth, so depth holds when the theme changes.
  *
- * **It stops when nobody is looking**, off screen and in a background tab, and
- * `prefers-reduced-motion` gets one still frame rather than an empty box.
+ * The animation stops when the orb is off screen or in a background tab. With
+ * `prefers-reduced-motion`, it draws one still frame.
  *
- * Styled only, and with behavior, which the tier split does not otherwise
- * allow: the behavior is drawing dots to a canvas, so there is no structure a
- * consumer could restyle and nothing for a headless twin to hold.
+ * The orb is styled only and has behavior, which the tier split does not
+ * otherwise allow. The behavior is drawing dots to a canvas, so there is no
+ * structure to restyle and nothing for a headless element to hold.
  *
  * @since 0.8.0
  * @status stable
@@ -47,16 +40,17 @@ import { type OrbState } from '../shapes.js';
  * @aliases Thinking, Activity, Agent, Status
  * @documentation https://fusion.dev/helix/components/orb
  *
- * @csspart canvas - The surface the cloud is drawn into.
+ * @csspart canvas - The canvas the dots are drawn on.
  *
- * @cssproperty --orb-color - Ink of the nearest dots. Defaults to `currentColor`.
- * @cssproperty --orb-ground - What the far dots are mixed toward. Defaults to the page's background.
- * @cssproperty --orb-size - Diameter. Overrides `size`.
+ * @cssproperty --orb-color - The color of the nearest dots. Defaults to `currentColor`.
+ * @cssproperty --orb-ground - The color the farthest dots fade toward. Defaults to the page's background.
+ * @cssproperty --orb-size - The diameter. Overrides `size`.
  */
 export declare class HelixOrb extends HelixElement {
     static styles: CSSResultGroup;
     /**
-     * Accessible name, where the state's own word is not the right one.
+     * The name read by screen readers. Defaults to the name of the state, such
+     * as "Thinking".
      *
      * Empty is the state's word, which is what most callers want and none of them
      * should have to write. A caller with something better to say says it here:
@@ -64,7 +58,7 @@ export declare class HelixOrb extends HelixElement {
      */
     label: string;
     /**
-     * Diameter relative to the surrounding text.
+     * The diameter, relative to the surrounding text.
      *
      * **`Loader`'s three steps, because the two are swapped for each other.** An
      * orb and a spinner are the same job drawn differently, a wait a reader is

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

@@ -1,18 +1,16 @@
 import { HelixHeadlessOutline } from '@fusion.dev/helix-headless/outline';
 import type { CSSResultGroup } from 'lit';
 /**
- * @summary Links to the headings on this page, marking the one being read.
+ * @summary Links to the headings on the page, with the section in view marked.
  *
  * @description
- * A rule down the leading edge with the current section lit along it, which is
- * the shape a table of contents has taken since printed marginalia: the line
- * says the list is one thing, and the lit segment says where in it you are.
+ * A rule runs down the leading edge, and the current section is highlighted
+ * along it.
  *
- * Nesting is the consumer's, expressed as `data-level` on a link, and the
- * levels are the heading levels: `2` through `6` each take one more step of
- * `--outline-indent`, and a link with no `data-level` is the top one. An
- * outline that read heading levels itself would have to look at the document,
- * and the document is not always where the headings are.
+ * Set nesting with `data-level` on each link, using the heading levels: `2`
+ * through `6` each add one step of `--outline-indent`, and a link without
+ * `data-level` is at the top level. The outline does not read heading levels
+ * from the document, because the headings are not always in the document.
  *
  * @since 0.1.0
  * @status stable
@@ -21,7 +19,7 @@ import type { CSSResultGroup } from 'lit';
  * @documentation https://fusion.dev/helix/components/outline
  *
  * @cssproperty --outline-indent - How far each level is inset from the one above.
- * @cssproperty --outline-rail - Width of the gutter the rule and the traveling mark share.
+ * @cssproperty --outline-rail - The width of the gutter that holds the line and the moving mark.
  */
 export declare class HelixOutline extends HelixHeadlessOutline {
     static styles: CSSResultGroup;

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

@@ -1,32 +1,22 @@
 import { HelixHeadlessPagination } from '@fusion.dev/helix-headless/pagination';
 import type { CSSResultGroup } from 'lit';
 /**
- * @summary Moves between pages of a longer result.
+ * @summary Controls for moving between the pages of a long set of results.
  *
  * @description
- * One box for every control in the row, arrows and numbers alike, so the run has
- * a single rhythm and the steps sit at the numbers' height rather than between
- * them. Square, because a page number is one or two characters and a box sized
- * to the widest would leave the short ones swimming; `min-inline-size` rather
- * than a fixed one, so page 100 grows instead of overflowing.
+ * Every control in the row, arrows and numbers alike, uses the same box, so the
+ * row has one rhythm. Boxes are square with a `min-inline-size`, so page 100
+ * grows wider and does not overflow.
  *
- * Figures are tabular throughout. A page number is the one thing here that
- * changes under the pointer, and proportional digits make the whole row shuffle
- * as it does.
+ * Figures are tabular, so the row does not shift as the page number changes.
  *
- * The current page is a raised chip rather than a brand fill, which is the
- * treatment `Tabs` gives its selected tab. Brand on a page number claims more
- * than the state deserves: it is not a choice the reader made about anything,
- * it is where they happen to be standing, and a row of gray numbers with one
- * blue one reads as the blue one being an action.
+ * The current page is a raised chip, the same treatment `Tabs` gives its
+ * selected tab. A brand fill would make the current page look like an action.
+ * It is styled from `aria-current`, so there is no second attribute to keep in
+ * sync.
  *
- * Selected on `aria-current` rather than on a second attribute saying the same
- * thing: the state is already in the accessibility tree, and a `data-current`
- * beside it would be two places to keep in step.
- *
- * The gap takes the same box as everything else in the row and only sits back a
- * shade in color. It is a control, so it answers hover and focus like one; it
- * is a way through rather than a destination, so it does not compete.
+ * A gap uses the same box in a slightly muted color. It responds to hover and
+ * focus like any control, and it does not stand out from the numbers.
  *
  * @since 0.1.0
  * @status stable
@@ -35,7 +25,7 @@ import type { CSSResultGroup } from 'lit';
  * @documentation https://fusion.dev/helix/components/pagination
  *
  * @csspart first - The control that jumps to the first page, under `ends`.
- * @csspart gap - The control standing over pages not shown, which jumps into them.
+ * @csspart gap - The control in place of hidden pages, which jumps into them.
  * @csspart item - One slot in the run, holding a page or a gap.
  * @csspart last - The control that jumps to the last page, under `ends`.
  * @csspart list - The run of pages.
@@ -43,7 +33,7 @@ import type { CSSResultGroup } from 'lit';
  * @csspart page - The control for one page.
  * @csspart page-current - The page you are on, beside `page`.
  * @csspart previous - The control that moves back one page.
- * @csspart status - The reading of where you are, in `compact`.
+ * @csspart status - The text that says which page you are on, in `compact`.
  *
  * @cssproperty --pagination-current-color - Fill behind the page you are on.
  * @cssproperty --pagination-gap - Space between one control and the next.

package/dist/pagination/size/pagination-size.d.ts

@@ -3,16 +3,16 @@ import type { CSSResultGroup } from 'lit';
 import '../../option/index.js';
 import '../../select/index.js';
 /**
- * @summary Chooses how many items a page holds.
+ * @summary A control for choosing how many items each page shows.
  *
  * @description
- * A `Select`, laid out on one row. Every other field stacks its label because it
- * stands in a column of fields; this one stands in a footer beside a run of page
- * numbers, where a two-line control makes the whole row two lines tall.
+ * A `Select` laid out on one row. Other fields stack their label because they
+ * sit in a column of fields. This one sits in a footer beside the page numbers,
+ * where a two-line control would make the whole row two lines tall.
  *
- * `Select`'s own parts are exported under `control-`, so `::part(control-trigger)` and
- * `::part(control-label)` reach through both boundaries and a consumer styles it
- * as the select it is.
+ * `Select`'s parts are exported with a `control-` prefix, so
+ * `::part(control-trigger)` and `::part(control-label)` reach through both
+ * shadow boundaries, and you can style it like any select.
  *
  * @since 0.1.0
  * @status stable

package/dist/pagination/summary/pagination-summary.d.ts

@@ -1,12 +1,11 @@
 import { HelixHeadlessPaginationSummary } from '@fusion.dev/helix-headless/pagination';
 import type { CSSResultGroup } from 'lit';
 /**
- * @summary Reads out which items of how many are on show.
+ * @summary Text that shows which items are on the current page, out of the total.
  *
  * @description
- * Prose beside the controls rather than one of them: no box and no hover, in the
- * subtler of the two muted steps, because it is a fact about the result and not
- * a way to move through it.
+ * Plain text beside the controls, with no box and no hover, in the lighter of
+ * the two muted colors. It reports the result and is not a control.
  *
  * @since 0.1.0
  * @status stable

package/dist/pin-input/root/pin-input-root.d.ts

@@ -1,20 +1,17 @@
 import { HelixHeadlessPinInput } from '@fusion.dev/helix-headless/pin-input';
 import type { CSSResultGroup } from 'lit';
 /**
- * @summary A short code, one character to a box.
+ * @summary A field for a short code, with one box for each character.
  *
  * @description
- * Square boxes at the control height with real space between them, which is the
- * whole picture: a code is read as separate characters, and boxes shoulder to
- * shoulder read as one field with lines drawn in it.
+ * Square boxes at the control height, with space between them so the code reads
+ * as separate characters.
  *
- * The focus ring is on the box the reader is in rather than around the row. A
- * code is entered one character at a time and the boxes exist to say which one
- * is next, so a ring around all six would answer the question the component is
- * for.
+ * The focus ring is on the current box, so you can see which character comes
+ * next.
  *
- * Figures are tabular, so a 1 takes the room an 8 does and the row does not
- * breathe as a code is typed into it.
+ * Figures are tabular, so every digit takes the same width and the row does not
+ * shift as you type.
  *
  * @since 0.1.0
  * @status stable
@@ -25,7 +22,7 @@ import type { CSSResultGroup } from 'lit';
  * @csspart cell - One box.
  * @csspart field - The row of boxes.
  *
- * @cssproperty --pin-input-gap - Space between one box and the next.
+ * @cssproperty --pin-input-gap - The space between one box and the next.
  */
 export declare class HelixPinInput extends HelixHeadlessPinInput {
     static styles: CSSResultGroup;

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

@@ -1,18 +1,16 @@
 import { HelixHeadlessPopover } from '@fusion.dev/helix-headless/popover';
 import type { CSSResultGroup } from 'lit';
 /**
- * @summary A panel that opens against a trigger and holds anything.
+ * @summary A panel that opens next to its trigger and holds any content.
  *
  * @description
- * A surface with an inset and a shadow, and nothing about what goes in it. The
- * inset is the panel's rather than the consumer's, which is the same call
- * `Dialog` and `Drawer` make and for the same reason: everyone was writing it,
- * and everyone was writing the same one.
+ * The styled tier draws a surface with an inset and a shadow and styles nothing
+ * inside it. The panel sets its own inset, as `Dialog` and `Drawer` do, because
+ * every use needed the same one.
  *
- * It arrives from the side it opened on. `data-placement` is written by the
- * positioning, so the panel knows which way it flipped and can animate from the
- * trigger rather than from a fixed direction that would be backwards half the
- * time.
+ * The panel animates in from the side it opened on. The positioning writes
+ * `data-placement`, so the panel animates from the trigger's side, including
+ * after it flips.
  *
  * @since 0.1.0
  * @status stable
@@ -21,18 +19,18 @@ import type { CSSResultGroup } from 'lit';
  * @documentation https://fusion.dev/helix/components/popover
  *
  * @cssproperty --popover-border-color - Color of the panel's edge.
- * @cssproperty --popover-border-width - Width of the panel's edge. Follows
- *   `--helix-border-floating`, which is `0`, so the panel is told apart by its lift unless a
- *   theme says otherwise.
+ * @cssproperty --popover-border-width - Width of the panel's edge. Defaults to
+ *   `--helix-border-floating`, which is `0`, so the panel stands out by its shadow unless
+ *   your theme sets a width.
  * @cssproperty --popover-inline-size - Width of the panel.
- * @cssproperty --popover-max-block-size - Tallest the panel grows before it scrolls.
+ * @cssproperty --popover-max-block-size - Maximum height of the panel before it scrolls.
  * @cssproperty --popover-padding - Space between the panel's edge and its contents.
- * @cssproperty --popover-shadow - Lift under the panel. Follows `--helix-shadow-floating`: a
- *   floating surface sits over content nobody can predict, so it keeps a lift by default.
+ * @cssproperty --popover-shadow - Shadow under the panel. Defaults to
+ *   `--helix-shadow-floating`, because the panel can sit over any content.
  */
 export declare class HelixPopover extends HelixHeadlessPopover {
     /**
-     * How the panel separates itself from what it floats over.
+     * How the panel is set apart from the content under it.
      *
      * One of the axis's four values, which is all this surface has meaning for: a
      * floating panel keeps its lift by default, `ThemeIntent.separation.floating`

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

@@ -1,18 +1,15 @@
 import { HelixHeadlessProgress } from '@fusion.dev/helix-headless/progress';
 import type { CSSResultGroup } from 'lit';
 /**
- * @summary Shows how far along a task is, when that is known.
+ * @summary A bar or ring that shows how far along a task is.
  *
  * @description
- * A track and the part of it that is done. The height comes from a token rather
- * than from a size property, for the reason the rest of the library gives about
- * controls: how heavy a bar is says something about the region it is in, and a
- * `--progress-size` on that region says it once.
+ * A track and the part of it that is done. The height comes from a token, like
+ * control sizes elsewhere in the library, so you can set `--progress-size` once
+ * on a region.
  *
- * The fill transitions, which is worth more here than it looks. Progress
- * arrives in steps, often large ones, and a bar that jumps between them reads
- * as a series of unrelated states where one that travels reads as a single
- * thing advancing.
+ * The fill transitions between values. Progress often arrives in large steps,
+ * and a fill that moves between them shows one task advancing.
  *
  * @since 0.1.0
  * @status stable
@@ -22,14 +19,14 @@ import type { CSSResultGroup } from 'lit';
  * @documentation https://fusion.dev/helix/components/progress
  *
  * @cssproperty --progress-color - Fill of the part that is done.
- * @cssproperty --progress-ring-size - Diameter of the ring appearance.
- * @cssproperty --progress-ring-width - Thickness of its stroke.
+ * @cssproperty --progress-ring-size - Diameter of the ring.
+ * @cssproperty --progress-ring-width - Thickness of the ring's stroke.
  * @cssproperty --progress-size - Thickness of the bar.
- * @cssproperty --progress-track-color - Fill of the part that is not.
+ * @cssproperty --progress-track-color - Fill of the part that is not done.
  */
 export declare class HelixProgress extends HelixHeadlessProgress {
     /**
-     * How much ink the bar claims.
+     * How strongly the bar is drawn.
      *
      * `subtle` is the bar as a wash of its own color: still legible, no longer
      * the loudest thing in the region. The case is a background task, which has to

package/dist/qr-code/root/qr-code-root.d.ts

@@ -1,30 +1,29 @@
 import { HelixHeadlessQrCode } from '@fusion.dev/helix-headless/qr-code';
 import type { CSSResultGroup } from 'lit';
 /**
- * @summary Encodes a short piece of text as a scannable square.
+ * @summary A scannable QR code for a short piece of text.
  *
  * @description
- * The picture is the headless tier's. What this adds is a size that can be set
+ * The headless tier draws the code. The styled tier adds a size you can set
  * once, the colors a scanner needs, and the box that holds a center mark.
  *
- * **The ink is `currentColor` and the ground is a real fill.** A code has to be
- * dark on light to read, and the pair that guarantees it is not the page's
- * foreground and background: those invert together in dark mode, and a code
- * drawn light-on-dark is refused by a good half of the scanners in the world.
- * So the ground is stated and the ink is the foreground it is chosen for.
+ * The ink is `currentColor` and the background is a solid fill. A code must be
+ * dark on light to scan. The page's foreground and background invert together
+ * in dark mode, and at least half of scanners reject a light-on-dark code, so
+ * the background is set explicitly and the ink is the foreground chosen for it.
  *
  * @since 0.1.0
  * @status stable
  * @category media
  * @documentation https://fusion.dev/helix/components/qr-code
  *
- * @cssproperty --qr-code-background-color - Behind them, including the quiet zone.
- * @cssproperty --qr-code-color - The dark modules. Defaults to the page's ink.
- * @cssproperty --qr-code-finder-color - The three corner squares. Defaults to
- * the same ink as the modules.
- * @cssproperty --qr-code-logo-padding - The quiet zone around that mark.
- * @cssproperty --qr-code-logo-size - How much of the middle a mark may cover.
- * Defaults to `27%`, which `H` correction carries: it can lose thirty percent.
+ * @cssproperty --qr-code-background-color - The fill behind the modules, including the quiet zone.
+ * @cssproperty --qr-code-color - Color of the dark modules. Defaults to the page's text color.
+ * @cssproperty --qr-code-finder-color - Color of the three corner squares. Defaults
+ * to the color of the modules.
+ * @cssproperty --qr-code-logo-padding - The clear space around the center logo.
+ * @cssproperty --qr-code-logo-size - How much of the center a logo can cover.
+ * Defaults to `27%`, which `H` correction allows, because it can lose thirty percent.
  * @cssproperty --qr-code-size - How wide the square is. Defaults to `12rem`.
  */
 export declare class HelixQrCode extends HelixHeadlessQrCode {

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

@@ -4,8 +4,8 @@ import type { CSSResultGroup } from 'lit';
  * @summary A short quotation, set inline with the text around it.
  *
  * @description
- * Takes the surrounding type rather than a size of its own, because a quotation
- * inside a paragraph is that paragraph's text with marks around it.
+ * Inherits the surrounding type, because an inline quotation is part of its
+ * paragraph.
  *
  * @since 0.1.0
  * @status stable

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

@@ -1,20 +1,20 @@
 import { HelixHeadlessRadioGroup } from '@fusion.dev/helix-headless/radio';
 import type { CSSResultGroup } from 'lit';
 /**
- * @summary A set of choices where exactly one is the answer.
+ * @summary A set of radios where exactly one can be chosen.
  *
  * @description
- * The field's three parts, laid out the way every other field lays them out: a
- * question over the set, and one line under it that is help until something is
- * wrong. `orientation` lays out the choices and not the field, so a horizontal
- * group keeps its question above the row rather than beside the first choice.
+ * Lays out the field's three parts the same way as every other field: the
+ * question above the set, and one line below it that shows the hint, or the
+ * message when something is wrong. `orientation` lays out the choices only, so
+ * a horizontal group keeps its question above the row.
  *
  * @since 0.1.0
  * @status stable
  * @aliases RadioButtons, Choice group
  * @documentation https://fusion.dev/helix/components/radio
  *
- * @cssproperty --radio-group-gap - Space between the choices.
+ * @cssproperty --radio-group-gap - The space between the choices.
  */
 export declare class HelixRadioGroup extends HelixHeadlessRadioGroup {
     static styles: CSSResultGroup;