@fusion.dev/helix-headless 0.51.0 → 0.52.1

package/custom-elements.json

@@ -2350,7 +2350,7 @@
               "type": {
                 "text": "Curve | undefined"
               },
-              "description": "How a band's edge gets from one reading to the next.\n\nThree values, and the class doc argues for each: `straight` is absent and\nis the default, `smooth` is for a stack read as a shape and is the one that\ncan draw a part as less than nothing, `step` is for a quantity that changes\nat a moment and is ordered the way `straight` is.\n\nAbsent rather than defaulted because a reflecting property with a default\nwrites its attribute onto every host, including the ones nobody configured.",
+              "description": "How a band's edge gets from one reading to the next.\n\nThree values, and the class doc argues for each: `straight` is absent and\nis the default, `smooth` is for a stack read as a shape and is the one that\ncan draw a part as less than nothing, `step` is for a quantity that changes\nat a moment and is ordered the way `straight` is.\n\nAbsent rather than defaulted because a reflecting property with a default\nwrites its attribute onto every host, including the ones nobody configured.\nThe resting value therefore lives in the render, as `curve ?? 'straight'`.\n\n**`LineChart` and `Sparkline` rest at `smooth` and are not disagreeing.** A\nline claims a position, so the bounded invention a monotone cubic makes is\na reading aid and costs nothing. A band claims an amount, and two sums\nsmoothed independently can cross, so the same aid here draws a part as less\nthan nothing. Same axis, different mark, different resting value.",
               "attribute": "curve",
               "reflects": true
             },
@@ -3136,7 +3136,7 @@
               "type": {
                 "text": "Curve | undefined"
               },
-              "description": "How a band's edge gets from one reading to the next.\n\nThree values, and the class doc argues for each: `straight` is absent and\nis the default, `smooth` is for a stack read as a shape and is the one that\ncan draw a part as less than nothing, `step` is for a quantity that changes\nat a moment and is ordered the way `straight` is.\n\nAbsent rather than defaulted because a reflecting property with a default\nwrites its attribute onto every host, including the ones nobody configured.",
+              "description": "How a band's edge gets from one reading to the next.\n\nThree values, and the class doc argues for each: `straight` is absent and\nis the default, `smooth` is for a stack read as a shape and is the one that\ncan draw a part as less than nothing, `step` is for a quantity that changes\nat a moment and is ordered the way `straight` is.\n\nAbsent rather than defaulted because a reflecting property with a default\nwrites its attribute onto every host, including the ones nobody configured.\nThe resting value therefore lives in the render, as `curve ?? 'straight'`.\n\n**`LineChart` and `Sparkline` rest at `smooth` and are not disagreeing.** A\nline claims a position, so the bounded invention a monotone cubic makes is\na reading aid and costs nothing. A band claims an amount, and two sums\nsmoothed independently can cross, so the same aid here draws a part as less\nthan nothing. Same axis, different mark, different resting value.",
               "fieldName": "curve"
             },
             {
@@ -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",
@@ -49864,7 +49864,7 @@
               "type": {
                 "text": "Curve | undefined"
               },
-              "description": "How the line gets from one reading to the next.\n\n**`smooth` is the resting curve.** A curve invents the values between two\nreadings, which is why `straight` still exists, but the invention is\nbounded: the interpolation is monotone cubic, so it never leaves the band\nthe data sets and never introduces a peak or a trough the series does not\nhave. Within that bound the smoothed line is the easier one to follow\nacross a long series, and `straight` becomes the deliberate claim.\n\n**Absent rather than defaulted on the property**, because a reflecting\nproperty with a default writes its attribute onto every host anybody\nrenders, including the ones nobody configured.\n`line-chart-root.ssr.spec.ts` asserts the host carries only what the\nconsumer wrote. The default therefore lives where the path is built, as\n`curve ?? 'smooth'`.\n\n`step` claims the opposite of both, that a reading holds until the next.",
+              "description": "How the line gets from one reading to the next.\n\n**`smooth` is the resting curve.** A curve invents the values between two\nreadings, which is why `straight` still exists, but the invention is\nbounded: the interpolation is monotone cubic, so it never leaves the band\nthe data sets and never introduces a peak or a trough the series does not\nhave. Within that bound the smoothed line is the easier one to follow\nacross a long series, and `straight` becomes the deliberate claim.\n\n**Absent rather than defaulted on the property**, because a reflecting\nproperty with a default writes its attribute onto every host anybody\nrenders, including the ones nobody configured.\n`line-chart-root.ssr.spec.ts` asserts the host carries only what the\nconsumer wrote. The default therefore lives where the path is built, as\n`curve ?? 'smooth'`.\n\n`step` claims the opposite of both, that a reading holds until the next.\n\n**`AreaChart` rests at `straight` and is not disagreeing.** A line claims a\nposition and a stacked band claims an amount: a curve fitted through one\nsum can pass under the curve fitted through the sum beneath it, so a\nsmoothed stack can draw a part as less than nothing. There is no such edge\nhere, which is what lets a line take the reading aid.",
               "attribute": "curve",
               "reflects": true
             },
