@fusion.dev/helix-headless 0.53.1 → 0.53.2

package/dist/accordion/item/accordion-item.d.ts

@@ -111,25 +111,25 @@ export declare class HelixHeadlessAccordionItem extends HelixHeadlessAccordionIt
      * pixel of it on the screen, so a consumer taking this tier gets sections of
      * text permanently open under a trigger saying `aria-expanded="false"`, and a
      * sighted reader sees content a screen reader is told is not there. Leaving
-     * the collapse to the styled tier's `grid-template-rows: 0fr` puts the state
-     * in a stylesheet, where only one of the two tiers has it.
+     * the collapse to a `grid-template-rows: 0fr` puts the state in a stylesheet,
+     * where only the consumers who load that sheet have it.
      *
-     * **`hidden` costs the styled tier nothing**, which is what makes this the
-     * cheap fix rather than a trade. The UA sheet hides `[hidden]` from the UA
-     * origin, and `accordion-item.css` already sets `display: grid` on this part
-     * unconditionally, so the author rule wins and the 0fr transition runs
-     * exactly as before. Measured on both tiers.
+     * **`hidden` costs a sheet that animates this region nothing**, which is what
+     * makes this the cheap fix rather than a trade. The UA sheet hides `[hidden]`
+     * from the UA origin, so any author rule already setting `display` on this
+     * part outranks it and the transition runs exactly as before. Measured on
+     * both tiers.
      *
      * **Not `hidden="until-found"`**, which would be the better accordion and is
      * a different piece of work. It hides through `content-visibility` rather
-     * than `display`, so the styled tier's `display: grid` would no longer
-     * override it and a collapsed section would animate open to nothing. It also
-     * needs a `beforematch` handler to set `open`, or find-in-page reveals text
-     * while the trigger still reports collapsed.
+     * than `display`, which an author `display` does not override, so a collapsed
+     * section a sheet animates would open to nothing. It also needs a
+     * `beforematch` handler to set `open`, or find-in-page reveals text while the
+     * trigger still reports collapsed.
      *
      * `inert` stays. `hidden` answers the reader who can see and `inert` answers
-     * the one tabbing through, and in the styled tier, where `display` is
-     * overridden, `inert` is the only one of the two still in force.
+     * the one tabbing through, and wherever a sheet overrides `display`, `inert`
+     * is the only one of the two still in force.
      */
     protected render(): TemplateResult;
 }

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

@@ -18,7 +18,7 @@ import { HelixHeadlessAccordionItem } from '../item/accordion-item.js';
  * item added a second after render coordinates on its first click.
  *
  * Items are matched with `instanceof HelixHeadlessAccordionItem`, never by tag
- * name. Matching `helix-accordion-item` would tie this tier to the styled one.
+ * name, so this tier does not learn about the styled one.
  *
  * The keyboard listener is the controller's and is attached on connect, so
  * none of it runs on the server, where there is no tree to walk and no events

package/dist/area-chart/root/area-chart-root.js

