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

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

@@ -12,14 +12,14 @@ declare const HelixHeadlessSpeedDial_base: (new (...args: any[]) => import("@fus
  * `Menu` is built from the same pieces. What is not shared is what actually
  * differs: a dial has no submenus, no headers, no checkable rows and no long
  * list to type ahead through, and shipping it as an appearance of `Menu` would
- * have meant defining what a dial with a submenu in it does.
+ * mean defining what a dial with a submenu in it does.
  *
  * **The trigger is a control the consumer slots**, and the floating action
  * button is the usual one: `helix-icon-button` with `shape="circle"` and
- * `raised`. There is no `helix-fab` here, and the reason is worth stating,
- * because a component would have re-declared `emphasis`, `tone`, `label` and
- * a size around a control that already has all four. A round raised button is a
- * shape, and where it sits is `data-dock` in the base layer.
+ * `raised`. There is no `helix-fab`, because it would re-declare `emphasis`,
+ * `tone`, `label` and a size around a control that already has all four. A
+ * round raised button is a shape, and where it sits is `data-dock` in the base
+ * layer.
  *
  * **Nothing is reserved from the keyboard.** A menu that drills has to keep the
  * horizontal pair for going in and coming back; a dial goes nowhere, so all four
@@ -41,7 +41,6 @@ declare const HelixHeadlessSpeedDial_base: (new (...args: any[]) => import("@fus
  * @event {Event} toggle - Says the state moved, carrying `newState` and `oldState`.
  *
  * @csspart actions - The region the actions are drawn in.
- * @csspart icon - A glyph this component draws.
  * @csspart trigger - The default trigger, where none was slotted.
  */
 export declare class HelixHeadlessSpeedDial extends HelixHeadlessSpeedDial_base {
@@ -49,6 +48,10 @@ export declare class HelixHeadlessSpeedDial extends HelixHeadlessSpeedDial_base
      * Names the trigger and the set of actions it opens.
      */
     label: string;
+    /**
+     * Space between the trigger and the actions, in pixels.
+     */
+    offset: number;
     /**
      * Which way the actions fan out. They move if that side does not fit.
      *
@@ -56,10 +59,6 @@ export declare class HelixHeadlessSpeedDial extends HelixHeadlessSpeedDial_base
      * bottom of the window and there is nothing below it to fan into.
      */
     placement: Placement;
-    /**
-     * Space between the trigger and the actions, in pixels.
-     */
-    offset: number;
     protected readonly keys: KeyboardNavigationController;
     private readonly panel;
     /** Whatever the consumer slotted, or the button rendered in its place. */
@@ -85,18 +84,16 @@ export declare class HelixHeadlessSpeedDial extends HelixHeadlessSpeedDial_base
      * who will forget, and the failure is silent to everyone who can see the
      * screen.
      *
-     * **Every word of that survives; the mechanism does not.** This wrote
-     * `aria-expanded` and `aria-haspopup` onto the consumer's element with
-     * `setAttribute`, and measured against React 19.2.8 that is a hydration
-     * mismatch React reports and does not patch up. `tellDisclosure` carries the
-     * argument and the measurement: the state travels as a property now, into the
-     * trigger's own shadow root, where React neither looks nor compares.
+     * **Never `setAttribute`.** Writing `aria-expanded` onto the consumer's
+     * element is a hydration mismatch React reports and does not patch up,
+     * measured against React 19.2.8. `tellDisclosure` carries the argument and the
+     * measurement: the state travels as a property, into the trigger's own shadow
+     * root, where React neither looks nor compares.
      *
-     * `aria-haspopup` goes with it rather than being written separately. It is a
-     * constant, so it could stay an attribute without changing on every open, and
-     * an attribute the consumer's server never sent is a mismatch whether or not
-     * it moves afterwards: that was measured too, both load orders. A trigger that
-     * says it is expanded is already saying it has something to expand.
+     * `aria-haspopup` goes with it rather than being written separately. An
+     * attribute the consumer's server never sent is a mismatch whether or not it
+     * moves afterwards, measured in both load orders, and a trigger that says it
+     * is expanded is already saying it has something to expand.
      */
     private announce;
     protected updated(changed: PropertyValues): void;
@@ -106,10 +103,9 @@ export declare class HelixHeadlessSpeedDial extends HelixHeadlessSpeedDial_base
      * **This is the case the tier rule blocks and a render method unblocks.** A
      * bare `<button>` is what the headless tier can write: it must not reach for
      * `helix-button`, which lives a tier above and would make `headless` depend
-     * on `web`. So the base draws the plain control and a tier that has buttons
-     * of its own overrides this to use one, which is the whole shape #76 exists
-     * for. Written inline the only way to change it was to reimplement the
-     * template, panel and all.
+     * on `styled`. So the base draws the plain control and a tier that has buttons
+     * of its own overrides this to use one. Written inline, the only way
+     * to change it would be to reimplement the template, panel and all.
      */
     protected renderTrigger(): TemplateResult;
     protected render(): TemplateResult;

package/dist/speed-dial/root/speed-dial-root.js

@@ -19,14 +19,14 @@ import { property } from 'lit/decorators.js';
  * `Menu` is built from the same pieces. What is not shared is what actually
  * differs: a dial has no submenus, no headers, no checkable rows and no long
  * list to type ahead through, and shipping it as an appearance of `Menu` would
- * have meant defining what a dial with a submenu in it does.
+ * mean defining what a dial with a submenu in it does.
  *
  * **The trigger is a control the consumer slots**, and the floating action
  * button is the usual one: `helix-icon-button` with `shape="circle"` and
- * `raised`. There is no `helix-fab` here, and the reason is worth stating,
- * because a component would have re-declared `emphasis`, `tone`, `label` and
- * a size around a control that already has all four. A round raised button is a
- * shape, and where it sits is `data-dock` in the base layer.
+ * `raised`. There is no `helix-fab`, because it would re-declare `emphasis`,
+ * `tone`, `label` and a size around a control that already has all four. A
+ * round raised button is a shape, and where it sits is `data-dock` in the base
+ * layer.
  *
  * **Nothing is reserved from the keyboard.** A menu that drills has to keep the
  * horizontal pair for going in and coming back; a dial goes nowhere, so all four
@@ -48,7 +48,6 @@ import { property } from 'lit/decorators.js';
  * @event {Event} toggle - Says the state moved, carrying `newState` and `oldState`.
  *
  * @csspart actions - The region the actions are drawn in.
- * @csspart icon - A glyph this component draws.
  * @csspart trigger - The default trigger, where none was slotted.
  */
 let HelixHeadlessSpeedDial = class HelixHeadlessSpeedDial extends MixinControllerOpen(HelixElement) {
@@ -58,6 +57,10 @@ let HelixHeadlessSpeedDial = class HelixHeadlessSpeedDial extends MixinControlle
          * Names the trigger and the set of actions it opens.
          */
         this.label = 'Actions';
+        /**
+         * Space between the trigger and the actions, in pixels.
+         */
+        this.offset = 12;
         /**
          * Which way the actions fan out. They move if that side does not fit.
          *
@@ -65,10 +68,6 @@ let HelixHeadlessSpeedDial = class HelixHeadlessSpeedDial extends MixinControlle
          * bottom of the window and there is nothing below it to fan into.
          */
         this.placement = 'top-end';
-        /**
-         * Space between the trigger and the actions, in pixels.
-         */
-        this.offset = 12;
         /* Nothing reserved: see the note above. `selects` is false because arriving at
            Delete must not delete, which is the difference between a set of commands
            and a set of choices. */
@@ -141,18 +140,16 @@ let HelixHeadlessSpeedDial = class HelixHeadlessSpeedDial extends MixinControlle
      * who will forget, and the failure is silent to everyone who can see the
      * screen.
      *
-     * **Every word of that survives; the mechanism does not.** This wrote
-     * `aria-expanded` and `aria-haspopup` onto the consumer's element with
-     * `setAttribute`, and measured against React 19.2.8 that is a hydration
-     * mismatch React reports and does not patch up. `tellDisclosure` carries the
-     * argument and the measurement: the state travels as a property now, into the
-     * trigger's own shadow root, where React neither looks nor compares.
+     * **Never `setAttribute`.** Writing `aria-expanded` onto the consumer's
+     * element is a hydration mismatch React reports and does not patch up,
+     * measured against React 19.2.8. `tellDisclosure` carries the argument and the
+     * measurement: the state travels as a property, into the trigger's own shadow
+     * root, where React neither looks nor compares.
      *
-     * `aria-haspopup` goes with it rather than being written separately. It is a
-     * constant, so it could stay an attribute without changing on every open, and
-     * an attribute the consumer's server never sent is a mismatch whether or not
-     * it moves afterwards: that was measured too, both load orders. A trigger that
-     * says it is expanded is already saying it has something to expand.
+     * `aria-haspopup` goes with it rather than being written separately. An
+     * attribute the consumer's server never sent is a mismatch whether or not it
+     * moves afterwards, measured in both load orders, and a trigger that says it
+     * is expanded is already saying it has something to expand.
      */
     announce() {
         const trigger = this.trigger;
@@ -177,14 +174,11 @@ let HelixHeadlessSpeedDial = class HelixHeadlessSpeedDial extends MixinControlle
             this.updateComplete.then(() => {
                 if (this.open) {
                     /* The first action that can *take* focus, not the first action. A
-                       dial whose first item is disabled opened onto a row that refuses
-                       focus, so the reader landed nowhere and their first arrow key
-                       started from nothing.
-          
-                       `KeyboardNavigationController` has always filtered disabled items,
-                       which is why the arrows were fine and this was not: the audit read
-                       the fault into `items` and it was only ever here, at the one place
-                       that reaches past the controller and indexes the list itself. */
+                       dial whose first item is disabled otherwise opens onto a row that
+                       refuses focus, so the reader lands nowhere and their first arrow
+                       key starts from nothing. `KeyboardNavigationController` filters
+                       disabled items itself; this is the one place that reaches past it
+                       and indexes the list. */
                     this.items.find((one) => !one.disabled)?.focusItem();
                 }
             });
@@ -199,10 +193,9 @@ let HelixHeadlessSpeedDial = class HelixHeadlessSpeedDial extends MixinControlle
      * **This is the case the tier rule blocks and a render method unblocks.** A
      * bare `<button>` is what the headless tier can write: it must not reach for
      * `helix-button`, which lives a tier above and would make `headless` depend
-     * on `web`. So the base draws the plain control and a tier that has buttons
-     * of its own overrides this to use one, which is the whole shape #76 exists
-     * for. Written inline the only way to change it was to reimplement the
-     * template, panel and all.
+     * on `styled`. So the base draws the plain control and a tier that has buttons
+     * of its own overrides this to use one. Written inline, the only way
+     * to change it would be to reimplement the template, panel and all.
      */
     renderTrigger() {
         return html `<slot name="trigger" @click=${this.handleTriggerClick}>
@@ -214,10 +207,9 @@ let HelixHeadlessSpeedDial = class HelixHeadlessSpeedDial extends MixinControlle
         aria-label=${this.label}
       >
         ${
-        /* A glyph, because the fallback was an empty `<button>`: a consumer
-           who slots no trigger got a control with nothing in it, and a
-           floating action button whose whole job is to be found. `plus` is
-           what a speed dial opens with everywhere it exists. */
+        /* A glyph, so a consumer who slots no trigger does not get an empty
+           control for a button whose whole job is to be found. `plus` is what
+           a speed dial opens with everywhere it exists. */
         ''}
         ${drawIcon(plus)}
       </button>
@@ -239,12 +231,12 @@ let HelixHeadlessSpeedDial = class HelixHeadlessSpeedDial extends MixinControlle
 __decorate([
     property()
 ], HelixHeadlessSpeedDial.prototype, "label", void 0);
-__decorate([
-    property()
-], HelixHeadlessSpeedDial.prototype, "placement", void 0);
 __decorate([
     property({ type: Number })
 ], HelixHeadlessSpeedDial.prototype, "offset", void 0);
+__decorate([
+    property()
+], HelixHeadlessSpeedDial.prototype, "placement", void 0);
 HelixHeadlessSpeedDial = __decorate([
     customElement('helix-headless-speed-dial')
 ], HelixHeadlessSpeedDial);

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

@@ -18,11 +18,11 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * positions at once.
  *
  * **The outer splitter draws it and the nested one announces itself upward.**
- * Built the other way round first, because a splitter already knows where its
- * own divider begins and needs no measurement of the other, and that version was
- * clipped: the crossing lies on the boundary between a pane and the divider
+ * The nested one drawing its own is the tempting version, since it already
+ * knows where its divider begins and needs no measurement of the other, and it
+ * is clipped: the crossing lies on the boundary between a pane and the divider
  * beside it, a handle centered there reaches back over the boundary, and a pane
- * is `overflow: auto`. Exactly half the corner was cut off. The outer separator
+ * is `overflow: auto`. Exactly half the corner is cut off. The outer separator
  * is the one element that already straddles the seam, so the corner belongs in
  * it.
  *
@@ -122,48 +122,27 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  */
 export declare class HelixHeadlessSplitter extends HelixElement {
     /**
-     * Which way the panes are laid out.
-     *
-     * `horizontal` is side by side with an upright divider between them, and
-     * `aria-orientation` on that divider is therefore `vertical`: a separator's
-     * orientation is the direction it is *drawn* in, not the axis it moves along,
-     * so the two words are opposite each other here on purpose. The code had this
-     * right and the sentence beside it said the reverse.
-     *
-     * Unset is horizontal and stays unset, so a reflected default cannot appear on
-     * a host whose server output never had it.
-     *
-     * **`auto` lays the panes out along whichever axis the splitter has room for**,
-     * stacking them once its own inline size falls under `STACK_BELOW`. It is a
-     * value rather than a default because turning a splitter is not a style
-     * change: the drag axis, the arrow keys and `aria-orientation` all turn with
-     * it, so a CSS-only version would look stacked and behave side by side, with
-     * the keyboard moving the wrong way and the accessibility tree saying
-     * something untrue. Everything here reads `vertical` rather than this
-     * property, which is what makes one getter enough to turn all three together.
+     * How much of a shut pane is still shown, as a percentage.
      *
-     * **Its own width and not the viewport**, per the responsiveness policy in
-     * `.claude/rules/helix.md`: a splitter in a 300px panel of a 1400px window has
-     * no room for two panes side by side, and a media query would hand it the
-     * desktop branch. A `ResizeObserver` on the host asks the only question that
-     * has an honest answer.
+     * Zero by default, which is a pane fully gone. A tab strip or a title bar
+     * that should survive its own collapse says how much of itself to keep, and
+     * only whoever put it there knows that, which is the same reason `min` is a
+     * consumer's to set.
      */
-    orientation?: 'auto' | 'horizontal' | 'vertical';
+    collapsedSize: number;
     /**
      * Where the divider sits, as a percentage of the whole.
      *
      * Reading gives where it is; writing declares it the consumer's, and
      * `default-position` seeds one this element owns. The same accessor pair
      * `Pagination.page` and the calendar's `month` carry.
-     *
-     *
      */
     get position(): number;
     set position(next: number);
     /**
-     * Where the divider starts, where nothing declared it.
+     * Accessible name for the handle where two dividers cross.
      */
-    defaultPosition: number;
+    cornerLabel: string;
     /**
      * Which pane is shut, if either.
      *
@@ -176,8 +155,6 @@ export declare class HelixHeadlessSplitter extends HelixElement {
      *
      * It overrides `min` and `max`, which is the point of it. Those keep a sliver
      * of a pane during a drag; this is the thing that says the sliver can go.
-     *
-     *
      */
     get collapsed(): 'end' | 'start' | undefined;
     set collapsed(next: 'end' | 'start' | undefined);
@@ -186,14 +163,30 @@ export declare class HelixHeadlessSplitter extends HelixElement {
      */
     defaultCollapsed?: 'end' | 'start';
     /**
-     * How much of a shut pane is still shown, as a percentage.
+     * Where the divider starts, where nothing declared it.
+     */
+    defaultPosition: number;
+    /**
+     * Accessible name for the divider.
+     */
+    label: string;
+    /**
+     * Nearest it may come to the end, on the same terms as `min`.
+     */
+    max: number | string;
+    /**
+     * Either kind of bound as a percentage of the box.
      *
-     * Zero by default, which is a pane fully gone. A tab strip or a title bar
-     * that should survive its own collapse says how much of itself to keep, and
-     * only whoever put it there knows that, which is the same reason `min` is a
-     * consumer's to set.
+     * Measured rather than cached: a length is only meaningful against the size
+     * the splitter is right now, and the drag that asks is already reading layout.
+     * Falls back where there is nothing to measure, which is the server and an
+     * element that is not displayed, so `aria-valuemin` is a number either way.
      */
-    collapsedSize: number;
+    private toPercent;
+    /** `min` as a percentage, whichever way it was written. */
+    private get minPercent();
+    /** `max` as a percentage, whichever way it was written. */
+    private get maxPercent();
     /**
      * Nearest the divider may come to the start.
      *
@@ -215,34 +208,36 @@ export declare class HelixHeadlessSplitter extends HelixElement {
      */
     min: number | string;
     /**
-     * Nearest it may come to the end, on the same terms as `min`.
-     */
-    max: number | string;
-    /**
-     * Either kind of bound as a percentage of the box.
+     * Which way the panes are laid out.
      *
-     * Measured rather than cached: a length is only meaningful against the size
-     * the splitter is right now, and the drag that asks is already reading layout.
-     * Falls back where there is nothing to measure, which is the server and an
-     * element that is not displayed, so `aria-valuemin` is a number either way.
+     * `horizontal` is side by side with an upright divider between them, and
+     * `aria-orientation` on that divider is therefore `vertical`: a separator's
+     * orientation is the direction it is *drawn* in, not the axis it moves along,
+     * so the two words are opposite each other here on purpose.
+     *
+     * Unset is horizontal and stays unset, so a reflected default cannot appear on
+     * a host whose server output never had it.
+     *
+     * **`auto` lays the panes out along whichever axis the splitter has room for**,
+     * stacking them once its own inline size falls under `STACK_BELOW`. It is a
+     * value rather than a default because turning a splitter is not a style
+     * change: the drag axis, the arrow keys and `aria-orientation` all turn with
+     * it, so a CSS-only version would look stacked and behave side by side, with
+     * the keyboard moving the wrong way and the accessibility tree saying
+     * something untrue. Everything here reads `vertical` rather than this
+     * property, which is what makes one getter enough to turn all three together.
+     *
+     * **Its own width and not the viewport**, per the responsiveness policy in
+     * `.claude/rules/helix.md`: a splitter in a 300px panel of a 1400px window has
+     * no room for two panes side by side, and a media query would hand it the
+     * desktop branch. A `ResizeObserver` on the host asks the only question that
+     * has an honest answer.
      */
-    private toPercent;
-    /** `min` as a percentage, whichever way it was written. */
-    private get minPercent();
-    /** `max` as a percentage, whichever way it was written. */
-    private get maxPercent();
+    orientation?: 'auto' | 'horizontal' | 'vertical';
     /**
      * How far one arrow press moves it, as a percentage.
      */
     step: number;
-    /**
-     * Accessible name for the divider.
-     */
-    label: string;
-    /**
-     * Accessible name for the handle where two dividers cross.
-     */
-    cornerLabel: string;
     /** The position, whoever set it, and `undefined` until somebody has. */
     private positionState;
     /** The collapse, whoever set it, and `undefined` until somebody has. */
@@ -266,14 +261,12 @@ export declare class HelixHeadlessSplitter extends HelixElement {
      * The position to draw, which is not always the position to report.
      *
      * A controlled splitter applies nothing, so `position` holds still for the
-     * whole gesture and the divider stayed where it was until the pointer came up
-     * and the consumer answered: it jumped to the end rather than following the
-     * hand. Reported as resizing that was not seamless and did not work as it had.
+     * whole gesture: drawn from it, the divider stays where it was until the
+     * pointer comes up and the consumer answers, jumping to the end rather than
+     * following the hand.
      *
-     * So a drag draws itself. The number is not announced until it settles, which
-     * is the rule that has not changed, and the consumer's answer takes over the
-     * moment they give one. It is what the sandbox did for itself before it used
-     * this component: write the size on every pointer move, tell anyone once.
+     * So a drag draws itself. The number is still not announced until it settles,
+     * and the consumer's answer takes over the moment they give one.
      */
     private get showing();
     /**
@@ -329,17 +322,25 @@ export declare class HelixHeadlessSplitter extends HelixElement {
     /**
      * Whether the divider is against an edge with nothing beside it.
      *
-     * Geometry, not state, which is the second answer here: it asked whether the
-     * pane was `collapsed`, and a divider driven to the edge by a consumer setting
-     * `position` is just as flush and drew a line anyway. What the stylesheet
-     * needs to know is whether there is a pane on both sides, and that is a fact
-     * about where the divider is however it got there.
+     * Geometry, not state. Asking whether the pane is `collapsed` is the wrong
+     * question: a divider driven to the edge by a consumer setting `position` is
+     * just as flush and would still get a line drawn. What the stylesheet needs
+     * to know is whether there is a pane on both sides, which is a fact about
+     * where the divider is however it got there.
      *
      * Still not the same question as `collapsed`: a pane shut to a sliver has a
      * boundary worth drawing, and one shut to nothing has the container's own edge
      * there instead.
      */
     private get flush();
+    /**
+     * The collapse a settled position amounts to, if any, so a pane dragged shut
+     * and a pane shut by a consumer's button are the same state.
+     *
+     * No separate threshold. Landing on the collapsed size *is* the gesture, and
+     * `clamp` puts every overshoot exactly on the bound, so the default of zero
+     * latches on any drag that runs off the end.
+     */
     private shutAt;
     /** Pulled between the bounds, which are the ends unless a consumer moved them. */
     private clamp;
@@ -391,19 +392,12 @@ export declare class HelixHeadlessSplitter extends HelixElement {
      * for its bounds. The other two arrows are left alone and the page scrolls
      * under them as it would anywhere else.
      *
-     * *Corrected 18 Aug 2026. This said "both axes, always", on the reasoning
-     * `KeyboardNavigationController` uses for a set of items: a reader who guesses
-     * the wrong arrow gets nothing. The code has never done it, and measuring the
-     * three tab stops of a nested pair is what turned that up, so the prose was
-     * describing a decision nobody implemented.*
-     *
-     * *Leaving it as one axis, because nesting is what settles it. Taking all four
-     * would mean `ArrowLeft` moving a horizontal divider up and down, which is not
-     * a reader being helped past a guess, it is an arrow that does not go the way
-     * it points. And the guess it was protecting against is answered better by the
-     * corner: there, all four arrows are live and each moves the divider it points
-     * along, which is the only place in a splitter where a second axis means
-     * anything.*
+     * **Not all four, which is the tempting version.** Taking every arrow would
+     * mean `ArrowLeft` moving a horizontal divider up and down: not a reader
+     * being helped past a wrong guess, an arrow that does not go the way it
+     * points. A reader who guesses wrong is answered better by the corner, where
+     * all four are live and each moves the divider it points along, which is the
+     * only place in a splitter where a second axis means anything.
      */
     private readonly handleKeydown;
     /** Puts the divider back where the markup put it. */
@@ -412,10 +406,9 @@ export declare class HelixHeadlessSplitter extends HelixElement {
     /**
      * Both of them, because the corner moves both.
      *
-     * It needs its own handler now. Inside the separator this came free by
-     * bubbling, and moving the corner out to sit against the host for the stacking
-     * reason took the double click with it: the divider reset and the crossing
-     * did not. Reported.
+     * Its own handler, because the corner is a sibling of the separator rather
+     * than a child of it, for the stacking reason in the stylesheet, so nothing
+     * reaches the separator's own double click by bubbling.
      */
     private readonly handleCornerDoubleClick;
     /**
@@ -440,13 +433,11 @@ export declare class HelixHeadlessSplitter extends HelixElement {
      *
      * `parentElement` first, so a splitter does not find itself.
      *
-     * **By identity rather than by tag, which `closestInstance` exists for and
-     * counts this file in its own documentation.** It matched
-     * `'helix-splitter, helix-headless-splitter'`, and only `@fusion.dev/helix` registers
-     * the first of those: a headless package naming a styled one by string. Under
-     * any third tag, which is exactly what subclassing a headless element is for and
-     * what `helix/styled` itself does, the lookup returned null and a nested
-     * splitter had no corner, with no error anywhere.
+     * **By identity rather than by tag, which is what `closestInstance` exists
+     * for.** A selector like `'helix-splitter, helix-headless-splitter'` names a
+     * styled tag from a headless package and misses any third tag, which is
+     * exactly what subclassing a headless element produces: the lookup returns
+     * null, the nested splitter gets no corner, and nothing reports an error.
      *
      * It also crosses shadow boundaries, which `closest` does not: a splitter
      * slotted into another component's shadow root has a `parentNode` chain
@@ -467,18 +458,14 @@ export declare class HelixHeadlessSplitter extends HelixElement {
     /**
      * Keeps a gesture on the corner to itself.
      *
-     * The corner was a child of the separator first, and every one of its events
-     * bubbled there, so the separator started its own drag from the same press.
-     * That is worse than moving twice: the separator calls `setPointerCapture`,
-     * which retargets every later pointer event to *it*, so the corner's
-     * `pointerup` never arrived, its origin was never cleared, and it went on
-     * resizing with no button held. Reported as resizing without a press.
-     *
-     * The corner is a sibling now, for the stacking reason in the stylesheet, so
-     * nothing reaches the separator by bubbling. This stays because the fix should
-     * not depend on where the element happens to sit, and `preventDefault` is
-     * still needed either way: a drag across a pane would otherwise select the
-     * text under it.
+     * The stop is not redundant with the corner being a sibling of the separator.
+     * Should a press on the corner ever reach the separator, the separator calls
+     * `setPointerCapture`, which retargets every later pointer event to *it*: the
+     * corner's `pointerup` never arrives, its origin is never cleared, and it
+     * goes on resizing with no button held. Worse than moving twice.
+     *
+     * `preventDefault` is needed either way: a drag across a pane would otherwise
+     * select the text under it.
      */
     private leaveSeparator;
     connectedCallback(): void;