@@ -50647,7 +50647,7 @@
               "type": {
                 "text": "Curve | undefined"
               },
-              "description": "How the line gets from one reading to the next.\n\n**`smooth` is the resting curve.** A curve invents the values between two\nreadings, which is why `straight` still exists, but the invention is\nbounded: the interpolation is monotone cubic, so it never leaves the band\nthe data sets and never introduces a peak or a trough the series does not\nhave. Within that bound the smoothed line is the easier one to follow\nacross a long series, and `straight` becomes the deliberate claim.\n\n**Absent rather than defaulted on the property**, because a reflecting\nproperty with a default writes its attribute onto every host anybody\nrenders, including the ones nobody configured.\n`line-chart-root.ssr.spec.ts` asserts the host carries only what the\nconsumer wrote. The default therefore lives where the path is built, as\n`curve ?? 'smooth'`.\n\n`step` claims the opposite of both, that a reading holds until the next.",
+              "description": "How the line gets from one reading to the next.\n\n**`smooth` is the resting curve.** A curve invents the values between two\nreadings, which is why `straight` still exists, but the invention is\nbounded: the interpolation is monotone cubic, so it never leaves the band\nthe data sets and never introduces a peak or a trough the series does not\nhave. Within that bound the smoothed line is the easier one to follow\nacross a long series, and `straight` becomes the deliberate claim.\n\n**Absent rather than defaulted on the property**, because a reflecting\nproperty with a default writes its attribute onto every host anybody\nrenders, including the ones nobody configured.\n`line-chart-root.ssr.spec.ts` asserts the host carries only what the\nconsumer wrote. The default therefore lives where the path is built, as\n`curve ?? 'smooth'`.\n\n`step` claims the opposite of both, that a reading holds until the next.\n\n**`AreaChart` rests at `straight` and is not disagreeing.** A line claims a\nposition and a stacked band claims an amount: a curve fitted through one\nsum can pass under the curve fitted through the sum beneath it, so a\nsmoothed stack can draw a part as less than nothing. There is no such edge\nhere, which is what lets a line take the reading aid.",
               "fieldName": "curve"
             },
             {
@@ -69615,11 +69615,11 @@
               "kind": "field",
               "name": "shape",
               "type": {
-                "text": "QrStyle"
+                "text": "QrStyle | undefined"
               },
-              "default": "'square'",
-              "description": "How the modules are drawn.\n\n`square` is the default and the only one that joins runs of adjacent\nmodules into a single subpath, which is what keeps a thousand modules to a\nhandful of nodes. `rounded` and `dots` draw each module on its own, because\nthe corners are the thing being drawn and a joined run has none in the\nmiddle. That cost is paid only by a code that asks for them.\n\nA scanner reads contrast between cells, not their shape, so all three\nscan. `dots` sits a little under half a module so neighbors do not touch,\nwhich is what makes it read as dots rather than as a softened square code.",
-              "attribute": "shape"
+              "description": "How the modules are drawn.\n\n`square` is the resting state and is written by not writing it, per the\nrule that a reflected property takes no default. It is also the only one\nthat joins runs of adjacent modules into a single subpath, which is what\nkeeps a thousand modules to a handful of nodes. `rounded` and `dots` draw\neach module on its own, because the corners are the thing being drawn and a\njoined run has none in the middle. That cost is paid only by a code that\nasks for them.\n\nA scanner reads contrast between cells, not their shape, so all three\nscan. `dots` sits a little under half a module so neighbors do not touch,\nwhich is what makes it read as dots rather than as a softened square code.",
+              "attribute": "shape",
+              "reflects": true
             },
             {
               "kind": "field",
@@ -70007,10 +70007,9 @@
             {
               "name": "shape",
               "type": {
-                "text": "QrStyle"
+                "text": "QrStyle | undefined"
               },
-              "default": "'square'",
-              "description": "How the modules are drawn.\n\n`square` is the default and the only one that joins runs of adjacent\nmodules into a single subpath, which is what keeps a thousand modules to a\nhandful of nodes. `rounded` and `dots` draw each module on its own, because\nthe corners are the thing being drawn and a joined run has none in the\nmiddle. That cost is paid only by a code that asks for them.\n\nA scanner reads contrast between cells, not their shape, so all three\nscan. `dots` sits a little under half a module so neighbors do not touch,\nwhich is what makes it read as dots rather than as a softened square code.",
+              "description": "How the modules are drawn.\n\n`square` is the resting state and is written by not writing it, per the\nrule that a reflected property takes no default. It is also the only one\nthat joins runs of adjacent modules into a single subpath, which is what\nkeeps a thousand modules to a handful of nodes. `rounded` and `dots` draw\neach module on its own, because the corners are the thing being drawn and a\njoined run has none in the middle. That cost is paid only by a code that\nasks for them.\n\nA scanner reads contrast between cells, not their shape, so all three\nscan. `dots` sits a little under half a module so neighbors do not touch,\nwhich is what makes it read as dots rather than as a softened square code.",
               "fieldName": "shape"
             },
             {
@@ -79128,7 +79127,7 @@
               "type": {
                 "text": "Curve | undefined"
               },
-              "description": "How the line gets from one reading to the next.\n\n**`smooth` is the resting curve.** A straight segment asserts nothing about\nthe values between two readings and a curve invents them, which is why\n`straight` exists. What settles the default the other way is that the\ninvention is bounded: the interpolation is monotone cubic, so it never\nleaves the band the data sets and never introduces a peak or a trough the\nseries does not have. Within that bound the smoothed line is the easier one\nto follow across a long series, which is what the drawing is for. `straight`\nbecomes the claim a consumer makes deliberately rather than the one they get\nby saying nothing.\n\n**The property stays optional and the default lives in the render.** A\nreflecting property with a default writes its attribute onto every host\nanybody renders, including the ones nobody configured, which the SSR specs\nassert against. So the resting state is still the attribute's absence, and\n`curve ?? 'smooth'` is what reads it.\n\n`step` claims the opposite of both, that a reading holds until the next.\nBars ignore it, having no between to interpolate.",
+              "description": "How the line gets from one reading to the next.\n\n**`smooth` is the resting curve.** A straight segment asserts nothing about\nthe values between two readings and a curve invents them, which is why\n`straight` exists. What settles the default the other way is that the\ninvention is bounded: the interpolation is monotone cubic, so it never\nleaves the band the data sets and never introduces a peak or a trough the\nseries does not have. Within that bound the smoothed line is the easier one\nto follow across a long series, which is what the drawing is for. `straight`\nbecomes the claim a consumer makes deliberately rather than the one they get\nby saying nothing.\n\n**The property stays optional and the default lives in the render.** A\nreflecting property with a default writes its attribute onto every host\nanybody renders, including the ones nobody configured, which the SSR specs\nassert against. So the resting state is still the attribute's absence, and\n`curve ?? 'smooth'` is what reads it.\n\n`step` claims the opposite of both, that a reading holds until the next.\nBars ignore it, having no between to interpolate.\n\n**`AreaChart` rests at `straight` and is not disagreeing.** A line claims a\nposition and a stacked band claims an amount: a curve fitted through one\nsum can pass under the curve fitted through the sum beneath it, so a\nsmoothed stack can draw a part as less than nothing. There is no such edge\nhere, which is what lets a line take the reading aid.",
               "attribute": "curve",
               "reflects": true
             },
@@ -79521,7 +79520,7 @@
               "type": {
                 "text": "Curve | undefined"
               },
-              "description": "How the line gets from one reading to the next.\n\n**`smooth` is the resting curve.** A straight segment asserts nothing about\nthe values between two readings and a curve invents them, which is why\n`straight` exists. What settles the default the other way is that the\ninvention is bounded: the interpolation is monotone cubic, so it never\nleaves the band the data sets and never introduces a peak or a trough the\nseries does not have. Within that bound the smoothed line is the easier one\nto follow across a long series, which is what the drawing is for. `straight`\nbecomes the claim a consumer makes deliberately rather than the one they get\nby saying nothing.\n\n**The property stays optional and the default lives in the render.** A\nreflecting property with a default writes its attribute onto every host\nanybody renders, including the ones nobody configured, which the SSR specs\nassert against. So the resting state is still the attribute's absence, and\n`curve ?? 'smooth'` is what reads it.\n\n`step` claims the opposite of both, that a reading holds until the next.\nBars ignore it, having no between to interpolate.",
+              "description": "How the line gets from one reading to the next.\n\n**`smooth` is the resting curve.** A straight segment asserts nothing about\nthe values between two readings and a curve invents them, which is why\n`straight` exists. What settles the default the other way is that the\ninvention is bounded: the interpolation is monotone cubic, so it never\nleaves the band the data sets and never introduces a peak or a trough the\nseries does not have. Within that bound the smoothed line is the easier one\nto follow across a long series, which is what the drawing is for. `straight`\nbecomes the claim a consumer makes deliberately rather than the one they get\nby saying nothing.\n\n**The property stays optional and the default lives in the render.** A\nreflecting property with a default writes its attribute onto every host\nanybody renders, including the ones nobody configured, which the SSR specs\nassert against. So the resting state is still the attribute's absence, and\n`curve ?? 'smooth'` is what reads it.\n\n`step` claims the opposite of both, that a reading holds until the next.\nBars ignore it, having no between to interpolate.\n\n**`AreaChart` rests at `straight` and is not disagreeing.** A line claims a\nposition and a stacked band claims an amount: a curve fitted through one\nsum can pass under the curve fitted through the sum beneath it, so a\nsmoothed stack can draw a part as less than nothing. There is no such edge\nhere, which is what lets a line take the reading aid.",
               "fieldName": "curve"
             },
             {
@@ -80928,7 +80927,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 +81148,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 +81398,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 +82020,7 @@
           "helix": {
             "category": "layout",
             "since": "0.1.0",
-            "status": "experimental",
+            "status": "stable",
             "documentation": "https://fusion.dev/helix/components/splitter",
             "aliases": [
               "SplitPane",

package/dist/area-chart/root/area-chart-root.d.ts

@@ -115,6 +115,13 @@ export declare class HelixHeadlessAreaChart extends HelixHeadlessAreaChart_base
      *
      * Absent rather than defaulted because a reflecting property with a default
      * writes its attribute onto every host, including the ones nobody configured.
+     * The resting value therefore lives in the render, as `curve ?? 'straight'`.
+     *
+     * **`LineChart` and `Sparkline` rest at `smooth` and are not disagreeing.** A
+     * line claims a position, so the bounded invention a monotone cubic makes is
+     * a reading aid and costs nothing. A band claims an amount, and two sums
+     * smoothed independently can cross, so the same aid here draws a part as less
+     * than nothing. Same axis, different mark, different resting value.
      */
     curve?: Curve;
     /**

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

@@ -101,6 +101,12 @@ export declare class HelixHeadlessLineChart extends HelixHeadlessLineChart_base
      * `curve ?? 'smooth'`.
      *
      * `step` claims the opposite of both, that a reading holds until the next.
+     *
+     * **`AreaChart` rests at `straight` and is not disagreeing.** A line claims a
+     * position and a stacked band claims an amount: a curve fitted through one
+     * sum can pass under the curve fitted through the sum beneath it, so a
+     * smoothed stack can draw a part as less than nothing. There is no such edge
+     * here, which is what lets a line take the reading aid.
      */
     curve?: Curve;
     /**

package/dist/qr-code/root/qr-code-root.d.ts

@@ -64,17 +64,19 @@ export declare class HelixHeadlessQrCode extends HelixElement {
     /**
      * How the modules are drawn.
      *
-     * `square` is the default and the only one that joins runs of adjacent
-     * modules into a single subpath, which is what keeps a thousand modules to a
-     * handful of nodes. `rounded` and `dots` draw each module on its own, because
-     * the corners are the thing being drawn and a joined run has none in the
-     * middle. That cost is paid only by a code that asks for them.
+     * `square` is the resting state and is written by not writing it, per the
+     * rule that a reflected property takes no default. It is also the only one
+     * that joins runs of adjacent modules into a single subpath, which is what
+     * keeps a thousand modules to a handful of nodes. `rounded` and `dots` draw
+     * each module on its own, because the corners are the thing being drawn and a
+     * joined run has none in the middle. That cost is paid only by a code that
+     * asks for them.
      *
      * A scanner reads contrast between cells, not their shape, so all three
      * scan. `dots` sits a little under half a module so neighbors do not touch,
      * which is what makes it read as dots rather than as a softened square code.
      */
-    shape: QrStyle;
+    shape?: QrStyle;
     /**
      * What the code encodes, which is usually a URL.
      */

package/dist/qr-code/root/qr-code-root.js

@@ -63,7 +63,6 @@ let HelixHeadlessQrCode = class HelixHeadlessQrCode extends HelixElement {
     constructor() {
         super(...arguments);
         this.label = '';
-        this.shape = 'square';
         this.value = '';
         this.logo = false;
     }
@@ -99,7 +98,7 @@ let HelixHeadlessQrCode = class HelixHeadlessQrCode extends HelixElement {
     >
       <path
         part="modules"
-        d=${pathFor(result.data, this.shape, 'body')}
+        d=${pathFor(result.data, this.shape ?? 'square', 'body')}
         transform="translate(${quiet} ${quiet})"
         fill="currentColor"
       />
@@ -134,7 +133,7 @@ __decorate([
     property()
 ], HelixHeadlessQrCode.prototype, "label", void 0);
 __decorate([
-    property()
+    property({ reflect: true })
 ], HelixHeadlessQrCode.prototype, "shape", void 0);
 __decorate([
     property()

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

@@ -70,6 +70,12 @@ export declare class HelixHeadlessSparkline extends HelixElement {
      *
      * `step` claims the opposite of both, that a reading holds until the next.
      * Bars ignore it, having no between to interpolate.
+     *
+     * **`AreaChart` rests at `straight` and is not disagreeing.** A line claims a
+     * position and a stacked band claims an amount: a curve fitted through one
+     * sum can pass under the curve fitted through the sum beneath it, so a
+     * smoothed stack can draw a part as less than nothing. There is no such edge
+     * here, which is what lets a line take the reading aid.
      */
     curve?: Curve;
     /**

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.1",
   "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.1",
+    "@fusion.dev/helix-icons": "0.52.1",
     "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.1",
+    "@fusion.dev/helix-testing": "0.52.1",
     "@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

@@ -756,7 +756,14 @@ can draw a part as less than nothing, `step` is for a quantity that changes
 at a moment and is ordered the way `straight` is.
 
 Absent rather than defaulted because a reflecting property with a default
-writes its attribute onto every host, including the ones nobody configured. */
+writes its attribute onto every host, including the ones nobody configured.
+The resting value therefore lives in the render, as `curve ?? 'straight'`.
+
+**`LineChart` and `Sparkline` rest at `smooth` and are not disagreeing.** A
+line claims a position, so the bounded invention a monotone cubic makes is
+a reading aid and costs nothing. A band claims an amount, and two sums
+smoothed independently can cross, so the same aid here draws a part as less
+than nothing. Same axis, different mark, different resting value. */
   curve?: (HelixHeadlessAreaChart["curve"]) | undefined;
   /** Which rules are drawn across the plot, if any.
 
@@ -799,7 +806,14 @@ can draw a part as less than nothing, `step` is for a quantity that changes
 at a moment and is ordered the way `straight` is.
 
 Absent rather than defaulted because a reflecting property with a default
-writes its attribute onto every host, including the ones nobody configured. */
+writes its attribute onto every host, including the ones nobody configured.
+The resting value therefore lives in the render, as `curve ?? 'straight'`.
+
+**`LineChart` and `Sparkline` rest at `smooth` and are not disagreeing.** A
+line claims a position, so the bounded invention a monotone cubic makes is
+a reading aid and costs nothing. A band claims an amount, and two sums
+smoothed independently can cross, so the same aid here draws a part as less
+than nothing. Same axis, different mark, different resting value. */
   "prop:curve"?: (HelixHeadlessAreaChart["curve"]) | undefined;
   /** Which rules are drawn across the plot, if any.
 
@@ -8494,7 +8508,13 @@ renders, including the ones nobody configured.
 consumer wrote. The default therefore lives where the path is built, as
 `curve ?? 'smooth'`.
 
-`step` claims the opposite of both, that a reading holds until the next. */
+`step` claims the opposite of both, that a reading holds until the next.
+
+**`AreaChart` rests at `straight` and is not disagreeing.** A line claims a
+position and a stacked band claims an amount: a curve fitted through one
+sum can pass under the curve fitted through the sum beneath it, so a
+smoothed stack can draw a part as less than nothing. There is no such edge
+here, which is what lets a line take the reading aid. */
   curve?: (HelixHeadlessLineChart["curve"]) | undefined;
   /** Which rules are drawn across the plot, if any.
 
@@ -8599,7 +8619,13 @@ renders, including the ones nobody configured.
 consumer wrote. The default therefore lives where the path is built, as
 `curve ?? 'smooth'`.
 
-`step` claims the opposite of both, that a reading holds until the next. */
+`step` claims the opposite of both, that a reading holds until the next.
+
+**`AreaChart` rests at `straight` and is not disagreeing.** A line claims a
+position and a stacked band claims an amount: a curve fitted through one
+sum can pass under the curve fitted through the sum beneath it, so a
+smoothed stack can draw a part as less than nothing. There is no such edge
+here, which is what lets a line take the reading aid. */
   "prop:curve"?: (HelixHeadlessLineChart["curve"]) | undefined;
   /** Which rules are drawn across the plot, if any.
 
@@ -11780,11 +11806,13 @@ and a URL is a better name than "QR code" for a reader who cannot see it. */
   label?: (HelixHeadlessQrCode["label"]) | undefined;
   /** How the modules are drawn.
 
-`square` is the default and the only one that joins runs of adjacent
-modules into a single subpath, which is what keeps a thousand modules to a
-handful of nodes. `rounded` and `dots` draw each module on its own, because
-the corners are the thing being drawn and a joined run has none in the
-middle. That cost is paid only by a code that asks for them.
+`square` is the resting state and is written by not writing it, per the
+rule that a reflected property takes no default. It is also the only one
+that joins runs of adjacent modules into a single subpath, which is what
+keeps a thousand modules to a handful of nodes. `rounded` and `dots` draw
+each module on its own, because the corners are the thing being drawn and a
+joined run has none in the middle. That cost is paid only by a code that
+asks for them.
 
 A scanner reads contrast between cells, not their shape, so all three
 scan. `dots` sits a little under half a module so neighbors do not touch,
@@ -11810,11 +11838,13 @@ and a URL is a better name than "QR code" for a reader who cannot see it. */
   "prop:label"?: (HelixHeadlessQrCode["label"]) | undefined;
   /** How the modules are drawn.
 
-`square` is the default and the only one that joins runs of adjacent
-modules into a single subpath, which is what keeps a thousand modules to a
-handful of nodes. `rounded` and `dots` draw each module on its own, because
-the corners are the thing being drawn and a joined run has none in the
-middle. That cost is paid only by a code that asks for them.
+`square` is the resting state and is written by not writing it, per the
+rule that a reflected property takes no default. It is also the only one
+that joins runs of adjacent modules into a single subpath, which is what
+keeps a thousand modules to a handful of nodes. `rounded` and `dots` draw
+each module on its own, because the corners are the thing being drawn and a
+joined run has none in the middle. That cost is paid only by a code that
+asks for them.
 
 A scanner reads contrast between cells, not their shape, so all three
 scan. `dots` sits a little under half a module so neighbors do not touch,
@@ -13066,7 +13096,13 @@ assert against. So the resting state is still the attribute's absence, and
 `curve ?? 'smooth'` is what reads it.
 
 `step` claims the opposite of both, that a reading holds until the next.
-Bars ignore it, having no between to interpolate. */
+Bars ignore it, having no between to interpolate.
+
+**`AreaChart` rests at `straight` and is not disagreeing.** A line claims a
+position and a stacked band claims an amount: a curve fitted through one
+sum can pass under the curve fitted through the sum beneath it, so a
+smoothed stack can draw a part as less than nothing. There is no such edge
+here, which is what lets a line take the reading aid. */
   curve?: (HelixHeadlessSparkline["curve"]) | undefined;
   /** The id of a table to read instead, when there is one behind the line.
 
@@ -13141,7 +13177,13 @@ assert against. So the resting state is still the attribute's absence, and
 `curve ?? 'smooth'` is what reads it.
 
 `step` claims the opposite of both, that a reading holds until the next.
-Bars ignore it, having no between to interpolate. */
+Bars ignore it, having no between to interpolate.
+
+**`AreaChart` rests at `straight` and is not disagreeing.** A line claims a
+position and a stacked band claims an amount: a curve fitted through one
+sum can pass under the curve fitted through the sum beneath it, so a
+smoothed stack can draw a part as less than nothing. There is no such edge
+here, which is what lets a line take the reading aid. */
   "prop:curve"?: (HelixHeadlessSparkline["curve"]) | undefined;
   /** The id of a table to read instead, when there is one behind the line.
 
@@ -18202,6 +18244,13 @@ export type CustomElements = {
    *
    * Absent rather than defaulted because a reflecting property with a default
    * writes its attribute onto every host, including the ones nobody configured.
+   * The resting value therefore lives in the render, as `curve ?? 'straight'`.
+   *
+   * **`LineChart` and `Sparkline` rest at `smooth` and are not disagreeing.** A
+   * line claims a position, so the bounded invention a monotone cubic makes is
+   * a reading aid and costs nothing. A band claims an amount, and two sums
+   * smoothed independently can cross, so the same aid here draws a part as less
+   * than nothing. Same axis, different mark, different resting value.
    * - `gridlines`: Which rules are drawn across the plot, if any.
    *
    * The same three values `LineChart` takes, with the same fallback: a bare
@@ -25934,6 +25983,12 @@ export type CustomElements = {
    * `curve ?? 'smooth'`.
    *
    * `step` claims the opposite of both, that a reading holds until the next.
+   *
+   * **`AreaChart` rests at `straight` and is not disagreeing.** A line claims a
+   * position and a stacked band claims an amount: a curve fitted through one
+   * sum can pass under the curve fitted through the sum beneath it, so a
+   * smoothed stack can draw a part as less than nothing. There is no such edge
+   * here, which is what lets a line take the reading aid.
    * - `gridlines`: Which rules are drawn across the plot, if any.
    *
    * Absent draws none, which is the honest default rather than a timid one: a
@@ -29288,11 +29343,13 @@ export type CustomElements = {
    * and a URL is a better name than "QR code" for a reader who cannot see it.
    * - `shape`: How the modules are drawn.
    *
-   * `square` is the default and the only one that joins runs of adjacent
-   * modules into a single subpath, which is what keeps a thousand modules to a
-   * handful of nodes. `rounded` and `dots` draw each module on its own, because
-   * the corners are the thing being drawn and a joined run has none in the
-   * middle. That cost is paid only by a code that asks for them.
+   * `square` is the resting state and is written by not writing it, per the
+   * rule that a reflected property takes no default. It is also the only one
+   * that joins runs of adjacent modules into a single subpath, which is what
+   * keeps a thousand modules to a handful of nodes. `rounded` and `dots` draw
+   * each module on its own, because the corners are the thing being drawn and a
+   * joined run has none in the middle. That cost is paid only by a code that
+   * asks for them.
    *
    * A scanner reads contrast between cells, not their shape, so all three
    * scan. `dots` sits a little under half a module so neighbors do not touch,
@@ -30866,6 +30923,12 @@ export type CustomElements = {
    *
    * `step` claims the opposite of both, that a reading holds until the next.
    * Bars ignore it, having no between to interpolate.
+   *
+   * **`AreaChart` rests at `straight` and is not disagreeing.** A line claims a
+   * position and a stacked band claims an amount: a curve fitted through one
+   * sum can pass under the curve fitted through the sum beneath it, so a
+   * smoothed stack can draw a part as less than nothing. There is no such edge
+   * here, which is what lets a line take the reading aid.
    * - `for`: The id of a table to read instead, when there is one behind the line.
    *
    * The first column of numbers is the series drawn. This wins over `values`,
@@ -31187,10 +31250,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
    *
@@ -36091,6 +36156,13 @@ export type CustomElementsSolidJs = {
    *
    * Absent rather than defaulted because a reflecting property with a default
    * writes its attribute onto every host, including the ones nobody configured.
+   * The resting value therefore lives in the render, as `curve ?? 'straight'`.
+   *
+   * **`LineChart` and `Sparkline` rest at `smooth` and are not disagreeing.** A
+   * line claims a position, so the bounded invention a monotone cubic makes is
+   * a reading aid and costs nothing. A band claims an amount, and two sums
+   * smoothed independently can cross, so the same aid here draws a part as less
+   * than nothing. Same axis, different mark, different resting value.
    * - `gridlines`: Which rules are drawn across the plot, if any.
    *
    * The same three values `LineChart` takes, with the same fallback: a bare
@@ -43930,6 +44002,12 @@ export type CustomElementsSolidJs = {
    * `curve ?? 'smooth'`.
    *
    * `step` claims the opposite of both, that a reading holds until the next.
+   *
+   * **`AreaChart` rests at `straight` and is not disagreeing.** A line claims a
+   * position and a stacked band claims an amount: a curve fitted through one
+   * sum can pass under the curve fitted through the sum beneath it, so a
+   * smoothed stack can draw a part as less than nothing. There is no such edge
+   * here, which is what lets a line take the reading aid.
    * - `gridlines`: Which rules are drawn across the plot, if any.
    *
    * Absent draws none, which is the honest default rather than a timid one: a
@@ -47336,11 +47414,13 @@ export type CustomElementsSolidJs = {
    * and a URL is a better name than "QR code" for a reader who cannot see it.
    * - `shape`: How the modules are drawn.
    *
-   * `square` is the default and the only one that joins runs of adjacent
-   * modules into a single subpath, which is what keeps a thousand modules to a
-   * handful of nodes. `rounded` and `dots` draw each module on its own, because
-   * the corners are the thing being drawn and a joined run has none in the
-   * middle. That cost is paid only by a code that asks for them.
+   * `square` is the resting state and is written by not writing it, per the
+   * rule that a reflected property takes no default. It is also the only one
+   * that joins runs of adjacent modules into a single subpath, which is what
+   * keeps a thousand modules to a handful of nodes. `rounded` and `dots` draw
+   * each module on its own, because the corners are the thing being drawn and a
+   * joined run has none in the middle. That cost is paid only by a code that
+   * asks for them.
    *
    * A scanner reads contrast between cells, not their shape, so all three
    * scan. `dots` sits a little under half a module so neighbors do not touch,
@@ -48941,6 +49021,12 @@ export type CustomElementsSolidJs = {
    *
    * `step` claims the opposite of both, that a reading holds until the next.
    * Bars ignore it, having no between to interpolate.
+   *
+   * **`AreaChart` rests at `straight` and is not disagreeing.** A line claims a
+   * position and a stacked band claims an amount: a curve fitted through one
+   * sum can pass under the curve fitted through the sum beneath it, so a
+   * smoothed stack can draw a part as less than nothing. There is no such edge
+   * here, which is what lets a line take the reading aid.
    * - `for`: The id of a table to read instead, when there is one behind the line.
    *
    * The first column of numbers is the series drawn. This wins over `values`,
@@ -49269,10 +49355,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

@@ -408,7 +408,14 @@ can draw a part as less than nothing, `step` is for a quantity that changes
 at a moment and is ordered the way `straight` is.
 
 Absent rather than defaulted because a reflecting property with a default
-writes its attribute onto every host, including the ones nobody configured. */
+writes its attribute onto every host, including the ones nobody configured.
+The resting value therefore lives in the render, as `curve ?? 'straight'`.
+
+**`LineChart` and `Sparkline` rest at `smooth` and are not disagreeing.** A
+line claims a position, so the bounded invention a monotone cubic makes is
+a reading aid and costs nothing. A band claims an amount, and two sums
+smoothed independently can cross, so the same aid here draws a part as less
+than nothing. Same axis, different mark, different resting value. */
   curve?: (HelixHeadlessAreaChart["curve"]) | undefined;
   /** Which rules are drawn across the plot, if any.
 
@@ -4360,7 +4367,13 @@ renders, including the ones nobody configured.
 consumer wrote. The default therefore lives where the path is built, as
 `curve ?? 'smooth'`.
 
-`step` claims the opposite of both, that a reading holds until the next. */
+`step` claims the opposite of both, that a reading holds until the next.
+
+**`AreaChart` rests at `straight` and is not disagreeing.** A line claims a
+position and a stacked band claims an amount: a curve fitted through one
+sum can pass under the curve fitted through the sum beneath it, so a
+smoothed stack can draw a part as less than nothing. There is no such edge
+here, which is what lets a line take the reading aid. */
   curve?: (HelixHeadlessLineChart["curve"]) | undefined;
   /** Which rules are drawn across the plot, if any.
 
@@ -6038,11 +6051,13 @@ and a URL is a better name than "QR code" for a reader who cannot see it. */
   label?: (HelixHeadlessQrCode["label"]) | undefined;
   /** How the modules are drawn.
 
-`square` is the default and the only one that joins runs of adjacent
-modules into a single subpath, which is what keeps a thousand modules to a
-handful of nodes. `rounded` and `dots` draw each module on its own, because
-the corners are the thing being drawn and a joined run has none in the
-middle. That cost is paid only by a code that asks for them.
+`square` is the resting state and is written by not writing it, per the
+rule that a reflected property takes no default. It is also the only one
+that joins runs of adjacent modules into a single subpath, which is what
+keeps a thousand modules to a handful of nodes. `rounded` and `dots` draw
+each module on its own, because the corners are the thing being drawn and a
+joined run has none in the middle. That cost is paid only by a code that
+asks for them.
 
 A scanner reads contrast between cells, not their shape, so all three
 scan. `dots` sits a little under half a module so neighbors do not touch,
@@ -6693,7 +6708,13 @@ assert against. So the resting state is still the attribute's absence, and
 `curve ?? 'smooth'` is what reads it.
 
 `step` claims the opposite of both, that a reading holds until the next.
-Bars ignore it, having no between to interpolate. */
+Bars ignore it, having no between to interpolate.
+
+**`AreaChart` rests at `straight` and is not disagreeing.** A line claims a
+position and a stacked band claims an amount: a curve fitted through one
+sum can pass under the curve fitted through the sum beneath it, so a
+smoothed stack can draw a part as less than nothing. There is no such edge
+here, which is what lets a line take the reading aid. */
   curve?: (HelixHeadlessSparkline["curve"]) | undefined;
   /** The id of a table to read instead, when there is one behind the line.
 
@@ -9793,7 +9814,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,