@@ -61,7 +61,7 @@ let HelixHeadlessAreaChart = class HelixHeadlessAreaChart extends MixinChartSour
         console.warn(`<${this.localName}> read a negative number and drew it as none. Its bands are parts of a ` +
             'total, and a part cannot be less than nothing: a band drawn below its neighbor would say ' +
             'the part took some of the one beneath it away. A series that crosses zero is a line, so ' +
-            'reach for `helix-line-chart`.');
+            'reach for the line chart in this tier instead.');
     }
     render() {
         const rows = this.sourceRows;

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

@@ -1,13 +1,13 @@
 import { HelixElement } from '@fusion.dev/helix-core';
 import { type PropertyValues, type TemplateResult } from 'lit';
 /**
- * The largest `max` the styled tier can hide past.
+ * The largest `max` a stylesheet can hide past.
  *
  * The fold is `:host([max="N"]) ::slotted(:nth-child(n + N+1))`, one selector
  * per value, because `An+B` takes a literal and no custom property can be read
- * into it. So the range is finite and this is where it is written down, in the
- * tier that has to agree with it: a count that folds and a stylesheet that does
- * not would put a "+5" beside five avatars that are still on screen.
+ * into it. So the range is finite, and it is written down beside the count that
+ * has to agree with it: a count that folds and a stylesheet that does not would
+ * put a "+5" beside five avatars that are still on screen.
  */
 export declare const FOLDS_UP_TO = 12;
 /**
@@ -45,13 +45,13 @@ export declare class HelixHeadlessAvatarGroup extends HelixElement {
      * Unset shows all of them, which is what no limit means and is more useful
      * than refusing to render.
      *
-     * **Reflected, because the fold is a stylesheet rule and nothing else.** The
-     * styled tier hides past the limit with `:host([max="N"]) ::slotted(:nth-child(n + N+1))`,
-     * so the attribute *is* the mechanism: a `max` that reaches this property and
-     * never reaches the host matches no rule, and every avatar is drawn beside a
-     * count claiming some are hidden. Markup is the safe path and hides the fault;
-     * a script is the broken one, and React takes it for everyone, assigning a
-     * matching property rather than an attribute.
+     * **Reflected, because the fold is a stylesheet rule and nothing else.** A
+     * sheet hides past the limit one selector per value, as `FOLDS_UP_TO`
+     * describes, so the attribute *is* the mechanism: a `max` that reaches this
+     * property and never reaches the host matches no rule, and every avatar is
+     * drawn beside a count claiming some are hidden. Markup is the safe path and
+     * hides the fault; a script is the broken one, and React takes it for
+     * everyone, assigning a matching property rather than an attribute.
      *
      * **Optional rather than defaulted, per the rule that a reflected property
      * takes no default**: `max = 0` would stamp `max="0"` onto every host that

package/dist/bar-chart/root/bar-chart-root.d.ts

@@ -66,7 +66,7 @@ declare const HelixHeadlessBarChart_base: typeof HelixElement & (new (...args: a
  * @csspart tooltip-value - A column's value inside the tooltip.
  *
  * @cssproperty --bar-chart-axis - How wide an axis column is drawn, in `ch`, from the widest number on it. Written on the axis itself, and only where the categories run along the bottom: turned sideways an axis is a row and takes a line's height instead.
- * @cssproperty --bar-chart-secondary - The color of the secondary axis when one series owns it. It resolves a `--helix-color-series-*` token, so on the headless tier alone it names something that is not there. #138.
+ * @cssproperty --bar-chart-secondary - The color of the secondary axis, where one series owns it. Written by the component from that series' `--chart-series-*`, so it promises the series color and nothing more: whatever that hook resolves to is what the axis is drawn in.
  * @cssproperty --chart-bar-wash - The gradient a bar would take, named per bar so the
  *   styled tier can point `fill` at it. Drawn whatever the treatment and used only where
  *   `wash="gradient"` asks for it.

package/dist/breadcrumbs/breadcrumb/breadcrumb.d.ts

@@ -55,12 +55,12 @@ export declare class HelixHeadlessBreadcrumb extends HelixElement {
     /**
      * Where the crumb goes, and nothing where it is the current page.
      *
-     * **Optional and reflected, because a stylesheet does select on it.**
-     * `breadcrumb.css` writes `:host(:not([href])) [part="link"]` to take the
-     * block padding off a crumb that is not a link, so the attribute is what
-     * decides how tall a crumb is. Unreflected, an `href` set from script reached
-     * the property, rendered the anchor, and left the host looking unlinked: the
-     * crumb drew at 20px where a markup twin drew at 28.
+     * **Optional and reflected, because a stylesheet does select on it.** A sheet
+     * writes `:host(:not([href])) [part="link"]` to take the block padding off a
+     * crumb that is not a link, so the attribute is what decides how tall a crumb
+     * is. Unreflected, an `href` set from script reached the property, rendered
+     * the anchor, and left the host looking unlinked: the crumb drew at 20px
+     * where a markup twin drew at 28.
      *
      * Optional rather than defaulted, which is the general rule that a reflected
      * property takes no default: an `href` written onto every host would be a link

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

@@ -47,7 +47,7 @@ export declare class HelixHeadlessButton extends HelixFormElement {
      * the same way `label` becomes `aria-label` in there.
      *
      * ```html
-     * <helix-button commandfor="confirm" command="--show">Delete…</helix-button>
+     * <helix-headless-button commandfor="confirm" command="--show">Delete…</helix-headless-button>
      * ```
      *
      * `commandFor` spells its attribute out, because Lit lowercases a property

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

@@ -11,7 +11,7 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  *
  * The host is the surface. A wrapper `<div part="container">` would be a second
  * box doing nothing the host cannot: the element itself takes the border, the
- * radius, and the grid, and a consumer styles `helix-card` rather than reaching
+ * radius, and the grid, and a consumer styles `Card` rather than reaching
  * through `::part`. One node instead of two, on every card on the page.
  *
  * Name the card with `aria-label` or `aria-labelledby`. That is the only

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

@@ -166,13 +166,13 @@ export declare class HelixHeadlessCarousel extends HelixElement {
      * **The number is published to the styles rather than enumerated by them**,
      * as `--carousel-per-view` on the track, which is what keeps a width and a
      * count from disagreeing. A sheet can only name a value it wrote a rule for,
-     * so the styled tier enumerated `per-view="2"` through `5` and called five a
-     * judgment; above it the pane fell back to one across while this file went on
-     * counting positions. Measured in Chromium over eight slides, six across gave
-     * three dots, a pane taking the whole track and five slides reachable only by
-     * dragging. Written from here there is no ceiling to exceed, and a consumer's
-     * own sheet reads the same declaration the styled one does. `runEnd` publishes
-     * its correction the same way and for the same reason.
+     * so a sheet enumerating `per-view="2"` through `5` is a ceiling of five, and
+     * above it the pane falls back to one across while this file goes on counting
+     * positions. Measured in Chromium over eight slides against such a sheet, six
+     * across gave three dots, a pane taking the whole track and five slides
+     * reachable only by dragging. Published from here there is no ceiling to
+     * exceed, and every sheet reads the same declaration. `runEnd` publishes its
+     * correction the same way and for the same reason.
      *
      * **On the track and not on the host.** A custom property on the host is a
      * reflected attribute by another name: it would arrive on upgrade, and a
@@ -197,8 +197,8 @@ export declare class HelixHeadlessCarousel extends HelixElement {
      * `auto` track is handed nothing. A count stays for the design that calls for
      * exactly three.
      *
-     * The styled sheet says how it divides, and the headless `auto` example
-     * carries the same three lines for a consumer writing their own.
+     * A sheet says how it divides, and the `auto` example here carries the same
+     * three lines for a consumer writing their own.
      *
      * **A value rather than the resting behavior**, which is what the
      * responsiveness policy asks of every axis that a box decides: a splitter
@@ -599,11 +599,11 @@ export declare class HelixHeadlessCarousel extends HelixElement {
      * The arithmetic wants how many slides there are, and CSS can only ask
      * `sibling-count()`, which is Chromium-only, evaluates to 0 through
      * `::part()`, and needs a `:last-child` that `::part()` cannot carry either.
-     * So the styled tier could correct its run and a consumer writing their own
-     * several-across sheet could not: measured in Chromium at three across, the
-     * headless tier rested at 451 against -450 while the styled tier rested at
-     * one number both ways. Published from here, one declaration reading this
-     * gets both tiers and any consumer to the same place.
+     * So a sheet shipped beside the component could correct its own run and a
+     * consumer writing their own several-across sheet could not: measured in
+     * Chromium at three across, an uncorrected track rested at 451 against -450
+     * where a corrected one rested on one number both ways. Published from here,
+     * one declaration reading this gets every sheet to the same place.
      *
      * **WebKit takes the margin and does not need it**, which is the reason a
      * correction written in CSS looked like enough. It has no `sibling-count()`

package/dist/chat/composer/chat-composer.d.ts

@@ -133,12 +133,12 @@ export declare class HelixHeadlessChatComposer extends HelixElement {
     /**
      * Records the draft, and stops the textarea speaking in this element's name.
      *
-     * **The stop is not incidental.** `input` is composed by specification, so the
-     * `<textarea>` in this shadow root sent its own past this host and on through
-     * whatever `<helix-chat>` it is slotted into, and neither element declares an
-     * `input`: a consumer binding one on either received an undeclared event whose
-     * target was a control they cannot reach. What a composer offers is
-     * `helix-send`, once, when the reader is done.
+     * **The stop is not incidental.** `input` is composed by specification, so
+     * the `<textarea>` in this shadow root sent its own past this host and on
+     * through whatever `<helix-headless-chat>` it is slotted into, and neither
+     * element declares an `input`: a consumer binding one on either received an
+     * undeclared event whose target was a control they cannot reach. What a
+     * composer offers is `helix-send`, once, when the reader is done.
      */
     private readonly handleInput;
     private readonly handleSend;

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

@@ -15,7 +15,7 @@ export interface ChatTurn {
      * response: history then loads under the reader rather than above them.
      */
     key?: string;
-    /** What has happened to it, as on `helix-chat-message`. */
+    /** What has happened to it, as on `ChatMessage`. */
     state?: 'failed' | 'sending' | 'sent' | 'streaming';
     /** What was said, as text. */
     text: string;
@@ -74,7 +74,7 @@ declare const HelixHeadlessChat_base: (new (...args: any[]) => import("@fusion.d
  * @aliases Conversation, Transcript, Thread, Messages
  * @documentation https://fusion.dev/helix/components/chat
  *
- * @slot - The turns, as `helix-chat-message` children.
+ * @slot - The turns.
  * @slot actions - Beside the header: what can be done to the conversation itself.
  * @slot composer - Below the transcript, where the reader writes.
  * @slot header - Above the transcript: what this conversation is.
@@ -163,13 +163,13 @@ export declare class HelixHeadlessChat extends HelixHeadlessChat_base {
      *
      * **Not reflected, and the default is why.** A reflected property that
      * defaults to true writes its attribute on upgrade whether or not the
-     * consumer wrote one, so the server serves `<helix-chat label="x">` and the
-     * client turns it into `<helix-chat label="x" pinned>`: a hydration mismatch a
-     * React consumer reports and does not patch up. Nothing needs the attribute
-     * either, because the one thing that changes with the pin is the way back, and
-     * that is a part inside the shadow tree where a stylesheet can already reach
-     * it. Measured rather than assumed: `label, pinned` after upgrade against
-     * `label` from the server.
+     * consumer wrote one, so the server serves `<helix-headless-chat label="x">`
+     * and the client turns it into `<helix-headless-chat label="x" pinned>`: a
+     * hydration mismatch a React consumer reports and does not patch up. Nothing
+     * needs the attribute either, because the one thing that changes with the pin
+     * is the way back, and that is a part inside the shadow tree where a
+     * stylesheet can already reach it. Measured rather than assumed: `label,
+     * pinned` after upgrade against `label` from the server.
      */
     get pinned(): boolean;
     set pinned(next: boolean);

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

@@ -78,8 +78,8 @@ export declare class HelixHeadlessCheckbox extends HelixHeadlessCheckbox_base {
      * pixels of nothing after it. The input answers this by not rendering the
      * element, which cannot work here, because a checkbox is named by its own
      * content and the property is only that slot's fallback. Gating on the
-     * property would unlabel every `<helix-checkbox>Text</helix-checkbox>` ever
-     * written.
+     * property would unlabel every
+     * `<helix-headless-checkbox>Text</helix-headless-checkbox>` ever written.
      *
      * So the slot is asked instead, the same way `Tooltip` asks its own: with
      * `flatten`, because here the fallback counts, being where the property

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

@@ -105,11 +105,11 @@ export declare class HelixHeadlessCodeBlock extends HelixElement {
      * round. The platform already writes booleans like this for the same reason,
      * `novalidate` and `nomodule` and `noreferrer` among them.
      *
-     * **Reflected, because the gutter is a stylesheet rule.** `code-block.css`
-     * reserves the copy button's width with `:host(:not([no-copy]))`, so the
-     * attribute is what decides whether the block pays for a control. Unreflected,
-     * setting it from script takes the button away (`render` reads the property)
-     * and leaves the 40px it stood in reserved.
+     * **Reflected, because the gutter is a stylesheet rule.** A sheet reserves
+     * the copy button's width with `:host(:not([no-copy]))`, so the attribute is
+     * what decides whether the block pays for a control. Unreflected, setting it
+     * from script takes the button away (`render` reads the property) and leaves
+     * the 40px it stood in reserved.
      *
      * A false boolean reflects as the attribute's absence, so this costs no
      * `no-copy=""` on hosts that never asked for one, and the rule about a

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

@@ -7,11 +7,11 @@ declare const HelixHeadlessColorInput_base: (new (...args: any[]) => import("@fu
  * @summary A color, typed in any syntax or picked from a panel.
  *
  * @description
- * **The picker is `helix-color-picker`, not a second one written here.** It owns the
+ * **The picker is `ColorPicker`, not a second one written here.** It owns the
  * square, the ramps, the eyedropper and the syntax toggle, and it is worth
  * having on its own: a settings pane wants a picker flat on the page with
  * nothing to open. This element is the field, the overlay, and the form.
- * Exactly the arrangement Date Input has with `helix-date-picker`.
+ * Exactly the arrangement Date Input has with `DatePicker`.
  *
  * **Typed as well as picked, and the typing is the reason this is not
  * `<input type="color">`.** The native control gives a free picker and takes
@@ -190,7 +190,7 @@ export declare class HelixHeadlessColorInput extends HelixHeadlessColorInput_bas
      * The picker is about to take the pointer over, so the panel gets out of the
      * way and comes back after.
      *
-     * `helix-color-picker` says what it is doing rather than reaching for a panel it
+     * `ColorPicker` says what it is doing rather than reaching for a panel it
      * cannot know it is in. A floating panel left up during an eyedropper is one
      * the reader cannot dismiss and may well be trying to sample from underneath.
      */

package/dist/color-picker/root/color-picker-root.d.ts

@@ -160,10 +160,10 @@ export declare class HelixHeadlessColorPicker extends HelixHeadlessColorPicker_b
      *
      * **A color is exactly as requirable as a date**, which is the comparison
      * that settles it: this element extends `HelixFormElement`, carries `name`
-     * and reports its value, so a consumer writing
-     * `<helix-color-picker name="brand" required>` inside a form has every reason
-     * to expect the form to refuse an empty one. Its two siblings in the same
-     * composition position, Date Picker and Time Picker, both check it.
+     * and reports its value, so a consumer writing `<helix-headless-color-picker
+     * name="brand" required>` inside a form has every reason to expect the form
+     * to refuse an empty one. Its two siblings in the same composition position,
+     * Date Picker and Time Picker, both check it.
      *
      * Written out rather than taken from `MixinField`, for the reason those two
      * record: the mixin brings a label, a hint and a feedback region, and this is
@@ -283,11 +283,11 @@ export declare class HelixHeadlessColorPicker extends HelixHeadlessColorPicker_b
      * **The one thing a form-associated element owes, and this element owed it
      * from the start without paying.** It extends `HelixFormElement`, takes
      * `MixinControllerValue` and carries `name`, so a consumer writing
-     * `<helix-color-picker name="brand">` inside a form has every reason to
-     * expect an entry, and the form carried none: no error, nothing in the
+     * `<helix-headless-color-picker name="brand">` inside a form has every reason
+     * to expect an entry, and the form carried none: no error, nothing in the
      * markup to look at, and a field silently missing from the submission. Its
-     * two siblings in the same composition position, Color Input and Slider,
-     * both report.
+     * two siblings in the same composition position, Color Input and Slider, both
+     * report.
      *
      * `null` rather than an empty string where there is no color, which is the
      * difference between a control that submits nothing and one that submits a
@@ -352,12 +352,12 @@ export declare class HelixHeadlessColorPicker extends HelixHeadlessColorPicker_b
      * ends. Listening only for the commit leaves the picker deaf while a handle
      * moves, and the hue and alpha handles do not move at all.
      *
-     * **Read off the target rather than out of a detail.** Do not bind
-     * `helix-input` and `helix-change` and take the proposed value out of the
-     * event: those are requests, announcing what the slider is *about* to do,
-     * before anything has moved and while a listener may still refuse it. The
-     * native pair fires after the slider applied, so the value is on the element
-     * and cannot disagree with it.
+     * **Read off the target rather than out of a detail.** Do not bind `Input`
+     * and `helix-change` and take the proposed value out of the event: those are
+     * requests, announcing what the slider is *about* to do, before anything has
+     * moved and while a listener may still refuse it. The native pair fires after
+     * the slider applied, so the value is on the element and cannot disagree with
+     * it.
      *
      * Idempotent, so taking both costs nothing: the same value applied twice is
      * the same color.

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

@@ -7,10 +7,10 @@ declare const HelixHeadlessCombobox_base: (new (...args: any[]) => import("@fusi
  * @summary A field that filters a list as it is typed into.
  *
  * @description
- * **The list is `helix-listbox`, and the filtering is its own.** It owns
- * narrowing, the empty state, the highlight, `aria-activedescendant` and
- * scrolling an option into view. What is left for this element is the field,
- * the panel and the traffic between them.
+ * **The list is `Listbox`, and the filtering is its own.** It owns narrowing,
+ * the empty state, the highlight, `aria-activedescendant` and scrolling an
+ * option into view. What is left for this element is the field, the panel and
+ * the traffic between them.
  *
  * **The text and the value are two things.** What a reader types is a filter:
  * it narrows the list and is thrown away. The value is whichever option they
@@ -39,7 +39,7 @@ declare const HelixHeadlessCombobox_base: (new (...args: any[]) => import("@fusi
  * @aliases Autocomplete, Typeahead, Search select
  * @documentation https://fusion.dev/helix/components/combobox
  *
- * @slot - The options, which are `helix-option` elements.
+ * @slot - The options.
  * @slot end - After it, for a unit or a clear button.
  * @slot indicator - Replaces the caret saying the field opens.
  * @slot start - Before the text, for an icon.
@@ -307,6 +307,10 @@ export declare class HelixHeadlessCombobox extends HelixHeadlessCombobox_base {
      * It only ever opens. Closing is Escape, a choice, or leaving, which is what
      * the input already did and what a text field wants: a control that closed
      * when you clicked into the middle of your own typing would be unusable.
+     *
+     * The tag is found by identity rather than by tag name. A name matches one
+     * tier's element and leaves the other's press falling through to the open,
+     * and a subclass under a third name is missed by both.
      */
     private readonly handleFieldClick;
     /**

package/dist/combobox/root/combobox-root.js

@@ -11,6 +11,7 @@ import { property, state } from 'lit/decorators.js';
 import { unsafeSVG } from 'lit/directives/unsafe-svg.js';
 import { html } from 'lit/static-html.js';
 import { optionsAmong } from '../../option/root/option-root.js';
+import { HelixHeadlessTag } from '../../tag/root/tag-root.js';
 import '../../listbox/index.js';
 import '../../tag/index.js';
 const isInsertion = (event) => !event.inputType?.startsWith('delete');
@@ -105,9 +106,7 @@ let HelixHeadlessCombobox = class HelixHeadlessCombobox extends MixinControllerO
             if (this.isDisabled) {
                 return;
             }
-            if (event
-                .composedPath()
-                .some((node) => node instanceof HTMLElement && node.localName === 'helix-tag')) {
+            if (event.composedPath().some((node) => node instanceof HelixHeadlessTag)) {
                 return;
             }
             this.partNamed('control')?.focus();

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

@@ -7,12 +7,11 @@ declare const HelixHeadlessCommand_base: (new (...args: any[]) => import("@fusio
  * @summary A list of commands, opened from anywhere and filtered by typing.
  *
  * @description
- * **The list is `helix-listbox`, filtering and all.** Listbox already owns
- * narrowing, the empty state, the highlight over what matched,
- * `aria-activedescendant`, scrolling an option into view and the keyboard that
- * moves between them. Its own note says a command palette is that list again
- * with something different opening it, and this is that something: a dialog,
- * and a key that summons it.
+ * **The list is `Listbox`, filtering and all.** Listbox already owns narrowing,
+ * the empty state, the highlight over what matched, `aria-activedescendant`,
+ * scrolling an option into view and the keyboard that moves between them. Its
+ * own note says a command palette is that list again with something different
+ * opening it, and this is that something: a dialog, and a key that summons it.
  *
  * **The value is not kept.** A palette runs a command and forgets it: nothing
  * here is a form control and nothing is submitted, so what it reports is that
@@ -36,7 +35,7 @@ declare const HelixHeadlessCommand_base: (new (...args: any[]) => import("@fusio
  * @aliases Command palette, Quick open, Spotlight
  * @documentation https://fusion.dev/helix/components/command
  *
- * @slot - The commands, which are `helix-option` elements and their groups.
+ * @slot - The commands, and any groups of them.
  * @slot footer - Under the list, for the keys a reader can press.
  *
  * @event {HelixBeforeCloseEvent} helix-before-close - Fired before it closes. Cancelable: refusing it takes the decision and nothing moves.

package/dist/data-table/root/data-table-root.d.ts

@@ -10,19 +10,19 @@ declare const HelixHeadlessDataTable_base: (new (...args: any[]) => import("@fus
  *
  * @description
  * **The schema is markup and the data is a property.** Columns are declared as
- * `helix-table-column` children, because a schema is small and something a
- * reader should see in the HTML; rows are handed over as an array, because a
- * table that draws ten thousand elements cannot window them.
+ * `TableColumn` children, because a schema is small and something a reader
+ * should see in the HTML; rows are handed over as an array, because a table
+ * that draws ten thousand elements cannot window them.
  *
  * ```html
- * <helix-data-table .rows=${rows} sort="name:asc" page-size="20">
- *   <helix-table-column field="name" sortable>Name</helix-table-column>
- *   <helix-table-column field="size" align="end" sortable .cell=${bytes}>Size</helix-table-column>
- * </helix-data-table>
+ * <helix-headless-data-table .rows=${rows} sort="name:asc" page-size="20">
+ *   <helix-headless-table-column field="name" sortable>Name</helix-headless-table-column>
+ *   <helix-headless-table-column field="size" align="end" sortable .cell=${bytes}>Size</helix-headless-table-column>
+ * </helix-headless-data-table>
  * ```
  *
- * `helix-table` takes rows as markup and is the right component for a table of
- * twelve things a person wrote out.
+ * `Table` takes rows as markup and is the right component for a table of twelve
+ * things a person wrote out.
  *
  * **Sort and filter apply to the whole set, never the page.** Sorting the drawn
  * window is correct on the first screen and wrong on every other one.
@@ -31,7 +31,7 @@ declare const HelixHeadlessDataTable_base: (new (...args: any[]) => import("@fus
  * elements do, but reading a cell needs the columns, and the columns are markup
  * children Lit SSR does not hand this element. So a crawler sees a table of the
  * right shape with nothing in it. That is the cost of the first paragraph: use
- * `helix-table` where the served HTML has to carry the values.
+ * `Table` where the served HTML has to carry the values.
  *
  * **`selectable` adds a column of checkboxes, keyed on `row-key`.** A row is
  * selected by its identity rather than its position, so a selection survives a
@@ -52,14 +52,13 @@ declare const HelixHeadlessDataTable_base: (new (...args: any[]) => import("@fus
  * in the order on screen, in the columns on screen. Saving it is the page's
  * business, the same as any other file.
  *
- * **There is no `columns` attribute here, and `helix-table` has one.** The
- * difference is what a column is in each: here it is the schema, so a table
- * without one has nothing to read a row with, and every column is a place to
- * write a `width`. A `helix-table` holds cells a consumer wrote and can be
- * written with no column at all, so its `columns` is where such a table is
- * sized from. Written on this element the attribute is inert, which is the trap
- * worth knowing when moving between the two. What both take is the CSS hook,
- * `--data-table-columns` here and `--table-columns` there.
+ * **There is no `columns` attribute here, and Table has one.** The difference
+ * is what a column is in each: here it is the schema, so a table without one
+ * has nothing to read a row with, and every column is a place to write a
+ * `width`. A Table holds cells a consumer wrote and can be written with no
+ * column at all, so its `columns` is where such a table is sized from. Written
+ * on this element the attribute is inert, which is the trap worth knowing when
+ * moving between the two.
  *
  * @since 0.1.0
  * @status stable
@@ -67,7 +66,7 @@ declare const HelixHeadlessDataTable_base: (new (...args: any[]) => import("@fus
  * @aliases Grid, Result table, Data grid
  * @documentation https://fusion.dev/helix/components/data-table
  *
- * @slot - The columns, declared as `helix-table-column` children.
+ * @slot - The columns, declared rather than drawn.
  * @slot footer - Below the grid, replacing the pagination this would otherwise draw.
  * @slot toolbar - Above the grid, for a search field or actions.
  *
@@ -115,18 +114,19 @@ declare const HelixHeadlessDataTable_base: (new (...args: any[]) => import("@fus
  * @csspart table - The grid.
  * @csspart toolbar - The region above the grid.
  *
- * @cssproperty --data-table-cell-align - The edge the column a cell sits under is set to, `start`, `center` or `end`, and unset under a column that sets none. Written by the component onto each cell it draws, read by the sheet that paints one; `helix-table` publishes `--table-cell-align` for the same attribute on the cells a consumer wrote, under its own family's name.
- * @cssproperty --data-table-template - The column track list this element worked out from the columns declared in it. Written by the component, read by the sheet that paints: a stylesheet takes it to lay the grid out, and setting it does nothing, because the component writes it inline on the very element that reads it and an inline declaration beats any sheet. `--data-table-columns` is the one to set.
+ * @cssproperty --data-table-cell-align - The edge the column a cell sits under is set to, `start`, `center` or `end`, and unset under a column that sets none. Written by the component onto each cell it draws, read by the sheet that paints one; Table publishes `--table-cell-align` for the same attribute on the cells a consumer wrote, under its own family's name.
+ * @cssproperty --data-table-template - The column track list this element worked out from the columns declared in it. Written by the component, read by the sheet that paints: a stylesheet takes it to lay the grid out, and setting it does nothing, because the component writes it inline on the very element that reads it and an inline declaration beats any sheet. A column's `width` is the one to set.
  */
 export declare class HelixHeadlessDataTable extends HelixHeadlessDataTable_base {
     /**
      * Nothing is assigned by name, so the columns can be put in a header row.
      *
-     * `role="columnheader"` under `role="grid"` with no owning row is invalid, and
-     * the columns are ordinary children a consumer writes with no `slot`. Manual
-     * assignment is the only way to wrap them without editing the consumer's
-     * markup, which is a change a React consumer's hydration reports and does not
-     * patch up. The same arrangement `helix-table` arrived at, for the same reason.
+     * `role="columnheader"` under `role="grid"` with no owning row is invalid,
+     * and the columns are ordinary children a consumer writes with no `slot`.
+     * Manual assignment is the only way to wrap them without editing the
+     * consumer's markup, which is a change a React consumer's hydration reports
+     * and does not patch up. The same arrangement `Table` arrived at, for the
+     * same reason.
      */
     static shadowRootOptions: ShadowRootInit;
     /**
@@ -273,9 +273,9 @@ export declare class HelixHeadlessDataTable extends HelixHeadlessDataTable_base
      *
      * **It announces nothing, and that is not an omission.** Nothing in this
      * element ever asks for a different page size: a size selector is
-     * `helix-pagination-size`, which a consumer puts in the `footer` slot and
-     * answers themselves. Routing this through `requestChange` would announce an
-     * event the element never has cause to fire.
+     * `PaginationSize`, which a consumer puts in the `footer` slot and answers
+     * themselves. Routing this through `requestChange` would announce an event
+     * the element never has cause to fire.
      */
     get pageSize(): number;
     set pageSize(next: number);
@@ -613,17 +613,17 @@ export declare class HelixHeadlessDataTable extends HelixHeadlessDataTable_base
     /**
      * One cell, carrying its column's edge as a fact rather than as a decision.
      *
-     * **A fact published rather than a property chosen**, which is what
-     * `helix-table` does with the same attribute: what lining up *means*, a
-     * `justify-content` for a value that fits or a `text-align` for one that
-     * wraps, belongs to whoever draws the cell. Written here as an inline
-     * `text-align` it was this tier choosing, in the tier that ships no CSS, and a
-     * consumer could not overrule it either, an inline declaration beating any
-     * `::part(cell)` rule they wrote.
+     * **A fact published rather than a property chosen**, which is what `Table`
+     * does with the same attribute: what lining up *means*, a `justify-content`
+     * for a value that fits or a `text-align` for one that wraps, belongs to
+     * whoever draws the cell. Written here as an inline `text-align` it was this
+     * tier choosing, in the tier that ships no CSS, and a consumer could not
+     * overrule it either, an inline declaration beating any `::part(cell)` rule
+     * they wrote.
      *
      * Only the three edges reach it, `align` being a string anybody can write and
-     * this being a style attribute: `edgeOf` is that guard, and `helix-table`
-     * holds the same value to the same three.
+     * this being a style attribute: `edgeOf` is that guard, and `Table` holds the
+     * same value to the same three.
      */
     private renderCell;
     /**

package/dist/data-table/root/order.d.ts

@@ -87,9 +87,9 @@ export declare const sort: (rows: readonly DataRow[], spec: Sort | undefined, ax
  * One page of rows, clamped.
  *
  * A page past the end returns the last page rather than nothing, because the
- * usual way to be past the end is a bookmarked link after the result shrank, and
- * an empty table is a worse answer than the last page of a smaller one. The
- * same clamp `helix-pagination` already applies to what it reports.
+ * usual way to be past the end is a bookmarked link after the result shrank,
+ * and an empty table is a worse answer than the last page of a smaller one. The
+ * same clamp `Pagination` already applies to what it reports.
  */
 export declare const window_: (rows: readonly DataRow[], page: number, size: number) => DataRow[];
 /** What arranging produces: the rows in order, with no page or window taken. */