@fusion.dev/helix-headless 0.53.1 → 0.53.3

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,14 +31,15 @@ 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
  * sort, a filter and a page. `selected` is the chosen keys, comma separated, the
- * shape Listbox uses for a multiple choice, and like `sort` it is controlled
- * when set and seeded by `default-selected`. The box in the heading selects every
- * row in the result, across pages, and shows a dash while only some are chosen.
+ * shape Listbox uses for a multiple choice, and like `sort` writing it applies
+ * while `default-selected` is what the markup declared. The box in the heading
+ * selects every row in the result, across pages, and shows a dash while only
+ * some are chosen.
  * Choosing one of many, rather than several, is opening a row, and that is a
  * link or a button in a cell rather than a selection.
  *
@@ -52,14 +53,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 +67,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 +115,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 +274,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 +614,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. */

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/donut-chart/root/donut-chart-root.d.ts

@@ -91,7 +91,7 @@ export declare class HelixHeadlessDonutChart extends HelixHeadlessDonutChart_bas
      * `--donut-chart-stroke`, which is a number a rule can do sums with where the
      * word is not. Reflected, it wrote a value onto every host a script had set
      * it on for nothing to read. `sweep` beside it is the converse and reflects,
-     * because three rules select on it.
+     * because the styled sheet selects on it.
      */
     hole?: 'large' | 'none' | 'small';
     /**

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
@@ -56,20 +56,19 @@ declare const HelixHeadlessFilterInput_base: (new (...args: any[]) => import("@f
  * `selectionStart` and `setSelectionRange` to write a completion back and put
  * the caret after it, or the next parse reads the wrong term.
  *
- * **Three things here have three different owners, and only one of them is a
- * controlled property.**
+ * **Three things here have three different owners.**
  *
- * `value` is the text, and it is uncontrolled by default: the reader types, the
- * element applies it, and `input` says so. **Writing `value` does not take that
- * over.** It is a seed and a correction, so a consumer who sets it and then
- * expects the field to hold still will watch the next keystroke overwrite them.
+ * `value` is the text: the reader types, the element applies it, and `input`
+ * says so. **Writing `value` does not take that over.** It is a seed and a
+ * correction, so a consumer who sets it and then expects the field to hold
+ * still will watch the next keystroke overwrite them.
  * Ownership is taken by refusing `helix-before-change` and writing the value
  * you want, which is the same shape every field in this library uses and is
  * worth saying out loud here because the property looks like React's.
  * `default-value` seeds the field without claiming anything.
  *
- * `open` is the suggestions panel, and it is the ordinary controlled pair:
- * refuse `helix-before-open` or `helix-before-close` to take the decision, and
+ * `open` is the suggestions panel, and it is the ordinary pair: refuse
+ * `helix-before-open` or `helix-before-close` to take the decision, and
  * `default-open` to seed it.
  *
  * The tokens are neither, because they are not state. They are the consumer's

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/object-inspector/root/object-inspector-root.d.ts

@@ -153,6 +153,16 @@ export declare class HelixHeadlessObjectInspector extends HelixElement {
     private active;
     /** Set by a keyboard move, so the next render brings the active row into view. */
     private revealing;
+    /**
+     * How tall a row is taken to be before it has been drawn, in pixels.
+     *
+     * A constant rather than the property `VirtualList` and `DataTable` carry:
+     * every row here is one line of the same text at this family's own leading,
+     * so there is nothing for a consumer to tell it. `reveal` falls back to this
+     * when a drawn row measures zero, and the two have to be the same number or a
+     * keyboard move scrolls by a different row than the window counted with.
+     */
+    static readonly ESTIMATE = 24;
     private readonly virtualize;
     private get root();
     /** Every visible row, in order, worked out once per change rather than per read. */