@fusion.dev/helix-headless 0.53.1 → 0.53.2

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

@@ -7,9 +7,9 @@ declare const HelixHeadlessDateInput_base: (new (...args: any[]) => import("@fus
  * @summary A date, typed or picked from a calendar.
  *
  * @description
- * **The calendar is `helix-date-picker`, not a second one written here.** It
- * already knows about months, ranges, disabled days, the first day of the week
- * and every keyboard rule a grid owes a reader. This element is the field, the
+ * **The calendar is `DatePicker`, not a second one written here.** It already
+ * knows about months, ranges, disabled days, the first day of the week and
+ * every keyboard rule a grid owes a reader. This element is the field, the
  * overlay, and the translation between them.
  *
  * **Typed as well as picked, and the typing is why it is not
@@ -260,14 +260,15 @@ export declare class HelixHeadlessDateInput extends HelixHeadlessDateInput_base
      * Slot fallback, so a consumer replaces it by slotting; and a method, so the
      * tier above replaces it by overriding.
      *
-     * **A named import rather than `<helix-icon>`**, which loses on three counts.
-     * `helix-icon` indexes the whole icon map at runtime, `icons[this.name]`, and
-     * no bundler can shake a runtime lookup, so every consumer of any component
-     * that renders one ships all 50kB of path data; a named import ships one
-     * path. The import is checked when the package compiles, where a `name`
-     * string is checked only by a later name lookup. And `helix-icon` is not
-     * registered on the headless tier at all, which registers `helix-headless-icon`,
-     * so a headless consumer gets an inert unknown element and no mark whatsoever.
+     * **A named import rather than `<helix-headless-icon>`**, which loses on
+     * three counts. `Icon` indexes the whole icon map at runtime,
+     * `icons[this.name]`, and no bundler can shake a runtime lookup, so every
+     * consumer of any component that renders one ships all 50kB of path data; a
+     * named import ships one path. The import is checked when the package
+     * compiles, where a `name` string is checked only by a later name lookup. And
+     * `Icon` is not registered on the headless tier at all, which registers
+     * `helix-headless-icon`, so a headless consumer gets an inert unknown element
+     * and no mark whatsoever.
      */
     protected renderTrigger(): TemplateResult;
     protected render(): TemplateResult;

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

@@ -148,10 +148,10 @@ export declare class HelixHeadlessDialog extends HelixHeadlessDialog_base {
      * restarts it: without that, pressing twice does nothing the second time,
      * which is the impression the whole thing exists to avoid.
      *
-     * **`once: true` is not a release when the event cannot arrive.** Under
-     * `prefers-reduced-motion: reduce` the styled tier sets `animation: none`, so
-     * no animation runs, `animationend` never fires, and every refused press left
-     * a listener that could not be removed and an attribute that stayed on. The
+     * **`once: true` is not a release when the event cannot arrive.** A sheet
+     * that sets `animation: none` under `prefers-reduced-motion: reduce` runs
+     * none, so `animationend` never fires, and every refused press left a
+     * listener that could not be removed and an attribute that stayed on. The
      * controller bounds it to one listener, aborted before the next is added.
      *
      * **And the attribute is cleared at once when no animation is running**, asked

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

@@ -24,8 +24,8 @@ declare const HelixHeadlessDrawer_base: (new (...args: any[]) => import("@fusion
  * Opened declaratively with the platform's invoker attributes:
  *
  * ```html
- * <helix-button commandfor="nav" command="--toggle">Menu</helix-button>
- * <helix-drawer id="nav">…</helix-drawer>
+ * <helix-headless-button commandfor="nav" command="--toggle">Menu</helix-headless-button>
+ * <helix-headless-drawer id="nav">…</helix-headless-drawer>
  * ```
  *
  * @since 0.1.0
@@ -84,10 +84,10 @@ export declare class HelixHeadlessDrawer extends HelixHeadlessDrawer_base {
     /**
      * Which edge the drawer comes from.
      *
-     * Unset is `end`, which the styled tier reads as `:host(:not([placement]))`
-     * beside `:host([placement="end"])` rather than as a value written here: a
+     * Unset is `end`, and it stays unset rather than being written down: a
      * default assigned to the property would reflect onto every host and put a
-     * `placement="end"` into markup no consumer wrote.
+     * `placement="end"` into markup no consumer wrote. So what this tier
+     * guarantees is the absence, and a sheet selects on it.
      */
     placement?: 'start' | 'end' | 'top' | 'bottom';
     /**

package/dist/filter-input/menu/filter-menu.d.ts

@@ -1,6 +1,6 @@
 import { HelixElement } from '@fusion.dev/helix-core';
 import { type PropertyValues, type TemplateResult } from 'lit';
-import type { HelixHeadlessFilterField } from '../field/filter-field.js';
+import { HelixHeadlessFilterField } from '../field/filter-field.js';
 import type { FilterGrammarOperator } from '../grammar.js';
 import '../../divider/index.js';
 import '../../menu/index.js';
@@ -97,6 +97,12 @@ export declare class HelixHeadlessFilterMenu extends HelixElement {
      *
      * What a render may know of them: none on a server, whose shim has no tree
      * and threw here, and none while hydrating what one sent.
+     *
+     * By identity rather than by tag. A list of names can only hold the tags this
+     * package knows about, so it misses any third one, which is what subclassing
+     * a headless element produces, and it is also how a headless package learns a
+     * styled tag. `instanceof` answers for every one of them and proves the type
+     * the signature claims.
      */
     get fields(): HelixHeadlessFilterField[];
     protected firstUpdated(changed: PropertyValues): void;

package/dist/filter-input/menu/filter-menu.js

@@ -8,6 +8,7 @@ import { customElement, HelixElement, HelixFacetEvent } from '@fusion.dev/helix-
 import { nothing } from 'lit';
 import { property } from 'lit/decorators.js';
 import { html } from 'lit/static-html.js';
+import { HelixHeadlessFilterField } from '../field/filter-field.js';
 import '../../divider/index.js';
 import '../../menu/index.js';
 let HelixHeadlessFilterMenu = class HelixHeadlessFilterMenu extends HelixElement {
@@ -49,7 +50,7 @@ let HelixHeadlessFilterMenu = class HelixHeadlessFilterMenu extends HelixElement
         };
     }
     get fields() {
-        return this.knownChildren.filter((child) => ['helix-headless-filter-field', 'helix-filter-field'].includes(child.localName));
+        return this.knownChildren.filter((child) => child instanceof HelixHeadlessFilterField);
     }
     firstUpdated(changed) {
         super.firstUpdated(changed);

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

@@ -43,12 +43,12 @@ declare const HelixHeadlessFilterInput_base: (new (...args: any[]) => import("@f
  * `FilterField` already plays on its own children.
  *
  * **It can suggest what to type next, and deciding what to suggest is still the
- * consumer's.** Slot `helix-option` elements into `suggestions` and the field
- * shows them, moves through them with the arrows, and lets Enter press one; the
- * option fires its own `helix-select` and the consumer decides what choosing
- * meant. Keys before a colon and values after it are the same panel with
- * different contents, and `readFilterText` is exported for a consumer narrowing
- * that panel against what a reader has half typed.
+ * consumer's.** Slot options into `suggestions` and the field shows them, moves
+ * through them with the arrows, and lets Enter press one; the option fires its
+ * own `helix-select` and the consumer decides what choosing meant. Keys before
+ * a colon and values after it are the same panel with different contents, and
+ * `readFilterText` is exported for a consumer narrowing that panel against what
+ * a reader has half typed.
  *
  * **The panel opens when there is something in it and closes when there is
  * not**, rather than on a choice. A reader who picks a key wants its values

package/dist/format-date/root/format-date-root.d.ts

@@ -47,11 +47,12 @@ export declare class HelixHeadlessFormatDate extends HelixElement {
      * would give.
      *
      * **The element's own text is read as a fallback, and only in a browser.**
-     * `<helix-format-date elapsed>2026-08-27T01:00:00Z</helix-format-date>` is the
-     * spelling that reads best in markup, and it cannot be the only one: measured
-     * against Lit's server shim, `textContent`, `children`, `firstChild` and
-     * `querySelector` are all `undefined` there, so a server has no way to see it.
-     * An element rendered on a server needs the attribute; one rendered in a
+     * `<helix-headless-format-date
+     * elapsed>2026-08-27T01:00:00Z</helix-headless-format-date>` is the spelling
+     * that reads best in markup, and it cannot be the only one: measured against
+     * Lit's server shim, `textContent`, `children`, `firstChild` and
+     * `querySelector` are all `undefined` there, so a server has no way to see
+     * it. An element rendered on a server needs the attribute; one rendered in a
      * browser may use either.
      */
     date: string;

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

@@ -63,11 +63,6 @@ declare const HelixHeadlessHeatmap_base: typeof HelixElement & (new (...args: an
  * @csspart tooltip-top - The bubble while it is above the reading, beside `tooltip`.
  * @csspart tooltip-value - A column's value inside the tooltip.
  *
- * @cssproperty --heatmap-cell-height - How tall a cell is. A row of a tall thin cell is what a status page draws.
- * @cssproperty --heatmap-cell-inline-size - How wide a cell is. The strip fits as many as the container allows.
- * @cssproperty --heatmap-cell-radius - How far a cell's corners are rounded.
- * @cssproperty --heatmap-cell-size - The size a cell wants on both axes, where neither is given its own.
- * @cssproperty --heatmap-gap - Space between cells. Zero is a continuous field rather than a grid of tiles.
  * @cssproperty --heatmap-rows - How many rows the strip lays out. Written by the component from the data, read by the tier that draws it.
  * @cssproperty --heatmap-tone - The tone of the cell this is set on. Written by the component, read by the sheet that paints.
  * @cssproperty --heatmap-tone-1 - The quietest step of the magnitude ramp, reached by `tones="1 …"`.
@@ -105,12 +100,12 @@ export declare class HelixHeadlessHeatmap extends HelixHeadlessHeatmap_base {
      * consumer has to keep by hand, and the one number a summary is told to trust
      * is the one it gets wrong.
      *
-     * The strip measures itself, so `--heatmap-cell-inline-size` and `--heatmap-gap` are
-     * enough on their own and these two are the estimate used until the first
-     * measurement lands. Writing the attribute pins the value and stops the
-     * measurement being consulted, which is what a container query or a transition
-     * on the cell size wants, where what is drawn this frame is not what the
-     * arithmetic should plan around.
+     * The strip measures itself, so sizing the cells in a sheet is enough on its
+     * own and these two are the estimate used until the first measurement lands.
+     * Writing the attribute pins the value and stops the measurement being
+     * consulted, which is what a container query or a transition on the cell size
+     * wants, where what is drawn this frame is not what the arithmetic should
+     * plan around.
      *
      * Zero turns the dropping off altogether, which is right for a strip in a
      * container that cannot get narrow.
@@ -176,13 +171,13 @@ export declare class HelixHeadlessHeatmap extends HelixHeadlessHeatmap_base {
     /**
      * The cell and gap the strip is drawing, in pixels, once it has been read.
      *
-     * **The arithmetic's inputs are a stylesheet's decisions, so the honest way to
-     * learn them is to ask the stylesheet.** A cell's size is a length that only
-     * the cascade can resolve: it may be a `rem` against a root font size, a
+     * **The arithmetic's inputs are a stylesheet's decisions, so the honest way
+     * to learn them is to ask the stylesheet.** A cell's size is a length that
+     * only the cascade can resolve: it may be a `rem` against a root font size, a
      * percentage of a container, or whatever a container query chose this frame.
      * Every one of those is invisible to a number typed into an attribute, and
-     * each of `--heatmap-cell-inline-size`, `--heatmap-cell-height` and `--heatmap-gap`
-     * added one more way for the two to drift apart silently.
+     * every hook a sheet offers for the cell box or the gap is one more way for
+     * the two to drift apart silently.
      *
      * Reading it back is not styling and does not breach the tier: this asks what
      * was decided rather than deciding, which is the same direction as the facts

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

@@ -93,10 +93,10 @@ export declare class HelixHeadlessImage extends HelixElement {
      * **Mirrored to `data-status`, and not reflected as `status`.** It is element
      * state, so reflecting it puts the element's own bookkeeping into the markup
      * a consumer rendered: React reads the attribute appearing at upgrade as a
-     * hydration mismatch, and a serialized `<helix-image status="loaded">` pasted
-     * back declares that a picture has arrived which this element has never
-     * fetched. The `data-` name is the library's answer to both, being a name a
-     * re-parse cannot mistake for a declaration, and it is what `data-closed` on
+     * hydration mismatch, and a host pasted back carrying `status="loaded"`
+     * declares that a picture has arrived which this element has never fetched.
+     * The `data-` name is the library's answer to both, being a name a re-parse
+     * cannot mistake for a declaration, and it is what `data-closed` on
      * `Toast.Item` already does. A picture arrives after somebody fetched it,
      * which puts this on the safe side of hydration: a fact that can be true on
      * the *first* update mirrors to a custom state instead, which is what

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

@@ -100,10 +100,10 @@ export declare class HelixHeadlessInput extends HelixHeadlessInput_base {
      * **The attribute is `readonly`, which is the platform's spelling.** A
      * camelCase property needs an explicit `attribute`, and dash-casing a word
      * HTML writes as one costs what an attribute always costs here: nothing
-     * warns. `<helix-input readonly>` is what anybody who has written HTML types;
-     * against `read-only` it parses to no property at all, and the field stays
-     * editable with no error anywhere. Measured on the dash-cased form, `readOnly`
-     * came back `false`.
+     * warns. `<helix-headless-input readonly>` is what anybody who has written
+     * HTML types; against `read-only` it parses to no property at all, and the
+     * field stays editable with no error anywhere. Measured on the dash-cased
+     * form, `readOnly` came back `false`.
      */
     readOnly: boolean;
     /**
@@ -218,9 +218,9 @@ export declare class HelixHeadlessInput extends HelixHeadlessInput_base {
      *
      * **Not reflected.** Reflection exists so a selector can reach a value, and
      * no stylesheet in this repository selects on `type`. Reflecting it writes
-     * `type="text"` onto every `<helix-input>` ever rendered, an attribute no
-     * consumer's markup has, which is the fault the area rules write up under
-     * `Button`'s `href`, `target` and `rel`.
+     * `type="text"` onto every `<helix-headless-input>` ever rendered, an
+     * attribute no consumer's markup has, which is the fault the area rules write
+     * up under `Button`'s `href`, `target` and `rel`.
      *
      * Nothing reads it from the attribute either. The real `<input>` inside takes
      * it as a property binding, which is what makes the keyboard and the

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

@@ -156,8 +156,7 @@ export declare class HelixHeadlessLineChart extends HelixHeadlessLineChart_base
      * over something busy. `triangle` points along the axis and reads as "and
      * onward" rather than as a second claim about the data.
      *
-     * The shapes come from
-     * `helix/styled/src/shared/chart/terminus.css`, the same sheet `Sparkline` takes, so
+     * The shapes come from one shared sheet, the same one `Sparkline` takes, so
      * the set is identical wherever one appears. **Which is why every value is
      * named here.** `Sparkline` shipped `square` implemented, drawn, asserted and
      * undocumented until the cohort before this one; this family reads the same

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

@@ -65,13 +65,12 @@ export declare class HelixHeadlessListItem extends HelixElement {
      * beside the words rather than at the edge of the block. A number that has to
      * sit in a track has to be a box in that track.
      *
-     * **The box belongs to the styled tier, which is why this returns `nothing`.**
-     * Rendering it here puts an unstyled empty box in front of every headless row,
-     * and a row styled with `display: flex` and a `gap` draws that gap beside the
-     * empty child: measured on this tier's own example, which is exactly such a
-     * row, 1384 pixels moved and every label sat half a rem further in. The styled
-     * row's own comment records the same fault about a column gap beside a
-     * zero-width column.
+     * **The box belongs to the styled tier, which is why this returns
+     * `nothing`.** Rendering it here puts an unstyled empty box in front of every
+     * headless row, and a row styled with `display: flex` and a `gap` draws that
+     * gap beside the empty child: measured on this tier's own example, which is
+     * exactly such a row, 1384 pixels moved and every label sat half a rem
+     * further in.
      *
      * A tier that ships no CSS cannot make a box it renders cost nothing, so it
      * does not render one. `marker="rail"` is a styled-tier attribute for the same

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

@@ -47,10 +47,10 @@ export declare class HelixHeadlessList extends HelixElement {
     /**
      * Which markers an ordered list draws, in `<ol type>`'s own five values.
      *
-     * Reflected, because this is one of the things a stylesheet selects on and
-     * the styled tier maps each to a `list-style-type`. The platform's spellings
-     * rather than the CSS ones, so `<helix-list kind="ordered" type="i">` is what
-     * a consumer would have written on an `<ol>`.
+     * Reflected, because this is one of the things a stylesheet selects on, each
+     * value mapping to a `list-style-type`. The platform's spellings rather than
+     * the CSS ones, so `<helix-headless-list kind="ordered" type="i">` is what a
+     * consumer would have written on an `<ol>`.
      *
      * **`start` and `reversed` are both absent and neither can be done here.**
      * This renders no `<ol>`: the rows are slotted and numbered by the CSS

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

@@ -137,8 +137,8 @@ export declare class HelixHeadlessMegamenu extends HelixHeadlessMegamenu_base {
      *
      * **The first ancestor as wide as the window, which is a fact and not a tag
      * name.** A band spans the viewport, so what it should hang from is whatever
-     * else does: that is what makes something a bar. Asking for `helix-app-header`
-     * by name would make this element know about that one, which is the coupling
+     * else does: that is what makes something a bar. Asking for `AppHeader` by
+     * name would make this element know about that one, which is the coupling
      * `Menu` is careful not to have with `Drilldown`, and would leave a consumer
      * who wrote their own header with a band across it.
      *
@@ -228,8 +228,8 @@ export declare class HelixHeadlessMegamenu extends HelixHeadlessMegamenu_base {
      * The control that opens it, behind a seam the styled tier can move.
      *
      * The same case `SpeedDial` records: a bare `<button>` is what this tier can
-     * write, `helix-button` lives a tier above, and a render method is how a tier
-     * that has one reaches this without reimplementing the panel below it.
+     * write, `Button` lives a tier above, and a render method is how a tier that
+     * has one reaches this without reimplementing the panel below it.
      */
     protected renderTrigger(): TemplateResult;
     protected render(): TemplateResult;

package/dist/notifications/notification/notification.d.ts

@@ -6,9 +6,9 @@ declare const HelixHeadlessNotification_base: (new (...args: any[]) => import("@
  * @summary One thing that happened, which a reader may not have seen yet.
  *
  * @description
- * A notification is a toast that did not go away. `helix-toast` is deliberately
- * the opposite of this: a live region whose items carry a `duration` and whose
- * root never creates or destroys anything. What makes this its own family is the
+ * A notification is a toast that did not go away. `Toast` is deliberately the
+ * opposite of this: a live region whose items carry a `duration` and whose root
+ * never creates or destroys anything. What makes this its own family is the
  * state each item carries rather than the arrangement it sits in: read and
  * unread, a timestamp that has to stay correct, and an action a reader can take
  * later.
@@ -20,9 +20,9 @@ declare const HelixHeadlessNotification_base: (new (...args: any[]) => import("@
  * reader wants exactly one of them at a time: the time while they are scanning,
  * and what they can do about it once they have stopped on a row.
  *
- * **The timestamp is `helix-format-date`**, which is where the reading, the
- * `<time datetime>` and the shared timer now live. It was implemented here, and
- * a component that formats a date is not a fact about notifications: Chat wanted
+ * **The timestamp is `FormatDate`**, which is where the reading, the `<time
+ * datetime>` and the shared timer now live. It was implemented here, and a
+ * component that formats a date is not a fact about notifications: Chat wanted
  * the same thing and had its own copy of half of it.
  *
  * **Read state is reported, not invented.** Marking something read is usually a
@@ -86,10 +86,10 @@ export declare class HelixHeadlessNotification extends HelixHeadlessNotification
      *
      * **Not reflected.** Unread is a visual state, which is why the four mixins
      * mirror theirs, but the mirror may not be the property's own attribute:
-     * `<helix-notification default-read>` comes back from a server without `read`
-     * and would gain it on the first update, which React reports as a hydration
-     * mismatch, and which a copy of the serialized element re-parses as a
-     * declaration. `:state(read)` is what the stylesheet reads.
+     * `<helix-headless-notification default-read>` comes back from a server
+     * without `read` and would gain it on the first update, which React reports
+     * as a hydration mismatch, and which a copy of the serialized element
+     * re-parses as a declaration. `:state(read)` is what the stylesheet reads.
      * `hydration.dom.spec.ts` holds it.
      */
     get read(): boolean;

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

@@ -30,7 +30,7 @@ declare const HelixHeadlessNotifications_base: (new (...args: any[]) => import("
  * @aliases Notification feed, Inbox, Activity
  * @documentation https://fusion.dev/helix/components/notifications
  *
- * @slot - The notifications, as `helix-notification` children.
+ * @slot - The notifications.
  * @slot footer - Below the list, for a link to everything.
  * @slot header - Above the list, for a title and the mark-all control.
  *

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

@@ -107,7 +107,7 @@ export declare class HelixHeadlessOption extends HelixElement {
      * **The attribute, read when it is asked for, and never a snapshot taken in
      * the constructor.** A field initializer runs there, and an element the HTML
      * parser created has none of its attributes yet at that moment: measured on
-     * this element, on `Radio` and on `Toggle`, `<helix-option value="a"
+     * this element, on `Radio` and on `Toggle`, `<helix-headless-option value="a"
      * selected>` reported `defaultSelected` as `false` both from parsed markup
      * and from `createElement` followed by `setAttribute`, which is every way a
      * consumer writes one. The snapshot could only ever be true for an element
@@ -223,8 +223,8 @@ export declare class HelixHeadlessOption extends HelixElement {
      * where it is not in the DOM at all.
      *
      * Reading `selected` is unaffected and so is writing it: the attribute still
-     * seeds the property, which is what `<helix-option selected>` in a consumer's
-     * markup means. What stops is the write back.
+     * seeds the property, which is what `<helix-headless-option selected>` in a
+     * consumer's markup means. What stops is the write back.
      */
     protected willUpdate(changed: PropertyValues): void;
     protected render(): TemplateResult;

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

@@ -6,8 +6,8 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * @description
  * **The component is the truncation.** Given a page and a total it works out
  * which numbers to show and where the runs break, so this is data-driven rather
- * than composed: `<helix-pagination page="4" pages="12">` rather than twelve
- * slotted children a consumer keeps in step with their own query.
+ * than composed: `<helix-headless-pagination page="4" pages="12">` rather than
+ * twelve slotted children a consumer keeps in step with their own query.
  *
  * **The width does not change as you page.** The run around the current page is
  * `siblings` either side, and grows to absorb a gap slot at a boundary, so the

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

@@ -110,10 +110,10 @@ export declare class HelixHeadlessPinInput extends HelixHeadlessPinInput_base {
      * marked letters wants `text`, which judges nothing.
      *
      * **Not reflected**: nothing selects on it, so reflecting only writes
-     * `type="numeric"` onto every `<helix-pin-input>` ever rendered, an attribute
-     * no consumer's markup had. The area rules carry the sentence "reflect only
-     * what CSS selects on". The real inputs take it as a binding, which is what
-     * makes the keyboard follow.
+     * `type="numeric"` onto every `<helix-headless-pin-input>` ever rendered, an
+     * attribute no consumer's markup had. The area rules carry the sentence
+     * "reflect only what CSS selects on". The real inputs take it as a binding,
+     * which is what makes the keyboard follow.
      */
     type: PinType;
     /** Focus is delegated, so the host is never the focus target. */

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

@@ -64,12 +64,13 @@ export declare class HelixHeadlessPopover extends HelixHeadlessPopover_base {
      * The invoker that last opened the panel, when a command did.
      *
      * Kept because the `source` a command hands the handlers is needed twice
-     * over. It is the anchor: the styled host is a boxless `display: contents`
-     * element, so a popover opened by a command outside it would otherwise open
-     * against the window origin. And the outside-press dismissal has to know the
-     * invoker is part of the control, the press firing on `pointerdown` and the
-     * command arriving on the `click` after it, or a `--toggle` button outside
-     * the host closes the panel and immediately reopens it, for ever.
+     * over. It is the anchor: the host is not a box to position against, a sheet
+     * being free to give it none, so a popover opened by a command outside it
+     * would otherwise open against the window origin. And the outside-press
+     * dismissal has to know the invoker is part of the control, the press firing
+     * on `pointerdown` and the command arriving on the `click` after it, or a
+     * `--toggle` button outside the host closes the panel and immediately reopens
+     * it, for ever.
      */
     private invoker;
     protected readonly commands: CommandController;

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

@@ -54,7 +54,7 @@ export declare class HelixHeadlessRadio extends HelixHeadlessRadio_base {
      * **The attribute, read when it is asked for, and never a snapshot taken in
      * the constructor.** A field initializer runs there, and an element the HTML
      * parser created has none of its attributes yet at that moment: measured on
-     * this element, on `Option` and on `Toggle`, `<helix-radio value="a"
+     * this element, on `Option` and on `Toggle`, `<helix-headless-radio value="a"
      * selected>` reported `defaultSelected` as `false` both from parsed markup
      * and from `createElement` followed by `setAttribute`, which is every way a
      * consumer writes one. The snapshot could only ever be true for an element

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

@@ -15,11 +15,10 @@ declare const HelixHeadlessSpeedDial_base: (new (...args: any[]) => import("@fus
  * mean defining what a dial with a submenu in it does.
  *
  * **The trigger is a control the consumer slots**, and the floating action
- * button is the usual one: `helix-icon-button` 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.
+ * 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.
  *
  * **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
@@ -105,10 +104,10 @@ export declare class HelixHeadlessSpeedDial extends HelixHeadlessSpeedDial_base
      *
      * **This is the case the tier rule blocks and a render method unblocks.** A
      * bare `<button>` is what the headless tier can write: it must not reach for
-     * `helix-button`, which lives a tier above and would make `headless` depend
-     * on `styled`. So the base draws the plain control and a tier that has buttons
-     * of its own overrides this to use one. Written inline, the only way
-     * to change it would be to reimplement the template, panel and all.
+     * `Button`, which lives a tier above and would make `headless` depend on
+     * `styled`. So the base draws the plain control and a tier that has buttons
+     * of its own overrides this to use one. Written inline, the only way to
+     * change it would be to reimplement the template, panel and all.
      */
     protected renderTrigger(): TemplateResult;
     protected render(): TemplateResult;

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

@@ -35,9 +35,9 @@ export declare class HelixHeadlessStat extends HelixElement {
      * The row directions set them side by side, for a figure in a line of text or
      * a narrow strip where a stacked pair would be two lines of almost nothing.
      *
-     * A property rather than a `helix-flex` around it, because the unit has to
-     * stay on the value's baseline whichever way the pair goes, and only this
-     * element knows which of its children the unit belongs to.
+     * A property rather than a `Flex` around it, because the unit has to stay on
+     * the value's baseline whichever way the pair goes, and only this element
+     * knows which of its children the unit belongs to.
      *
      * **Optional rather than defaulted to `column`, which is not a style
      * preference.** A reflecting property with a default writes its attribute onto

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

@@ -22,7 +22,7 @@ declare const HelixHeadlessSteps_base: (new (...args: any[]) => import("@fusion.
  * @aliases Stepper, Wizard, Progress steps
  * @documentation https://fusion.dev/helix/components/steps
  *
- * @slot - The steps, which are `helix-step` elements.
+ * @slot - The steps.
  *
  * @event {HelixActivateEvent} helix-activate - Fired once the current one has moved, so the element already holds it.
  * @event {HelixBeforeActivateEvent} helix-before-activate - Fired before the active step changes. Cancelable: refusing it takes the decision and nothing moves.

package/dist/steps/step/step.d.ts

@@ -6,9 +6,9 @@ import '../../button/index.js';
  *
  * @description
  * **The name is a button, and only the name.** The marker is `aria-hidden`
- * decoration, so wrapping it would add hit area and no meaning. It is
- * `helix-button` rather than a `<button>` this element resets: the hover wash,
- * the focus ring and the disabled treatment are decisions the button carries.
+ * decoration, so wrapping it would add hit area and no meaning. It is `Button`
+ * rather than a `<button>` this element resets: the hover wash, the focus ring
+ * and the disabled treatment are decisions the button carries.
  *
  * **It says nothing about where a reader may go.** Every step is pressable and
  * announces itself with `helix-select`; refusing the ones ahead is `disabled`,
@@ -27,7 +27,7 @@ import '../../button/index.js';
  * @documentation https://fusion.dev/helix/components/steps
  *
  * @slot - The step's name.
- * @slot content - What the stage holds. Always rendered here, a tier with no stylesheet having nothing to fold it with; the styled tier opens it on the current step down a column, and a row has no space under a step to open it into.
+ * @slot content - What the stage holds. Always rendered here, a tier with no stylesheet having nothing to fold it with, so whether it is folded away is the sheet's answer and not this tier's.
  * @slot description - A line under the name, for what the stage is for.
  * @slot marker - Replaces the number, or the check a complete step shows.
  *
@@ -36,7 +36,7 @@ import '../../button/index.js';
  * @csspart body - The name and its description.
  * @csspart content - What the stage holds, while it is open.
  * @csspart description - The line under it.
- * @csspart label - The step's name, which is a `helix-button`.
+ * @csspart label - The step's name, which is a control.
  * @csspart label-button - The inner control.
  * @csspart lead - The half line arriving from the step before.
  * @csspart mark - The glyph inside the marker: a tick, a dot, or an empty ring.