@fusion.dev/helix-headless 0.0.0-dev → 0.0.3

package/dist/menu/root/menu-root.js

@@ -56,42 +56,35 @@ let HelixHeadlessMenu = class HelixHeadlessMenu extends MixinCollection(MixinCon
     constructor() {
         super(...arguments);
         /**
-         * Preferred side.
-         *
-         * It moves if that side does not fit.
-         */
-        this.placement = 'bottom-start';
-        /**
-         * Space between the trigger and the surface, in pixels.
+         * What the row returning from a submenu reads.
          */
-        this.offset = 4;
+        this.backLabel = 'Back';
         /**
          * Accessible name for the surface.
          */
         this.label = 'Menu';
         /**
-         * What the row returning from a submenu reads.
+         * Space between the trigger and the surface, in pixels.
          */
-        this.backLabel = 'Back';
+        this.offset = 4;
+        /**
+         * Preferred side.
+         *
+         * It moves if that side does not fit.
+         */
+        this.placement = 'bottom-start';
         /**
          * Which page is showing, and what is on it.
          *
-         * This was a `page` field, a title getter and an items getter written here.
-         * None of them were about menus: a settings panel or a navigation tree wants
-         * the same thing, and could not have it without being a menu. The controller
-         * holds the same shape, so the port is a rename rather than a rewrite, and it
-         * adds a real stack: `back()` returns one level instead of to the root, which
-         * this could not do because it only ever went two deep.
+         * A controller rather than fields here, because none of this is about menus:
+         * a settings panel or a navigation tree wants the same shape. It holds a real
+         * stack, so `back()` returns one level rather than to the root.
          */
         this.drilldown = new DrilldownController(this, {
             isRow: (element) => 'isMenuItem' in element && element.isMenuItem === true,
             root: () => [...this.children].filter((child) => child.slot !== 'trigger'),
             slot: 'submenu',
         });
-        /* One controller where there were two and a hand-written sequence between
-           them. It is the same three things in the same order; what it is not is a
-           third copy of them, and the second copy is how `Select` ended up never
-           reaching the top layer at all. */
         /**
          * Moving between rows, which is not this element's own business any more.
          *
@@ -99,14 +92,12 @@ let HelixHeadlessMenu = class HelixHeadlessMenu extends MixinCollection(MixinCon
          * choosing are one act in a radio group and two acts here, which is the
          * distinction the controller was already drawing for `Tabs`.
          *
-         * The origin is the selection, which took a wrong turn first and is worth
-         * recording. `focus` looks like the right reading, since a menu's current row
-         * is the focused one, but that origin also carries a rule a menu must not
-         * follow: a press that did not come from the set moves nothing. That rule is
-         * there for a tab panel, which is a tab stop beside the tabs; a menu's panel
-         * holds the rows and nothing else, and Down on a menu that has just opened is
-         * how a reader gets to the first row at all. It moved nothing, and the specs
-         * written alongside this are what said so.
+         * The origin is the selection, and `focus` is the wrong reading however right
+         * it looks: that origin also carries a rule a menu must not follow, that a
+         * press which did not come from the set moves nothing. That rule is there for
+         * a tab panel, which is a tab stop beside the tabs; a menu's panel holds the
+         * rows and nothing else, and Down on a menu that has just opened is how a
+         * reader gets to the first row at all.
          *
          * The horizontal pair is reserved rather than released. Right opens a
          * submenu and left comes back, which are the platform's own bindings for a
@@ -144,30 +135,12 @@ let HelixHeadlessMenu = class HelixHeadlessMenu extends MixinCollection(MixinCon
             }
             this.hide();
         };
-        /*
-         * Moves over the page, in the direction the key points.
-         *
-         * The arrows wrap, because a menu is a ring rather than a list with ends:
-         * pressing down on the last item to reach the first is what every menu on
-         * every platform does.
-         */
-        /*
-         * Focuses an item and brings it into the surface, which is not the same act.
-         *
-         * A menu long enough to scroll had the tree's problem: the arrow keys moved
-         * focus past the bottom of the panel and the panel stayed where it was.
-         * Scrolled here rather than by the browser, because `scrollIntoView` would
-         * take the page behind the menu with it.
-         */
         /**
          * Keeps whatever has focus in sight, however it got there.
          *
-         * This was done in the arrow branches, which meant it was true of the arrow
-         * keys and of nothing else: a row reached by Tab, or focused by the drilldown
-         * on the way into a page, could sit below the fold of a scrolled panel. On
-         * `focusin` it is one rule about focus rather than a line repeated in every
-         * branch that moves it, and it survived the arrow keys moving out to a shared
-         * controller that knows nothing about this panel.
+         * On `focusin` rather than in the branches that move focus: a row reached by
+         * Tab, or focused by the drilldown on the way into a page, can otherwise sit
+         * below the fold of a scrolled panel.
          */
         this.handleFocusIn = (event) => {
             const item = this.items.find((row) => row.contains(event.target));
@@ -177,14 +150,10 @@ let HelixHeadlessMenu = class HelixHeadlessMenu extends MixinCollection(MixinCon
             /* `surface`, which is the part this template renders and the name the
                whole library spells this box with.
         
-               *Rewritten 28 Aug 2026, because it had come to say the reverse.* The
-               fault it records is real and was the other way round: the lookup asked
-               for a name the template did not render, found null, and `scrollItemIntoView`
-               ran with no scroller and took the page behind the menu with it, which is
-               the one thing that method exists to prevent. What the comment could not
-               know is that `check:vocabulary` later renamed the part *to* `surface`, so
-               a note naming `menu` as the right answer now teaches the opposite of the
-               rule that settled it. The lookup and the part have agreed since. */
+               Keep the two in step. A lookup asking for a name the template does not
+               render finds null, and `scrollItemIntoView` then runs with no scroller and
+               takes the page behind the menu with it, which is the one thing that method
+               exists to prevent. */
             const surface = this.renderRoot.querySelector('[part="surface"]');
             scrollItemIntoView(item, { padding: 4, ...(surface ? { scroller: surface } : {}) });
         };
@@ -204,9 +173,9 @@ let HelixHeadlessMenu = class HelixHeadlessMenu extends MixinCollection(MixinCon
             else if (event.key === 'Tab') {
                 /* Out, and the panel goes with it.
                  *
-                 * Nothing closed the menu when focus left it, so tabbing out of an open
-                 * one left a shadowed panel in the top layer sitting over whatever the
-                 * reader had tabbed to. Deliberately not prevented: focus should carry on
+                 * Nothing else closes the menu when focus leaves it, so tabbing out of an
+                 * open one would leave a shadowed panel in the top layer sitting over
+                 * whatever the reader tabbed to. Deliberately not prevented: focus carries on
                  * outward, which is what the reader asked for. And deliberately not a
                  * focus trap, because a menu is not a modal and Tab is a way out of one. */
                 this.hide();
@@ -229,11 +198,10 @@ let HelixHeadlessMenu = class HelixHeadlessMenu extends MixinCollection(MixinCon
     /**
      * Tells a slotted trigger the disclosure state, by property.
      *
-     * This menu wrote nothing onto its trigger, which was the right call and cost
-     * a reader the one thing they needed: a control that opens a menu and never
-     * says so. The class note above already gives the mechanism for the way out,
-     * that items are "told by property, not by attribute", and `tellDisclosure`
-     * is that argument applied one level up. See #322.
+     * A control that opens a menu has to say so. By property rather than by
+     * attribute, which is the class note's rule about items applied one level up:
+     * an attribute written onto a consumer's element after it upgrades is a
+     * hydration mismatch waiting to happen.
      */
     tellTrigger() {
         const slot = this.renderRoot?.querySelector('slot[name="trigger"]');
@@ -248,9 +216,9 @@ let HelixHeadlessMenu = class HelixHeadlessMenu extends MixinCollection(MixinCon
         /* Disabled rows are not there for the keyboard.
          *
          * A disabled row renders no `tabindex` and cannot take focus, so leaving it
-         * in the list meant the arrow keys computed a move onto it, called `focus()`
-         * on something unfocusable, and stopped: the keyboard was stuck one row
-         * above every disabled item in the menu. `Drilldown` filters for the same
+         * in the list has the arrow keys compute a move onto it, call `focus()` on
+         * something unfocusable, and stop: the keyboard is then stuck one row above
+         * every disabled item in the menu. `Drilldown` filters for the same
          * reason. */
         return this.drilldown.rows.filter((row) => !row.disabled);
     }
@@ -322,10 +290,10 @@ let HelixHeadlessMenu = class HelixHeadlessMenu extends MixinCollection(MixinCon
         super.updated(changed);
         // Every update, so a trigger slotted after the first render is told too.
         this.tellTrigger();
-        /* Put the panel where `open` says, however it got there. `show()` and
-           `hide()` raised and lowered it and nothing else did, so a menu opened by
-           declaring `open` rendered visible, out of the top layer and unanchored:
-           every imperative path worked and every declarative one was half-open. */
+        /* Put the panel where `open` says, however it got there. Raising it in
+           `show()` and lowering it in `hide()` alone leaves a menu opened by
+           declaring `open` visible, out of the top layer and unanchored: every
+           imperative path works and every declarative one is half-open. */
         if (changed.has('open')) {
             /* Here rather than a microtask later: `updated()` runs after the render,
                so the panel is no longer `display: none` and `showPopover` is safe. */
@@ -350,11 +318,10 @@ let HelixHeadlessMenu = class HelixHeadlessMenu extends MixinCollection(MixinCon
     /**
      * Walks the tree marking which rows are on the page showing.
      *
-     * Two levels were marked by hand and nothing wrote `showingSubmenu` on a
-     * nested row, so drilling into a third-level submenu rendered the header over
-     * an empty panel: the page existed, its rows were still marked as belonging
-     * to the level above, and none of them rendered. `Drilldown.mark()` is the
-     * same walk and was already recursive.
+     * Recursive rather than two levels by hand: without `showingSubmenu` on a
+     * nested row, drilling into a third-level submenu renders the header over an
+     * empty panel, the page existing while its rows are still marked as belonging
+     * to the level above. `Drilldown.mark()` is the same walk.
      *
      * `slot === 'submenu'` rather than every child, because a row's other
      * children are its label and its icons.
@@ -404,18 +371,18 @@ let HelixHeadlessMenu = class HelixHeadlessMenu extends MixinCollection(MixinCon
       </div>`;
     }
 };
+__decorate([
+    property({ attribute: 'back-label' })
+], HelixHeadlessMenu.prototype, "backLabel", void 0);
 __decorate([
     property()
-], HelixHeadlessMenu.prototype, "placement", void 0);
+], HelixHeadlessMenu.prototype, "label", void 0);
 __decorate([
     property({ type: Number })
 ], HelixHeadlessMenu.prototype, "offset", void 0);
 __decorate([
     property()
-], HelixHeadlessMenu.prototype, "label", void 0);
-__decorate([
-    property({ attribute: 'back-label' })
-], HelixHeadlessMenu.prototype, "backLabel", void 0);
+], HelixHeadlessMenu.prototype, "placement", void 0);
 HelixHeadlessMenu = __decorate([
     customElement('helix-headless-menu')
 ], HelixHeadlessMenu);

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

@@ -53,50 +53,6 @@ export type MeterBand = 'fair' | 'good' | 'poor';
  * @cssproperty --meter-sweep - How much of the circle the arc covers, as a path length.
  */
 export declare class HelixHeadlessMeter extends HelixElement {
-    /**
-     * Accessible name for the reading.
-     */
-    label: string;
-    /**
-     * Bottom of the range.
-     */
-    min: number;
-    /**
-     * Top of the range.
-     *
-     * A hundred rather than the platform's one, which is what `Progress` already
-     * takes and what a consumer writing `value="72"` means. A range of zero to one
-     * is a fraction, and a component that reads `value="72"` as seventy-two times
-     * over its maximum is a trap that costs nothing to avoid.
-     */
-    max: number;
-    /**
-     * Where the reading sits between `min` and `max`.
-     *
-     * Outside them, it clamps.
-     */
-    value: number;
-    /**
-     * Top of the low band.
-     *
-     * Absent leaves the range unbanded.
-     */
-    low?: number;
-    /**
-     * Bottom of the high band.
-     *
-     * Absent leaves the range unbanded.
-     */
-    high?: number;
-    /**
-     * Where in the range it is best to be.
-     *
-     * Defaults to the middle of whatever bands are declared, which is the
-     * platform's own default and the right one for a score. A meter where low is
-     * good, like disk usage, says `optimum="0"`; one where high is good, like a
-     * battery, says `optimum="100"`.
-     */
-    optimum?: number;
     /**
      * The band, said outright, where the three thresholds cannot say it.
      *
@@ -121,10 +77,47 @@ export declare class HelixHeadlessMeter extends HelixElement {
      *
      * Not reflected. Nothing selects on it: the band reaches the stylesheet as
      * `data-band` on the fill, because that is the element being colored, so
-     * reflecting here would write an attribute onto the host for no reader. Third
-     * time this rule has caught something today.
+     * reflecting here would write an attribute onto the host for no reader.
      */
     band?: MeterBand;
+    /**
+     * Bottom of the high band.
+     *
+     * Absent leaves the range unbanded.
+     */
+    high?: number;
+    /**
+     * Accessible name for the reading.
+     */
+    label: string;
+    /**
+     * Top of the low band.
+     *
+     * Absent leaves the range unbanded.
+     */
+    low?: number;
+    /**
+     * Top of the range.
+     *
+     * A hundred rather than the platform's one, which is what `Progress` already
+     * takes and what a consumer writing `value="72"` means. A range of zero to one
+     * is a fraction, and a component that reads `value="72"` as seventy-two times
+     * over its maximum is a trap that costs nothing to avoid.
+     */
+    max: number;
+    /**
+     * Bottom of the range.
+     */
+    min: number;
+    /**
+     * Where in the range it is best to be.
+     *
+     * Defaults to the middle of whatever bands are declared, which is the
+     * platform's own default and the right one for a score. A meter where low is
+     * good, like disk usage, says `optimum="0"`; one where high is good, like a
+     * battery, says `optimum="100"`.
+     */
+    optimum?: number;
     /**
      * Whether the reading is drawn as a bar, a ring or an arc.
      *
@@ -148,6 +141,12 @@ export declare class HelixHeadlessMeter extends HelixElement {
      * Whether the reading is shown beside the bar.
      */
     showValue: boolean;
+    /**
+     * Where the reading sits between `min` and `max`.
+     *
+     * Outside them, it clamps.
+     */
+    value: number;
     /**
      * What the reading says, where a number is not the whole story.
      *
@@ -170,15 +169,12 @@ export declare class HelixHeadlessMeter extends HelixElement {
     /**
      * Where the value really sits, which is what the words report.
      *
-     * **A value past the end used to be swallowed twice.** The bar filled and the
-     * reading said "100%", so 110 and 250 were indistinguishable from exactly
-     * full, measured. A meter that cannot say "you are over" is worse than no
-     * meter for the one case anybody checks it in, and it is the same fault as a
-     * pagination reporting a page it is not on: the number shown and the number
-     * given disagree, quietly.
+     * **Unclamped, so a value past the end is not swallowed.** Clamped as well as
+     * the bar is, 110 and 250 read as exactly full, and a meter that cannot say
+     * "you are over" is worse than no meter for the one case anybody checks it in.
      *
      * The bar still stops at its end, because that is what an end is. The words
-     * and the accessible reading carry the truth, and `data-over` is on the fill
+     * and the accessible reading carry the truth, and `data-beyond` is on the fill
      * so a consumer can say more about it.
      */
     private get ratio();

package/dist/meter/root/meter-root.js

@@ -64,10 +64,6 @@ let HelixHeadlessMeter = class HelixHeadlessMeter extends HelixElement {
          * Accessible name for the reading.
          */
         this.label = 'Meter';
-        /**
-         * Bottom of the range.
-         */
-        this.min = 0;
         /**
          * Top of the range.
          *
@@ -78,15 +74,19 @@ let HelixHeadlessMeter = class HelixHeadlessMeter extends HelixElement {
          */
         this.max = 100;
         /**
-         * Where the reading sits between `min` and `max`.
-         *
-         * Outside them, it clamps.
+         * Bottom of the range.
          */
-        this.value = 0;
+        this.min = 0;
         /**
          * Whether the reading is shown beside the bar.
          */
         this.showValue = false;
+        /**
+         * Where the reading sits between `min` and `max`.
+         *
+         * Outside them, it clamps.
+         */
+        this.value = 0;
         /**
          * What the reading says, where a number is not the whole story.
          *
@@ -120,15 +120,12 @@ let HelixHeadlessMeter = class HelixHeadlessMeter extends HelixElement {
     /**
      * Where the value really sits, which is what the words report.
      *
-     * **A value past the end used to be swallowed twice.** The bar filled and the
-     * reading said "100%", so 110 and 250 were indistinguishable from exactly
-     * full, measured. A meter that cannot say "you are over" is worse than no
-     * meter for the one case anybody checks it in, and it is the same fault as a
-     * pagination reporting a page it is not on: the number shown and the number
-     * given disagree, quietly.
+     * **Unclamped, so a value past the end is not swallowed.** Clamped as well as
+     * the bar is, 110 and 250 read as exactly full, and a meter that cannot say
+     * "you are over" is worse than no meter for the one case anybody checks it in.
      *
      * The bar still stops at its end, because that is what an end is. The words
-     * and the accessible reading carry the truth, and `data-over` is on the fill
+     * and the accessible reading carry the truth, and `data-beyond` is on the fill
      * so a consumer can say more about it.
      */
     get ratio() {
@@ -195,8 +192,6 @@ let HelixHeadlessMeter = class HelixHeadlessMeter extends HelixElement {
         this.internals.ariaValueMin = String(min);
         this.internals.ariaValueMax = String(max);
         this.internals.ariaValueNow = String(this.reading);
-        /* Spoken instead of the number wherever the consumer gave words, which is
-           what `value-text` is for: "18 GB of 32 GB" rather than "56". */
         /* The consumer's words where they gave any, and otherwise nothing at all
            *unless* the value is past an end. `ariaValueNow` has to sit inside the
            range, so it is the only place a reader can be told that 250 is not 100. */
@@ -279,34 +274,34 @@ let HelixHeadlessMeter = class HelixHeadlessMeter extends HelixElement {
 };
 __decorate([
     property()
-], HelixHeadlessMeter.prototype, "label", void 0);
+], HelixHeadlessMeter.prototype, "band", void 0);
 __decorate([
     property({ type: Number })
-], HelixHeadlessMeter.prototype, "min", void 0);
+], HelixHeadlessMeter.prototype, "high", void 0);
 __decorate([
-    property({ type: Number })
-], HelixHeadlessMeter.prototype, "max", void 0);
+    property()
+], HelixHeadlessMeter.prototype, "label", void 0);
 __decorate([
     property({ type: Number })
-], HelixHeadlessMeter.prototype, "value", void 0);
+], HelixHeadlessMeter.prototype, "low", void 0);
 __decorate([
     property({ type: Number })
-], HelixHeadlessMeter.prototype, "low", void 0);
+], HelixHeadlessMeter.prototype, "max", void 0);
 __decorate([
     property({ type: Number })
-], HelixHeadlessMeter.prototype, "high", void 0);
+], HelixHeadlessMeter.prototype, "min", void 0);
 __decorate([
     property({ type: Number })
 ], HelixHeadlessMeter.prototype, "optimum", void 0);
-__decorate([
-    property()
-], HelixHeadlessMeter.prototype, "band", void 0);
 __decorate([
     property({ reflect: true })
 ], HelixHeadlessMeter.prototype, "shape", void 0);
 __decorate([
     property({ attribute: 'show-value', reflect: true, type: Boolean })
 ], HelixHeadlessMeter.prototype, "showValue", void 0);
+__decorate([
+    property({ type: Number })
+], HelixHeadlessMeter.prototype, "value", void 0);
 __decorate([
     property({ attribute: 'value-text' })
 ], HelixHeadlessMeter.prototype, "valueText", void 0);

package/dist/navigation/root/navigation-root.js

@@ -41,10 +41,9 @@ import { property } from 'lit/decorators.js';
 let HelixHeadlessNavigation = class HelixHeadlessNavigation extends HelixElement {
     constructor() {
         super(...arguments);
-        /* The mark, and the RTL sign and border correction that came with it. This
-           was hand-written and had neither: the distance was measured from the
-           physical left and applied from the inline-start edge, so it traveled the
-           wrong way in a right-to-left document. */
+        /* The controller carries the RTL sign and border correction: a distance
+           measured from the physical left and applied from the inline-start edge
+           travels the wrong way in a right-to-left document. */
         this.indicator = new IndicatorController(this, {
             active: () => this.items.find((item) => item.getAttribute('aria-current') === 'page'),
             indicator: () => this.renderRoot?.querySelector('[part="indicator"]'),
@@ -64,20 +63,13 @@ let HelixHeadlessNavigation = class HelixHeadlessNavigation extends HelixElement
     watch() {
         this.observer?.disconnect();
         this.current?.disconnect();
-        /* Nothing is written onto the items any more.
-         *
-         * `data-navigation-item` used to be put here, because the base layer styled a
-         * destination with it and forgetting it was silent and total: the links
-         * kept working and came out as bare underlined anchors. Writing it fixed
-         * that and bought two problems. It happened after upgrade, so a
-         * server-rendered nav arrived unstyled and restyled itself a frame later;
-         * and a React consumer who wrote the attribute themselves got
-         * `data-navigation-item="true"` from JSX, which this then had to be careful not to
-         * overwrite or hydration reported a mismatch.
-         *
-         * The base layer selects `helix-navigation a` as well now, so the styling is
-         * true the moment the markup is parsed, on the server and on the client,
-         * and there is nothing to write or to be careful about. */
+        /* Nothing is written onto the items, and `data-navigation-item` must not be
+         * written here: it would land after upgrade, so a server-rendered nav would
+         * arrive unstyled and restyle itself a frame later, and a React consumer
+         * who wrote the attribute themselves gets `data-navigation-item="true"`
+         * from JSX, which overwriting reports as a hydration mismatch. The base
+         * layer selects `helix-navigation a`, so the styling is true the moment the
+         * markup is parsed, on the server and on the client. */
         this.indicator.place();
         this.observer = new ResizeObserver(() => this.indicator.place());
         this.observer.observe(this);
@@ -98,7 +90,7 @@ let HelixHeadlessNavigation = class HelixHeadlessNavigation extends HelixElement
      * a list left this permanently dead: the observer gone, nothing to rebuild
      * it, and the component still rendering as though it were watching. Guarded
      * on `hasUpdated`, because the first connection happens before the first
-     * render and there is nothing to watch yet. `check:observers` holds it. */
+     * render and there is nothing to watch yet. */
     connectedCallback() {
         super.connectedCallback();
         if (this.hasUpdated) {

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

@@ -73,18 +73,13 @@ export declare class HelixHeadlessNotification extends HelixElement {
      * changes nothing until a new value arrives. `default-read` seeds a state
      * this element then owns.
      *
-     * **Not reflected, and it was until 27 Aug 2026.** The reason given was that
-     * unread is a visual state and a stylesheet has no other way to know, which
-     * is the same reason the four mixins mirror theirs, and the mirror may not be
-     * the property's own attribute: `<helix-notification default-read>`
-     * came back from a server without `read` and gained it on the first update,
-     * which React reports as a hydration mismatch, and a copy of the serialized
-     * element re-parses that attribute as a declaration. `:state(read)` is what
-     * the stylesheet reads now. Found by `hydration.dom.spec.ts` on the day it
-     * learned to mount an element a consumer had configured rather than a bare
-     * one.
-     *
-     *
+     * **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.
+     * `hydration.dom.spec.ts` holds it.
      */
     get read(): boolean;
     set read(next: boolean);
@@ -96,16 +91,16 @@ export declare class HelixHeadlessNotification extends HelixElement {
      * Whether a reader may remove it.
      */
     dismissible: boolean;
+    /**
+     * Accessible name for the dismiss control.
+     */
+    dismissLabel: string;
     /**
      * Locale for the timestamp.
      *
      * Empty is the runtime's own.
      */
     locale: string;
-    /**
-     * Accessible name for the dismiss control.
-     */
-    dismissLabel: string;
     /**
      * @internal Read by the list to identify its children across the light DOM,
      * which is cheaper than `instanceof` and is why this is public rather than
@@ -141,11 +136,11 @@ export declare class HelixHeadlessNotification extends HelixElement {
      * it.** A fallback answers a consumer and a seam answers the tier above, which
      * are different people: the styled tier wants an icon here, and with the slot
      * written inline the only way to change it is to reimplement the whole
-     * template. `check:fallbacks` holds that, and moving only the fallback out was
-     * not enough, which is the right rule: the slot is the thing a tier redraws.
+     * template. Moving only the fallback out is not enough: the slot is the thing
+     * a tier redraws.
      *
-     * **The mark is drawn rather than typed, which is what lets it align.** It was
-     * `&times;`, and a character is placed by its font rather than by its box:
+     * **The mark is drawn rather than typed, which is what lets it align.** A
+     * character such as `&times;` is placed by its font rather than by its box:
      * measured against the ghost button beside it at 8x, the cross carried 6
      * pixels of ink to the label's 9.5 and sat 1.5 pixels below its center, in two
      * boxes whose own centers agreed to a tenth of a pixel. No stylesheet can
@@ -160,8 +155,7 @@ export declare class HelixHeadlessNotification extends HelixElement {
      *
      * The tag is interpolated rather than written, so each tier renders its own:
      * the base tier may not name a styled element, and a styled item inherits this
-     * template without having a tag of its own to remind anybody. `check:composed`
-     * holds both halves.
+     * template without having a tag of its own to remind anybody.
      *
      * `exportparts` and no `part` of its own, which is the rule about a part
      * already named for its role: the child publishes `time`, the role here is