@fusion.dev/helix-headless 0.53.1 → 0.53.2

package/dist/table/column/table-column.d.ts

@@ -25,9 +25,9 @@ export declare const at: (row: Readonly<Record<string, unknown>>, path: string)
  *
  * **`align` is a string anybody can write**, the union on the property being a
  * compile-time claim and nothing else, and both tables put the value straight
- * into CSS: `helix-table` into a rule in each row's shadow root, `helix-data-table`
- * into the cell it draws. One guard, here with the property, rather than one in
- * each table and only one of them written.
+ * into CSS: `Table` into a rule in each row's shadow root, `DataTable` into the
+ * cell it draws. One guard, here with the property, rather than one in each
+ * table and only one of them written.
  */
 export declare const edgeOf: (align: string | undefined) => string | undefined;
 /**
@@ -38,23 +38,23 @@ export declare const edgeOf: (align: string | undefined) => string | undefined;
  * the table has another track; remove one and it does not. That is what ties
  * the two together, and a table-level track list on its own does not: a list
  * that is accidentally the headings is invalid CSS a grid ignores in silence,
- * drawing the whole table as one column. `helix-table`'s `columns` is dealt out
- * a track at a time against the columns declared under it, so a heading among
- * the widths costs its own column a width and no more, and a list longer or
- * shorter than the columns is trimmed or shared rather than being a second
- * count of them. A column's own `width` wins over the track in its place.
+ * drawing the whole table as one column. `Table`'s `columns` is dealt out a
+ * track at a time against the columns declared under it, so a heading among the
+ * widths costs its own column a width and no more, and a list longer or shorter
+ * than the columns is trimmed or shared rather than being a second count of
+ * them. A column's own `width` wins over the track in its place.
  *
  * **It is also where every per-column fact goes**, which is the reason
- * `helix-data-table` needs no column config object. `field` names the key the
- * cell reads, `sortable` says a reader may reorder by it, `align` says which
- * edge the values line up against, and `cell` takes a function for anything the
+ * `DataTable` needs no column config object. `field` names the key the cell
+ * reads, `sortable` says a reader may reorder by it, `align` says which edge
+ * the values line up against, and `cell` takes a function for anything the
  * field alone cannot express. The schema is markup and the data is a property:
  * a schema is small, declarative, and something a reader should be able to see
  * in the HTML, and data is large and windowed.
  *
  * **The same element serves both tables**, the markup one and the data one. It
- * is identified by a flag rather than by `instanceof`, so a `helix-table-column`
- * works inside either without the two roots sharing anything else.
+ * is identified by a flag rather than by `instanceof`, so a `TableColumn` works
+ * inside either without the two roots sharing anything else.
  *
  * **It generates no box of its own**, the same as a row: the heading is a grid
  * item of the table, so it lines up with the cells under it rather than sitting
@@ -64,10 +64,10 @@ export declare const edgeOf: (align: string | undefined) => string | undefined;
  * both, so the columns after it keep their own widths and every row keeps its
  * cells under their headings. `hidden="until-found"` keeps its track, the
  * heading being left drawn, as every Helix element leaves one with that value.
- * `helix-data-table` draws the cells, so it leaves out the ones under a hidden
- * column. A `helix-table`'s cells are markup the consumer wrote, so hide them
- * with the column, as removing a column means removing its cells: a row with a
- * cell more than the table has tracks wraps into the next.
+ * `DataTable` draws the cells, so it leaves out the ones under a hidden column.
+ * A `Table`'s cells are markup the consumer wrote, so hide them with the
+ * column, as removing a column means removing its cells: a row with a cell more
+ * than the table has tracks wraps into the next.
  *
  * **A heading that does something holds a control that does it.** The host is
  * the column header, and a header is not focusable, so a sortable heading is a
@@ -99,15 +99,15 @@ export declare class HelixHeadlessTableColumn extends HelixElement {
     /**
      * Which edge the values line up against.
      *
-     * `end` is what a column of numbers wants, so digits of the same magnitude sit
-     * above each other. Left unset the cell inherits the table's own alignment,
-     * which is `start` for text in either writing direction. `helix-data-table`
-     * aligns the cells it draws. A `helix-table`'s cells are markup the consumer
-     * wrote, so the table writes nothing onto them: it publishes the edge to each
-     * cell under this column as `--table-cell-align`, which `@fusion.dev/helix`
-     * reads. The heading is this element's own, and `@fusion.dev/helix` sets it to
-     * the same edge in either table. `end` is the inline end, so in a
-     * right-to-left table it is the left.
+     * `end` is what a column of numbers wants, so digits of the same magnitude
+     * sit above each other. Left unset the cell inherits the table's own
+     * alignment, which is `start` for text in either writing direction.
+     * `DataTable` aligns the cells it draws. A `Table`'s cells are markup the
+     * consumer wrote, so the table writes nothing onto them: it publishes the
+     * edge to each cell under this column as `--table-cell-align`, which
+     * `@fusion.dev/helix` reads. The heading is this element's own, and
+     * `@fusion.dev/helix` sets it to the same edge in either table. `end` is the
+     * inline end, so in a right-to-left table it is the left.
      *
      * **Reflected, because the heading is drawn by a stylesheet and has no other
      * way to learn it.** Set as a property, which is how React sets it, an
@@ -181,8 +181,8 @@ export declare class HelixHeadlessTableColumn extends HelixElement {
      * The track this column takes, as CSS.
      *
      * A single track value, so anything valid in `grid-template-columns` works:
-     * `16rem`, `auto`, `minmax(0, 2fr)`. Left unset the column takes the track
-     * in its place in a `helix-table`'s `columns`, where that table sets one, and
+     * `16rem`, `auto`, `minmax(0, 2fr)`. Left unset the column takes the track in
+     * its place in a `Table`'s `columns`, where that table sets one, and
      * otherwise shares what is left over equally, as `minmax(max-content, 1fr)`.
      * Set here, it wins over that list, which is what lets a reader resize a
      * column in a table that set one.

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

@@ -34,21 +34,20 @@ declare const HelixHeadlessTable_base: (new (...args: any[]) => import("@fusion.
  * @csspart loading - Shown while the rows are still on their way.
  * @csspart table - The grid.
  *
- * @cssproperty --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. `--table-columns` is the one to set.
+ * @cssproperty --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. `columns` is the one to set.
  */
 export declare class HelixHeadlessTable extends HelixHeadlessTable_base {
     /**
      * The column widths as one track list, written once on the table.
      *
-     * With `helix-table-column` children, each track sizes the column in its
-     * place, a hidden column counted, so hiding one takes its track with it and
-     * the rest keep theirs. The columns decide how many tracks there are and this
-     * list only how wide: a track past the last column is dropped, and a column
-     * past the last track shares what is left. With no columns declared it is
-     * the whole track list. Tracks count as the grid counts them, so
-     * `minmax(0, 1fr)` is one and `repeat(2, 8rem)` is two, and one the grid
-     * would refuse leaves its column at the default rather than taking the table
-     * down to one column.
+     * With `TableColumn` children, each track sizes the column in its place, a
+     * hidden column counted, so hiding one takes its track with it and the rest
+     * keep theirs. The columns decide how many tracks there are and this list
+     * only how wide: a track past the last column is dropped, and a column past
+     * the last track shares what is left. With no columns declared it is the
+     * whole track list. Tracks count as the grid counts them, so `minmax(0, 1fr)`
+     * is one and `repeat(2, 8rem)` is two, and one the grid would refuse leaves
+     * its column at the default rather than taking the table down to one column.
      *
      * **A column's own `width` wins over its track here.** The width is written
      * on the column it sizes, which is the more particular statement, and it is
@@ -62,13 +61,11 @@ export declare class HelixHeadlessTable extends HelixHeadlessTable_base {
      * whole answer: a table given one lays its grid out in the first paint, and a
      * table sized only by its columns is one track wide until it upgrades.
      *
-     * **`helix-data-table` has none of this, and should not.** Its columns are
-     * its schema rather than an option, so there is always a column to write a
-     * `width` on and a list here would be a second way to say what that says.
-     * This table's cells are markup, and a table written as rows of cells with no
-     * `helix-table-column` in it has nowhere else to be sized from. Both families
-     * take the same CSS hook, `--table-columns` and `--data-table-columns`, which
-     * wins over whichever list the element worked out.
+     * **Data Table has none of this, and should not.** Its columns are its schema
+     * rather than an option, so there is always a column to write a `width` on
+     * and a list here would be a second way to say what that says. This table's
+     * cells are markup, and a table written as rows of cells with no column
+     * declared in it has nowhere else to be sized from.
      */
     columns: string;
     /**

package/dist/table/row/table-row.d.ts

@@ -4,10 +4,10 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * @summary One row of a table.
  *
  * @description
- * `display: contents` in the styled tier, so the row's cells become items of
- * the table's own grid and every column lines up across every row. The row
- * still exists as an element, which is what a `<table>` gives away when its
- * cells are laid out by the table algorithm.
+ * The row renders its cells straight through and lays out none of them, so a
+ * sheet can take them into the table's own grid and every column lines up
+ * across every row. The row still exists as an element, which is what a
+ * `<table>` gives away when its cells are laid out by the table algorithm.
  *
  * @since 0.1.0
  * @status stable

package/dist/tabs/panel/tab-panel.d.ts

@@ -52,8 +52,8 @@ export declare class HelixHeadlessTabPanel extends HelixElement {
      * a choice nobody made. `ElementInternals` holds it instead.
      *
      * The attribute still seeds the property, which is what
-     * `<helix-tab-panel selected>` in a consumer's markup means. Only the write
-     * back is gone.
+     * `<helix-headless-tab-panel selected>` in a consumer's markup means. Only
+     * the write back is gone.
      */
     protected willUpdate(changed: PropertyValues): void;
     protected render(): TemplateResult;

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

@@ -8,10 +8,10 @@ declare const HelixHeadlessTimeInput_base: (new (...args: any[]) => import("@fus
  * @summary A time, typed or picked from a list.
  *
  * @description
- * **The list is `helix-time-picker`, not a second one written here.** It is worth
+ * **The list is `TimePicker`, not a second one written here.** It is worth
  * having on its own, flat in a settings pane with nothing to open, and this
  * element is the field, the overlay and the form. Exactly the arrangement Input
- * Date has with `helix-date-picker` and Color Input with `helix-color-picker`.
+ * Date has with `DatePicker` and Color Input with `ColorPicker`.
  *
  * **Typed as well as picked, and that is the division the list depends on.** A
  * list at a step offers the times a product actually has, and the field is how a
@@ -120,8 +120,8 @@ export declare class HelixHeadlessTimeInput extends HelixHeadlessTimeInput_base
      *
      * Absent is one. `range` holds a start and an end, `multiple` holds any
      * number, and both are carried as one comma-separated value, which is what a
-     * form submits. `helix-time-picker` carries the longer note on the interaction and on
-     * why a wheel cannot do either.
+     * form submits. `TimePicker` carries the longer note on the interaction and
+     * on why a wheel cannot do either.
      */
     mode?: 'multiple' | 'range';
     /**
@@ -185,7 +185,7 @@ export declare class HelixHeadlessTimeInput extends HelixHeadlessTimeInput_base
      * `list` offers whole times, which is what a product with slots or opening
      * hours has. `wheels` splits them into an hour, a minute and a meridiem where
      * the locale uses one, which is the only way to reach `23:45` without
-     * scrolling most of a day. `helix-time-picker` carries the longer note on the trade.
+     * scrolling most of a day. `TimePicker` carries the longer note on the trade.
      *
      * **Optional rather than defaulted, which is not a style preference.** A
      * reflecting property with a default writes its attribute onto every host the
@@ -218,14 +218,14 @@ export declare class HelixHeadlessTimeInput extends HelixHeadlessTimeInput_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>`**, 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>`**, 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/time-picker/root/time-picker-root.d.ts

@@ -25,8 +25,8 @@ declare const HelixHeadlessTimePicker_base: (new (...args: any[]) => import("@fu
  *
  * @description
  * **A list rather than three wheels**, and the reason is what a list already
- * is. `helix-listbox` brings the keyboard, the typeahead, the scroll into view
- * and the announcement of a set of options, and a time at a step is a set of
+ * is. `Listbox` brings the keyboard, the typeahead, the scroll into view and
+ * the announcement of a set of options, and a time at a step is a set of
  * options. Three little wheels for hours, minutes and a meridiem are three
  * controls to build, three to test, and a tab stop each for something a reader
  * answers once.
@@ -145,7 +145,7 @@ export declare class HelixHeadlessTimePicker extends HelixHeadlessTimePicker_bas
      *
      * Absent is one. `range` holds a start and an end with everything between
      * them shown as part of the answer, `multiple` holds any number, and both are
-     * carried as one comma-separated value: the same shape `helix-date-picker` uses,
+     * carried as one comma-separated value: the same shape `DatePicker` uses,
      * because it is the same question asked of a different unit.
      *
      * **A range is two picks, and a third starts over.** That is the calendar's
@@ -335,11 +335,11 @@ export declare class HelixHeadlessTimePicker extends HelixHeadlessTimePicker_bas
     /**
      * Reveals once the wheels, or the list and its rows, have rendered themselves.
      *
-     * `updated` is this element's own moment, and each wheel is a `helix-listbox`
-     * that was created during this very render: its first update has been
-     * scheduled and has not run, so it has no rows and no height and `reveal`
-     * measures zero and gives up. Measured on a standalone picker, every column
-     * sat at `scrollTop: 0` with the answer nine rows down, which reads as a wheel
+     * `updated` is this element's own moment, and each wheel is a `Listbox` that
+     * was created during this very render: its first update has been scheduled
+     * and has not run, so it has no rows and no height and `reveal` measures zero
+     * and gives up. Measured on a standalone picker, every column sat at
+     * `scrollTop: 0` with the answer nine rows down, which reads as a wheel
      * showing the wrong time rather than as one that failed to scroll.
      *
      * Whatever opens a panel calls `reveal` again afterwards, for the separate

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

@@ -34,7 +34,7 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * @aliases Toaster, Snackbar
  * @documentation https://fusion.dev/helix/components/toast
  *
- * @slot - The messages, as `helix-toast-item` elements.
+ * @slot - The messages.
  *
  * @event {HelixDismissEvent} helix-dismiss - A message asking to go, by its control or by its timer, dispatched by the message and heard here because the stack is what a consumer holds. Cancelable: refusing it takes the decision and the message stays.
  *
@@ -55,7 +55,7 @@ export declare class HelixHeadlessToast extends HelixElement {
      * **Optional, and bottom-end is the absence of it.** Reflecting *and*
      * defaulting is the pair that writes onto a host: every toast region anybody
      * rendered would gain a `placement="bottom-end"` nobody typed, which a React
-     * consumer's server markup does not have. The styled sheet carries the resting
+     * consumer's server markup does not have. A sheet carries the resting
      * arrangement in its own `:host` rule and the selectors describe only the
      * departures, which is what `orientation` does.
      */

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

@@ -37,11 +37,11 @@ export declare class HelixHeadlessToggle extends HelixHeadlessToggle_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 `Radio`, `<helix-toggle value="light"
-     * 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
-     * already in the document when `customElements.define` ran.
+     * this element, on `Option` and on `Radio`, `<helix-headless-toggle
+     * value="light" 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 already in the document when `customElements.define` ran.
      *
      * Nothing overwrites it either, which is what makes reading it late correct
      * rather than merely later: `selected` does not reflect, for the reason

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

@@ -21,8 +21,8 @@ declare const HelixHeadlessTooltip_base: (new (...args: any[]) => import("@fusio
  * the ordinary way:
  *
  * ```html
- * <helix-button id="save" aria-describedby="save-tip">Save</helix-button>
- * <helix-tooltip id="save-tip" for="save" content="Save your work"></helix-tooltip>
+ * <helix-headless-button id="save" aria-describedby="save-tip">Save</helix-headless-button>
+ * <helix-headless-tooltip id="save-tip" for="save" content="Save your work"></helix-headless-tooltip>
  * ```
  *
  * The reference points at *this host*, not at the bubble in its shadow root:

package/dist/tour/stop/tour-stop.d.ts

@@ -20,9 +20,9 @@ import '../../button/index.js';
  * - **When it shows.** Which is `current`, and which the root decides.
  *
  * What it does not own is the heading, the paragraph, the picture and the
- * layout. Slot a `helix-card`, or a heading and a line of prose, or anything
- * else. Fixed `title` and `body` parts would be a component deciding what a
- * tour is allowed to say.
+ * layout. Slot a `Card`, or a heading and a line of prose, or anything else.
+ * Fixed `title` and `body` parts would be a component deciding what a tour is
+ * allowed to say.
  *
  * **The buttons are slot fallback, so the common case costs nothing and the
  * uncommon one is possible.** Write nothing and get Back, Next and Skip already

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

@@ -186,8 +186,8 @@ export declare class HelixHeadlessTreeItem extends HelixHeadlessTreeItem_base {
      * holds it instead, 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-tree-item selected>` in a consumer's
-     * markup means. What stops is the write back.
+     * seeds the property, which is what `<helix-headless-tree-item selected>` in
+     * a consumer's markup means. What stops is the write back.
      */
     protected willUpdate(changed: PropertyValues): void;
     protected render(): TemplateResult;

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

@@ -74,14 +74,15 @@ export declare class HelixHeadlessTree extends HelixHeadlessTree_base {
     /**
      * Every item, in the order a reader moving down would meet them.
      *
-     * Selected by tag, never by `'*'` and a filter: this is the array a single
-     * arrow press rebuilds, and `'*'` makes it every descendant element in the
-     * tree, labels and icons and whatever a consumer slotted into a row included.
+     * **By identity rather than by tag**, which is the same reason Splitter
+     * writes out at `findOuter`: a tag list names one tier's element from the
+     * other's package, and misses any third tag, which is exactly what
+     * subclassing an item produces. The item then never enters the array a single
+     * arrow press rebuilds, so it is silently unreachable from the keyboard.
      *
-     * The two tag names rather than `instanceof` on everything: a styled
-     * `helix-tree-item` extends the base, so both names are needed, and the
-     * `instanceof` stays as the type guard because a consumer can write either
-     * tag and neither selector proves what the element is.
+     * `'*'` and a filter rather than a tag: the walk is one native pass and the
+     * `instanceof` is what narrows it, so the labels, icons and whatever a
+     * consumer slotted into a row are gone by the time the array exists.
      */
     private get items();
     /** Items a reader can actually reach: not inside a collapsed branch. */

package/dist/tree/root/tree-root.js

@@ -81,7 +81,7 @@ let HelixHeadlessTree = class HelixHeadlessTree extends MixinCollection(MixinCon
         };
     }
     get items() {
-        return [...this.querySelectorAll('helix-tree-item, helix-headless-tree-item')].filter((node) => node instanceof HelixHeadlessTreeItem);
+        return [...this.querySelectorAll('*')].filter((node) => node instanceof HelixHeadlessTreeItem);
     }
     get visibleItems() {
         return this.items.filter((item) => {

package/dist/video-playlist/menu/video-playlist-menu.d.ts

@@ -61,7 +61,13 @@ export declare class HelixHeadlessVideoPlaylistMenu extends HelixElement {
     private foundPlaylist;
     /** The playlist this menu belongs to, found upward through the slots. */
     private get playlist();
-    /** The playlist's entries, in the order it holds them. */
+    /**
+     * The playlist's entries, in the order it holds them.
+     *
+     * By identity rather than by tag, the same reason the playlist itself reads
+     * them that way: a tag list names one tier's element from the other's package
+     * and misses any third one.
+     */
     private get entries();
     /**
      * Watches the playlist for entries arriving, and re-reads it on every open.

package/dist/video-playlist/menu/video-playlist-menu.js

@@ -9,9 +9,9 @@ import { list } from '@fusion.dev/helix-icons';
 import { nothing } from 'lit';
 import { property } from 'lit/decorators.js';
 import { html } from 'lit/static-html.js';
+import { HelixHeadlessVideoPlaylistItem } from '../item/video-playlist-item.js';
 import { HelixHeadlessVideoPlaylist } from '../root/video-playlist-root.js';
 import '../../menu/index.js';
-const ITEMS = 'helix-video-playlist-item, helix-headless-video-playlist-item';
 let HelixHeadlessVideoPlaylistMenu = class HelixHeadlessVideoPlaylistMenu extends HelixElement {
     constructor() {
         super(...arguments);
@@ -39,7 +39,9 @@ let HelixHeadlessVideoPlaylistMenu = class HelixHeadlessVideoPlaylistMenu extend
     }
     get entries() {
         const playlist = this.playlist;
-        return playlist ? [...playlist.querySelectorAll(ITEMS)] : [];
+        return playlist
+            ? [...playlist.querySelectorAll('*')].filter((one) => one instanceof HelixHeadlessVideoPlaylistItem)
+            : [];
     }
     watch() {
         this.foundPlaylist ??= closestInstance(this, HelixHeadlessVideoPlaylist) ?? undefined;

package/dist/video-playlist/root/video-playlist-root.d.ts

@@ -35,7 +35,7 @@ declare const HelixHeadlessVideoPlaylist_base: (new (...args: any[]) => import("
  * @documentation https://fusion.dev/helix/components/video-playlist
  *
  * @slot - The entries.
- * @slot player - The `helix-video` they play in.
+ * @slot player - The player the entries take turns in.
  *
  * @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 current entry changes, and cancelable.
@@ -80,10 +80,10 @@ export declare class HelixHeadlessVideoPlaylist extends HelixHeadlessVideoPlayli
     /**
      * The player, whichever tag the consumer slotted.
      *
-     * Asked of the slot rather than matched by tag name: the headless tier's
-     * player is `helix-headless-video` and the styled tier's is `helix-video`, and
-     * a consumer bringing a third under either name should still be driven. What
-     * is needed of it is `src`, which is the whole of the contract.
+     * Asked of the slot rather than matched by tag name: each tier registers its
+     * own player under its own name, and a consumer bringing a third should still
+     * be driven. What is needed of it is `src`, which is the whole of the
+     * contract.
      */
     private get player();
     /** Moves by one, and does nothing at either end. */

package/dist/video-playlist/root/video-playlist-root.js

@@ -7,6 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { customElement, HelixElement, MixinControllerActive } from '@fusion.dev/helix-core';
 import { html } from 'lit';
 import { property } from 'lit/decorators.js';
+import { HelixHeadlessVideoPlaylistItem } from '../item/video-playlist-item.js';
 let HelixHeadlessVideoPlaylist = class HelixHeadlessVideoPlaylist extends MixinControllerActive(HelixElement) {
     constructor() {
         super(...arguments);
@@ -34,9 +35,7 @@ let HelixHeadlessVideoPlaylist = class HelixHeadlessVideoPlaylist extends MixinC
         };
     }
     get items() {
-        return [
-            ...this.querySelectorAll('helix-video-playlist-item, helix-headless-video-playlist-item'),
-        ].filter((one) => one.value !== '');
+        return [...this.querySelectorAll('*')].filter((one) => one instanceof HelixHeadlessVideoPlaylistItem && one.value !== '');
     }
     get player() {
         const slot = this.renderRoot?.querySelector('slot[name="player"]');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fusion.dev/helix-headless",
   "description": "Headless component tier. Structure, accessibility, state, and form participation. No styling.",
-  "version": "0.53.1",
+  "version": "0.53.2",
   "license": "MIT",
   "author": "Ross Sheppard <ross.sheppard@fusion.dev>",
   "repository": {
@@ -46,14 +46,14 @@
   },
   "bugs": "https://github.com/project-fusion/fusion/issues",
   "dependencies": {
-    "@fusion.dev/helix-core": "0.53.1",
-    "@fusion.dev/helix-icons": "0.53.1",
+    "@fusion.dev/helix-core": "0.53.2",
+    "@fusion.dev/helix-icons": "0.53.2",
     "uqr": "^0.1.3"
   },
   "devDependencies": {
     "@custom-elements-manifest/analyzer": "^0.11.0",
-    "@fusion.dev/helix-cem": "0.53.1",
-    "@fusion.dev/helix-testing": "0.53.1",
+    "@fusion.dev/helix-cem": "0.53.2",
+    "@fusion.dev/helix-testing": "0.53.2",
     "@fusion.dev/scripts": "0.0.0-dev",
     "@happy-dom/global-registrator": "^20.0.0",
     "@lit-labs/ssr": "^4.1.0",