@fusion.dev/helix-headless 0.51.0 → 0.52.0

package/custom-elements.json

@@ -9988,7 +9988,7 @@
                   }
                 }
               ],
-              "description": "The leading padding the track keeps for a slide to draw its own edge in.\n\nA styled track carries one so a slide's shadow and focus ring have\nsomewhere to go: a scroll container clips at its padding box, and a slide\nflush against that edge loses whatever it paints outside itself. The\nheadless tier has no stylesheet and so no padding, and this reads zero\nthere, which is why both tiers can share the arithmetic below.\n\nPhysical sides rather than logical, to match the physical `offsetLeft` and\n`offsetTop` it is subtracted from. The bleed is one length on all four\nsides, so the two agree whatever the writing mode; if that stops being\ntrue, this is the method that has to know."
+              "description": "The leading padding the track keeps for a slide to draw its own edge in.\n\nA styled track carries one so a slide's shadow and focus ring have\nsomewhere to go: a scroll container clips at its padding box, and a slide\nflush against that edge loses whatever it paints outside itself. The\nheadless tier has no stylesheet and so no padding, and this reads zero\nthere, which is why both tiers can share the arithmetic below.\n\nPhysical sides rather than logical, to match the physical `offsetLeft` and\n`offsetTop` it is subtracted from.\n\n**The side read is the side the track scrolls on, and not one side standing\nfor four.** They are one length on a track laid out at the defaults and\nstop being one the moment a consumer raises `--carousel-bleed`, which the\nhook exists to invite: a slide on `--helix-shadow-lg` reaches 44px and is\ntold to ask for it. So a horizontal track's room is its inline padding and\na vertical one's is its block padding, and each sheet puts the bleed where\nthe scroller clips. Reading one side for both would have a vertical track\nmeasuring a length nothing on its axis was laid out with."
             },
             {
               "kind": "method",
@@ -10594,7 +10594,7 @@
           "helix": {
             "category": "layout",
             "since": "0.1.0",
-            "status": "experimental",
+            "status": "stable",
             "documentation": "https://fusion.dev/helix/components/carousel",
             "aliases": [
               "Slider",
@@ -80928,7 +80928,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "**One axis, and nesting is how you get two.** A splitter inside a splitter\ngives back the cross, and gives the three-pane and four-pane arrangements a\nsingle divider never had.\n\n**Where two of them cross there is a corner, and it moves both.** A splitter\nslotted into a pane of another, at right angles to it, grows a handle at the\ncrossing: `move` under the pointer, both arrow axes on the keyboard, and a\ndrag that carries the two positions at once. It appears at `firstUpdated`\nrather than in the served markup, being an affordance rather than content,\nand a splitter with no corner yet is a splitter with two working dividers.\n\n**The divider is a real `role=\"separator\"` with `aria-valuenow`**, moved by\nthe arrow keys as well as by pointer, with `Home` and `End` taking it to its\nbounds. A drag in progress is a state rather than `:hover`, so both dividers\na corner moves are lit for as long as it moves them.\n\n**It goes where it is put, all the way to either end.** `min` and `max` are\nnothing and everything unless a consumer says otherwise, because a divider\nthat stops short of the edge gives a reader no way to put a pane away.\n\n**A pane can be shut, and that is not the same as a divider at the edge.**\nThe geometry is identical and the knowledge is not: only a shut pane knows\nwhere to open back to. So `collapsed` is a second state rather than a reading\nof the position, and the position it opens to is the one collapsing never\noverwrote. `collapsed-size` keeps a sliver showing where a pane has a tab\nstrip worth leaving, and collapse overrides `min` and `max`, which is what\nthose are for.",
+          "description": "**One axis, and nesting is how you get two.** A splitter inside a splitter\ngives back the cross, and gives the three-pane and four-pane arrangements a\nsingle divider never had.\n\n**Where two of them cross there is a corner, and it moves both.** A splitter\nslotted into a pane of another, at right angles to it, grows a handle at the\ncrossing: `move` under the pointer, both arrow axes on the keyboard, and a\ndrag that carries the two positions at once. It appears at `firstUpdated`\nrather than in the served markup, being an affordance rather than content,\nand a splitter with no corner yet is a splitter with two working dividers.\n\n**The divider is a real `role=\"separator\"` with `aria-valuenow`**, moved by\nthe arrow keys as well as by pointer, with `Home` and `End` taking it to its\nbounds. A drag in progress is a state rather than `:hover`, so both dividers\na corner moves are lit for as long as it moves them.\n\n**It goes where it is put, all the way to either end.** `min` and `max` are\nnothing and everything unless a consumer says otherwise, because a divider\nthat stops short of the edge gives a reader no way to put a pane away.\n\n**A pane can be shut, and that is not the same as a divider at the edge.**\nThe geometry is identical and the knowledge is not: only a shut pane knows\nwhere to open back to. So `collapsed` is a second state rather than a reading\nof the position, and the position it opens to is where the gesture that shut\nit began, whichever gesture that was: a drag takes its reading on the press,\nand every other door takes it in `settle`, nothing having been applied there\nyet. `collapsed-size` keeps a sliver showing where a pane has a tab strip\nworth leaving, and collapse overrides `min` and `max`, which is what those\nare for.",
           "name": "HelixHeadlessSplitter",
           "cssProperties": [
             {
@@ -81149,7 +81149,7 @@
               },
               "privacy": "private",
               "default": "undefined",
-              "description": "Where the divider was before the gesture that may be about to shut it.\n\nA drag writes a position on every pointer move, so by the time it reaches\nthe edge the number it started from is gone. Taken once, on the press, and\nwritten back if the gesture ends shut, so the pane opens to where it was\nrather than to the edge it was dragged against."
+              "description": "Where the divider was before the gesture that may be about to shut it.\n\nA drag writes a position on every pointer move, so by the time it reaches\nthe edge the number it started from is gone. Taken once, on the press, and\nwritten back if the gesture ends shut, so the pane opens to where it was\nrather than to the edge it was dragged against.\n\n**A pointer gesture only, because it is the only one that loses it**, and\n`settle` answers for the rest from `began`: a key and a double click apply\nnothing before they settle, so where the divider is at the top of that\nmethod is where it was. Read once and cleared there, exactly as `began` is,\nand for the second reason as well as the first. Left standing it measured\nthe next gesture against the last one's press, so a collapse pressed from\n20 reopened at the 60 a drag had started from an hour earlier."
             },
             {
               "kind": "field",
@@ -81399,7 +81399,7 @@
                   }
                 }
               ],
-              "description": "Says the arrangement has settled, so a consumer can keep it.\n\nThrough the audited path, so a consumer who owns `position` is told what was\nasked for and decides, and one who does not has already had it applied.\n\n**A refused resize ends the resize and not the gesture.** `shutAt` reads the\nposition the gesture ended on, so the collapse is computed from a number the\nconsumer may have declined, and the reading this replaces was that the two\nare therefore one decision: refuse the first and the second cannot stand.\nThat is a reasonable thing to believe about a splitter nobody else owns, and\nit takes \"no\" to mean the gesture is over. What it misses is that a consumer\nwho owns the position refuses in order to *take* the decision, not to end\nit. The sandbox two folders away refuses every `helix-before-resize` from\nthe splitter inside it, re-announces the same move in its own vocabulary and\nwrites the answer back through `position`, which is what makes it the single\ndecision point; returning on its refusal left `panel-collapsed-size` inert\nthere, the shipped `with-a-panel` example measuring a 0px panel against the\n36 its summary promises. So the collapse is reached either way and is\nrefused, or not, on its own.\n\n**Which is honest because the collapse carries its own position.** A shut\npane sits at `collapsed-size`, which is where `position` reads it from once\n`collapsed` is set, and never at the number the resize named: refuse a drag\nto 100 on a splitter with `collapsed-size=\"10\"`, allow the collapse, and the\ndivider is at 90. Nothing writes the refused number either, `requestChange`\napplying nothing when it is refused and the collapse below writing the open\nposition back over whatever a drag had already drawn, so a consumer who says\nno to the position and yes to the collapse gets the pane shut and keeps the\nnumber they had to reopen to. The two coincide only where `collapsed-size`\nis zero, and the states differ even there: a shut pane knows where to open\nback to and a divider parked at the edge does not.\n\nRefusing the collapse alone still leaves the resize, which is the other way\nround and is coherent: the divider goes where the drag put it and the pane\nis not declared shut.\n\n**A gesture that moved nothing announces nothing, and this is the one place\nthat can say so.** A change carrying the position the divider already had\nrewrites a consumer's stored value from a gesture that moved nothing:\nharmless where the value round-trips exactly, and not where it does not,\nwhich is any consumer storing pixels and dividing by a box. The separator's\n`pointerup` held that as an early return of its own and was the only door\nwith one. There are five: the separator's pointer and arrows, the corner's\npointer and arrows, and a double click through `reset`, and `moveTo` is a\nsixth a consumer can open. Measured in Chromium 17 Sep 2026 on the built\nbundle, every door but the guarded one announced a move of zero: a corner\npress with nothing between announced on both splitters, `Home` on a divider\nalready at its minimum announced, and a double click on one already at its\ndefault announced.\n\n**Measured against where the gesture began, and not against `position`.**\n`move` applies as it goes, so by the time a drag settles the position is\nalready the number about to be announced, and comparing those two would\nsilence every drag there is. `began` is the press; a discrete path takes\nnone and compares against the position, which for it is the same thing.\n\n**Per divider rather than per gesture, which is the corner's question.** The\ncorner drives two at once, so \"moved nothing\" cannot mean \"neither moved\":\na drag along one axis moves one of them, and the other would be announcing\na number nobody asked to change. Each settles on its own and guards on its\nown, so the one that moved still announces while the one that did not stays\nquiet. That is also why the guard cannot live in `handleCornerUp`, which\nonly ever sees the pair.\n\n**The collapse counts as movement, because a refusal can leave the two\ndisagreeing.** A consumer who refuses `helix-before-collapse` has a pane at\nthe edge that is not declared shut, and a guard reading the position alone\nwould then never offer the collapse again: `Home` is already at the\nminimum, so every later press is a move of zero."
+              "description": "Says the arrangement has settled, so a consumer can keep it.\n\nThrough the audited path, so a consumer who owns `position` is told what was\nasked for and decides, and one who does not has already had it applied.\n\n**A refused resize ends the resize and not the gesture.** `shutAt` reads the\nposition the gesture ended on, so the collapse is computed from a number the\nconsumer may have declined, and the reading this replaces was that the two\nare therefore one decision: refuse the first and the second cannot stand.\nThat is a reasonable thing to believe about a splitter nobody else owns, and\nit takes \"no\" to mean the gesture is over. What it misses is that a consumer\nwho owns the position refuses in order to *take* the decision, not to end\nit. The sandbox two folders away refuses every `helix-before-resize` from\nthe splitter inside it, re-announces the same move in its own vocabulary and\nwrites the answer back through `position`, which is what makes it the single\ndecision point; returning on its refusal left `panel-collapsed-size` inert\nthere, the shipped `with-a-panel` example measuring a 0px panel against the\n36 it asks for. So the collapse is reached either way and is refused, or\nnot, on its own.\n\n**Which is honest because the collapse carries its own position.** A shut\npane sits at `collapsed-size`, which is where `position` reads it from once\n`collapsed` is set, and never at the number the resize named: refuse a drag\nto 100 on a splitter with `collapsed-size=\"10\"`, allow the collapse, and the\ndivider is at 90. Nothing writes the refused number either, `requestChange`\napplying nothing when it is refused and the collapse below writing the open\nposition back over whatever a drag had already drawn, so a consumer who says\nno to the position and yes to the collapse gets the pane shut and keeps the\nnumber they had to reopen to. The two coincide only where `collapsed-size`\nis zero, and the states differ even there: a shut pane knows where to open\nback to and a divider parked at the edge does not.\n\nRefusing the collapse alone still leaves the resize, which is the other way\nround and is coherent: the divider goes where the drag put it and the pane\nis not declared shut.\n\n**The open position is taken here for every door but the pointer's, which\nis the same split `began` makes and for the same reason.** A drag has\noverwritten the position on the way to the edge, so it reads it on the\npress; a key, a double click and `moveTo` apply nothing until the request\nbelow, so where the divider is at the top of this method is where it was.\nCaptured on the press alone, the class docstring's promise that a shut pane\nknows where to open back to held for a drag and for nothing else: measured\n17 Sep 2026, `Home` on a splitter resting at 60 shut the start pane and\nreopened it at 0, the resize above having written the edge and the collapse\nhaving nothing to put back. Stale, it was worse than absent, `opened` never\nbeing cleared: a press at 60, then a key collapse from 20, reopened at 60.\n\n**A gesture that moved nothing announces nothing, and this is the one place\nthat can say so.** A change carrying the position the divider already had\nrewrites a consumer's stored value from a gesture that moved nothing:\nharmless where the value round-trips exactly, and not where it does not,\nwhich is any consumer storing pixels and dividing by a box. The separator's\n`pointerup` held that as an early return of its own and was the only door\nwith one. There are five: the separator's pointer and arrows, the corner's\npointer and arrows, and a double click through `reset`, and `moveTo` is a\nsixth a consumer can open. Measured in Chromium 17 Sep 2026 on the built\nbundle, every door but the guarded one announced a move of zero: a corner\npress with nothing between announced on both splitters, `Home` on a divider\nalready at its minimum announced, and a double click on one already at its\ndefault announced.\n\n**Measured against where the gesture began, and not against `position`.**\n`move` applies as it goes, so by the time a drag settles the position is\nalready the number about to be announced, and comparing those two would\nsilence every drag there is. `began` is the press; a discrete path takes\nnone and compares against the position, which for it is the same thing.\n\n**Per divider rather than per gesture, which is the corner's question.** The\ncorner drives two at once, so \"moved nothing\" cannot mean \"neither moved\":\na drag along one axis moves one of them, and the other would be announcing\na number nobody asked to change. Each settles on its own and guards on its\nown, so the one that moved still announces while the one that did not stays\nquiet. That is also why the guard cannot live in `handleCornerUp`, which\nonly ever sees the pair.\n\n**The collapse counts as movement, because a refusal can leave the two\ndisagreeing.** A consumer who refuses `helix-before-collapse` has a pane at\nthe edge that is not declared shut, and a guard reading the position alone\nwould then never offer the collapse again: `Home` is already at the\nminimum, so every later press is a move of zero."
             },
             {
               "kind": "field",
@@ -82021,7 +82021,7 @@
           "helix": {
             "category": "layout",
             "since": "0.1.0",
-            "status": "experimental",
+            "status": "stable",
             "documentation": "https://fusion.dev/helix/components/splitter",
             "aliases": [
               "SplitPane",

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

@@ -20,7 +20,7 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * performs, and it is first in the tab order.
  *
  * @since 0.1.0
- * @status experimental
+ * @status stable
  * @category layout
  * @aliases Slider, Gallery, Slideshow
  * @documentation https://fusion.dev/helix/components/carousel
@@ -390,9 +390,16 @@ export declare class HelixHeadlessCarousel extends HelixElement {
      * there, which is why both tiers can share the arithmetic below.
      *
      * Physical sides rather than logical, to match the physical `offsetLeft` and
-     * `offsetTop` it is subtracted from. The bleed is one length on all four
-     * sides, so the two agree whatever the writing mode; if that stops being
-     * true, this is the method that has to know.
+     * `offsetTop` it is subtracted from.
+     *
+     * **The side read is the side the track scrolls on, and not one side standing
+     * for four.** They are one length on a track laid out at the defaults and
+     * stop being one the moment a consumer raises `--carousel-bleed`, which the
+     * hook exists to invite: a slide on `--helix-shadow-lg` reaches 44px and is
+     * told to ask for it. So a horizontal track's room is its inline padding and
+     * a vertical one's is its block padding, and each sheet puts the bleed where
+     * the scroller clips. Reading one side for both would have a vertical track
+     * measuring a length nothing on its axis was laid out with.
      */
     private bleed;
     /**

package/dist/carousel/root/carousel-root.js

@@ -297,15 +297,14 @@ let HelixHeadlessCarousel = class HelixHeadlessCarousel extends HelixElement {
     }
     updated(changed) {
         super.updated(changed);
-        const count = this.slides.length;
         const drawn = this.renderRoot.querySelectorAll('[part="slide"]').length;
         if (changed.has('index') || (this.scrolledFor === 0 && drawn > 0)) {
             this.scrollToIndex();
         }
         this.scrolledFor = drawn;
         this.runTimer();
-        if (count > 0 && this.index > count - 1) {
-            this.goTo(count - 1);
+        if (this.slides.length > 0 && this.index > this.positions - 1) {
+            this.goTo(this.positions - 1);
         }
         this.watchPane();
         this.assign();

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

@@ -27,13 +27,15 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * **A pane can be shut, and that is not the same as a divider at the edge.**
  * The geometry is identical and the knowledge is not: only a shut pane knows
  * where to open back to. So `collapsed` is a second state rather than a reading
- * of the position, and the position it opens to is the one collapsing never
- * overwrote. `collapsed-size` keeps a sliver showing where a pane has a tab
- * strip worth leaving, and collapse overrides `min` and `max`, which is what
- * those are for.
+ * of the position, and the position it opens to is where the gesture that shut
+ * it began, whichever gesture that was: a drag takes its reading on the press,
+ * and every other door takes it in `settle`, nothing having been applied there
+ * yet. `collapsed-size` keeps a sliver showing where a pane has a tab strip
+ * worth leaving, and collapse overrides `min` and `max`, which is what those
+ * are for.
  *
  * @since 0.1.0
- * @status experimental
+ * @status stable
  * @category layout
  * @aliases SplitPane, Resizable, SplitView
  * @documentation https://fusion.dev/helix/components/splitter
@@ -181,6 +183,14 @@ export declare class HelixHeadlessSplitter extends HelixElement {
      * the edge the number it started from is gone. Taken once, on the press, and
      * written back if the gesture ends shut, so the pane opens to where it was
      * rather than to the edge it was dragged against.
+     *
+     * **A pointer gesture only, because it is the only one that loses it**, and
+     * `settle` answers for the rest from `began`: a key and a double click apply
+     * nothing before they settle, so where the divider is at the top of that
+     * method is where it was. Read once and cleared there, exactly as `began` is,
+     * and for the second reason as well as the first. Left standing it measured
+     * the next gesture against the last one's press, so a collapse pressed from
+     * 20 reopened at the 60 a drag had started from an hour earlier.
      */
     private opened;
     /**
@@ -343,8 +353,8 @@ export declare class HelixHeadlessSplitter extends HelixElement {
      * writes the answer back through `position`, which is what makes it the single
      * decision point; returning on its refusal left `panel-collapsed-size` inert
      * there, the shipped `with-a-panel` example measuring a 0px panel against the
-     * 36 its summary promises. So the collapse is reached either way and is
-     * refused, or not, on its own.
+     * 36 it asks for. So the collapse is reached either way and is refused, or
+     * not, on its own.
      *
      * **Which is honest because the collapse carries its own position.** A shut
      * pane sits at `collapsed-size`, which is where `position` reads it from once
@@ -362,6 +372,18 @@ export declare class HelixHeadlessSplitter extends HelixElement {
      * round and is coherent: the divider goes where the drag put it and the pane
      * is not declared shut.
      *
+     * **The open position is taken here for every door but the pointer's, which
+     * is the same split `began` makes and for the same reason.** A drag has
+     * overwritten the position on the way to the edge, so it reads it on the
+     * press; a key, a double click and `moveTo` apply nothing until the request
+     * below, so where the divider is at the top of this method is where it was.
+     * Captured on the press alone, the class docstring's promise that a shut pane
+     * knows where to open back to held for a drag and for nothing else: measured
+     * 17 Sep 2026, `Home` on a splitter resting at 60 shut the start pane and
+     * reopened it at 0, the resize above having written the edge and the collapse
+     * having nothing to put back. Stale, it was worse than absent, `opened` never
+     * being cleared: a press at 60, then a key collapse from 20, reopened at 60.
+     *
      * **A gesture that moved nothing announces nothing, and this is the one place
      * that can say so.** A change carrying the position the divider already had
      * rewrites a consumer's stored value from a gesture that moved nothing:

package/dist/splitter/root/splitter-root.js

@@ -302,6 +302,8 @@ let HelixHeadlessSplitter = HelixHeadlessSplitter_1 = class HelixHeadlessSplitte
         const shut = this.shutAt(wanted);
         const began = this.began ?? this.position;
         this.began = undefined;
+        const opened = this.opened ?? (this.collapsed ? undefined : began);
+        this.opened = undefined;
         if (wanted === began && shut === this.collapsed) {
             return;
         }
@@ -319,8 +321,8 @@ let HelixHeadlessSplitter = HelixHeadlessSplitter_1 = class HelixHeadlessSplitte
             requestChange({
                 apply: (value) => {
                     const previous = this.collapsed;
-                    if (value !== '' && this.opened !== undefined) {
-                        this.positionState = this.opened;
+                    if (value !== '' && opened !== undefined) {
+                        this.positionState = opened;
                     }
                     this.collapsedState = value === '' ? 'none' : value;
                     this.requestUpdate('collapsed', previous);

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.51.0",
+  "version": "0.52.0",
   "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.51.0",
-    "@fusion.dev/helix-icons": "0.51.0",
+    "@fusion.dev/helix-core": "0.52.0",
+    "@fusion.dev/helix-icons": "0.52.0",
     "uqr": "^0.1.3"
   },
   "devDependencies": {
     "@custom-elements-manifest/analyzer": "^0.11.0",
-    "@fusion.dev/helix-cem": "0.51.0",
-    "@fusion.dev/helix-testing": "0.51.0",
+    "@fusion.dev/helix-cem": "0.52.0",
+    "@fusion.dev/helix-testing": "0.52.0",
     "@fusion.dev/scripts": "0.0.0-dev",
     "@happy-dom/global-registrator": "^20.0.0",
     "@lit-labs/ssr": "^4.1.0",

package/types/jsx.d.ts

@@ -31187,10 +31187,12 @@ export type CustomElements = {
    * **A pane can be shut, and that is not the same as a divider at the edge.**
    * The geometry is identical and the knowledge is not: only a shut pane knows
    * where to open back to. So `collapsed` is a second state rather than a reading
-   * of the position, and the position it opens to is the one collapsing never
-   * overwrote. `collapsed-size` keeps a sliver showing where a pane has a tab
-   * strip worth leaving, and collapse overrides `min` and `max`, which is what
-   * those are for.
+   * of the position, and the position it opens to is where the gesture that shut
+   * it began, whichever gesture that was: a drag takes its reading on the press,
+   * and every other door takes it in `settle`, nothing having been applied there
+   * yet. `collapsed-size` keeps a sliver showing where a pane has a tab strip
+   * worth leaving, and collapse overrides `min` and `max`, which is what those
+   * are for.
    *
    * ## Attributes & Properties
    *
@@ -49269,10 +49271,12 @@ export type CustomElementsSolidJs = {
    * **A pane can be shut, and that is not the same as a divider at the edge.**
    * The geometry is identical and the knowledge is not: only a shut pane knows
    * where to open back to. So `collapsed` is a second state rather than a reading
-   * of the position, and the position it opens to is the one collapsing never
-   * overwrote. `collapsed-size` keeps a sliver showing where a pane has a tab
-   * strip worth leaving, and collapse overrides `min` and `max`, which is what
-   * those are for.
+   * of the position, and the position it opens to is where the gesture that shut
+   * it began, whichever gesture that was: a drag takes its reading on the press,
+   * and every other door takes it in `settle`, nothing having been applied there
+   * yet. `collapsed-size` keeps a sliver showing where a pane has a tab strip
+   * worth leaving, and collapse overrides `min` and `max`, which is what those
+   * are for.
    *
    * ## Attributes & Properties
    *

package/types/vue.d.ts

@@ -9793,7 +9793,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixHeadlessSpeedDialVueProps,
     HelixHeadlessSpeedDialVueEvents
   >;
-  /** **One axis, and nesting is how you get two.** A splitter inside a splitter gives back the cross, and gives the three-pane and four-pane arrangements a single divider never had.  **Where two of them cross there is a corner, and it moves both.** A splitter slotted into a pane of another, at right angles to it, grows a handle at the crossing: 'move' under the pointer, both arrow axes on the keyboard, and a drag that carries the two positions at once. It appears at 'firstUpdated' rather than in the served markup, being an affordance rather than content, and a splitter with no corner yet is a splitter with two working dividers.  **The divider is a real 'role="separator"' with 'aria-valuenow'**, moved by the arrow keys as well as by pointer, with 'Home' and 'End' taking it to its bounds. A drag in progress is a state rather than ':hover', so both dividers a corner moves are lit for as long as it moves them.  **It goes where it is put, all the way to either end.** 'min' and 'max' are nothing and everything unless a consumer says otherwise, because a divider that stops short of the edge gives a reader no way to put a pane away.  **A pane can be shut, and that is not the same as a divider at the edge.** The geometry is identical and the knowledge is not: only a shut pane knows where to open back to. So 'collapsed' is a second state rather than a reading of the position, and the position it opens to is the one collapsing never overwrote. 'collapsed-size' keeps a sliver showing where a pane has a tab strip worth leaving, and collapse overrides 'min' and 'max', which is what those are for. */
+  /** **One axis, and nesting is how you get two.** A splitter inside a splitter gives back the cross, and gives the three-pane and four-pane arrangements a single divider never had.  **Where two of them cross there is a corner, and it moves both.** A splitter slotted into a pane of another, at right angles to it, grows a handle at the crossing: 'move' under the pointer, both arrow axes on the keyboard, and a drag that carries the two positions at once. It appears at 'firstUpdated' rather than in the served markup, being an affordance rather than content, and a splitter with no corner yet is a splitter with two working dividers.  **The divider is a real 'role="separator"' with 'aria-valuenow'**, moved by the arrow keys as well as by pointer, with 'Home' and 'End' taking it to its bounds. A drag in progress is a state rather than ':hover', so both dividers a corner moves are lit for as long as it moves them.  **It goes where it is put, all the way to either end.** 'min' and 'max' are nothing and everything unless a consumer says otherwise, because a divider that stops short of the edge gives a reader no way to put a pane away.  **A pane can be shut, and that is not the same as a divider at the edge.** The geometry is identical and the knowledge is not: only a shut pane knows where to open back to. So 'collapsed' is a second state rather than a reading of the position, and the position it opens to is where the gesture that shut it began, whichever gesture that was: a drag takes its reading on the press, and every other door takes it in 'settle', nothing having been applied there yet. 'collapsed-size' keeps a sliver showing where a pane has a tab strip worth leaving, and collapse overrides 'min' and 'max', which is what those are for. */
   "helix-headless-splitter": DefineCustomElement<
     HelixHeadlessSplitter,
     HelixHeadlessSplitterVueProps,