@fusion.dev/helix 0.50.0 → 0.51.0

package/custom-elements.json

@@ -13281,7 +13281,7 @@
               }
             },
             {
-              "description": "How many slides go across, written onto the track by the component so a sheet divides the track by the same number the positions are counted from. Read it rather than selecting on `per-view`, which cannot be enumerated without a ceiling. See `perView`.",
+              "description": "How many slides go across, written onto the track by the component so a sheet divides the track by the same number the positions are counted from. Read it rather than selecting on `per-view`, which cannot be enumerated without a ceiling. Under `per-view=\"auto\"` the component writes nothing and the sheet declares it instead, so the same name answers in both modes. See `perView`.",
               "name": "--carousel-per-view",
               "inheritedFrom": {
                 "name": "HelixHeadlessCarousel",
@@ -13295,6 +13295,14 @@
                 "name": "HelixHeadlessCarousel",
                 "module": "src/carousel/root/carousel-root.ts"
               }
+            },
+            {
+              "description": "The narrowest a slide may be laid out, which is what `per-view=\"auto\"` fits the track with. A length, since the sheet divides by it. Unset is the whole track, which is one across.",
+              "name": "--carousel-slide-min",
+              "inheritedFrom": {
+                "name": "HelixHeadlessCarousel",
+                "module": "src/carousel/root/carousel-root.ts"
+              }
             }
           ],
           "members": [
@@ -13521,9 +13529,9 @@
               "kind": "field",
               "name": "perView",
               "type": {
-                "text": "number | undefined"
+                "text": "number | 'auto' | undefined"
               },
-              "description": "How many slides are shown across the track at once. Absent shows one.\n\n**Here rather than on the styled tier, because it decides how many places\nthe track can stop.** From the stylesheet it looks like a width, one rule\nper value setting a custom property that the slides divide the track by.\nBut a carousel showing four of six slides has three positions, not six, and\neverything that counts positions is in this file. Declared up there, `goTo`\nclamps to the last *slide*, so three of the six indicators point at an\noffset the track has already reached: pressing next walks the dots to the\nend while the slides stop moving a third of the way through.\n\n**The number is published to the styles rather than enumerated by them**,\nas `--carousel-per-view` on the track, which is what keeps a width and a\ncount from disagreeing. A sheet can only name a value it wrote a rule for,\nso the styled tier enumerated `per-view=\"2\"` through `5` and called five a\njudgment; above it the pane fell back to one across while this file went on\ncounting positions. Measured in Chromium over eight slides, six across gave\nthree dots, a pane taking the whole track and five slides reachable only by\ndragging. Written from here there is no ceiling to exceed, and a consumer's\nown sheet reads the same declaration the styled one does. `runEnd` publishes\nits correction the same way and for the same reason.\n\n**On the track and not on the host.** A custom property on the host is a\nreflected attribute by another name: it would arrive on upgrade, and a\nconsumer's server markup never had it. Inside the component's own shadow\nroot it serializes with the rest of the template on the server, and the\ntrack's own declaration beats anything a consumer inherits in, so the\nattribute is the one answer to how wide a pane is.\n\nA value the track cannot honor is taken to the nearest one it can, by\n`across`, and both tiers read that rather than this.\n\nNo default, because it reflects. A reflected property with a value writes\nits attribute on upgrade, and the host then carries something a consumer's\nserver markup never had, which React reports as a mismatch. The one-across\ncase is the absent attribute, and the styles read it that way.",
+              "description": "How many slides are shown across the track at once. Absent shows one.\n\n**Here rather than on the styled tier, because it decides how many places\nthe track can stop.** From the stylesheet it looks like a width, one rule\nper value setting a custom property that the slides divide the track by.\nBut a carousel showing four of six slides has three positions, not six, and\neverything that counts positions is in this file. Declared up there, `goTo`\nclamps to the last *slide*, so three of the six indicators point at an\noffset the track has already reached: pressing next walks the dots to the\nend while the slides stop moving a third of the way through.\n\n**The number is published to the styles rather than enumerated by them**,\nas `--carousel-per-view` on the track, which is what keeps a width and a\ncount from disagreeing. A sheet can only name a value it wrote a rule for,\nso the styled tier enumerated `per-view=\"2\"` through `5` and called five a\njudgment; above it the pane fell back to one across while this file went on\ncounting positions. Measured in Chromium over eight slides, six across gave\nthree dots, a pane taking the whole track and five slides reachable only by\ndragging. Written from here there is no ceiling to exceed, and a consumer's\nown sheet reads the same declaration the styled one does. `runEnd` publishes\nits correction the same way and for the same reason.\n\n**On the track and not on the host.** A custom property on the host is a\nreflected attribute by another name: it would arrive on upgrade, and a\nconsumer's server markup never had it. Inside the component's own shadow\nroot it serializes with the rest of the template on the server, and the\ntrack's own declaration beats anything a consumer inherits in, so the\nattribute is the one answer to how wide a pane is.\n\nA value the track cannot honor is taken to the nearest one it can, by\n`across`, and both tiers read that rather than this.\n\n**`auto` fits as many as the track can hold**, at `--carousel-slide-min`\napiece, and nothing is written onto the track: the count is the sheet's,\nand the sheet's alone, because it is the one number here CSS can work out\nfor itself. Everything it takes is a length the sheet already has, so the\npanes are laid out at their final width by the first rule that runs, on a\nserver's markup as on the client's, and no script is waited on. That is the\nwhole reason a declared count was ever the only option: a carousel that\nasks how wide its container is can only ask on the client, so the panes go\ndown at one width and move to another when the answer arrives. Written\ninline the count would outrank the sheet that computes it, which is why an\n`auto` track is handed nothing. A count stays for the design that calls for\nexactly three.\n\nThe styled sheet says how it divides, and the headless `auto` example\ncarries the same three lines for a consumer writing their own.\n\n**A value rather than the resting behavior**, which is what the\nresponsiveness policy asks of every axis that a box decides: a splitter\nturns on `orientation=\"auto\"` and a plain one does not turn at all. Fitting\nchanges what the carousel *does*, since how many are across is how many\nplaces the track can stop, so a carousel that had not asked for it would\nfind its position count moving with the window.\n\nNo default, because it reflects. A reflected property with a value writes\nits attribute on upgrade, and the host then carries something a consumer's\nserver markup never had, which React reports as a mismatch. The one-across\ncase is the absent attribute, and the styles read it that way.",
               "attribute": "per-view",
               "reflects": true,
               "inheritedFrom": {
@@ -13533,12 +13541,40 @@
             },
             {
               "kind": "field",
-              "name": "across",
+              "name": "clamped",
               "type": {
                 "text": "number"
               },
               "privacy": "private",
-              "description": "`perView` as both tiers use it: a whole number of slides, one at least.\n\n**The clamp is here because the arithmetic is here**, and the two readers\nof this number have to be given the same one. A fraction is floored, since\na position is a whole slide along: one and a half across leaves a last\nposition the track runs out before reaching, which is the fault `goTo`\nalready carries a comment about. Zero and a negative divide the track into\nnothing and into a pane facing the wrong way, and a non-numeric attribute\nparses to `NaN`, which `Math.max` propagates: it counted `NaN` positions,\ndrew no indicators at all and left `index` at `NaN`. All of them read as\none across, which is what a carousel with nothing sayable asked for.\n\nNot clamped to the number of slides. Six across four slides is four panes\nat a sixth of the track each and the one place to stand, which is what was\nasked for as nearly as it can be had, and the slide count is a fact the\nserver does not have: clamping to it would draw one width there and another\non upgrade.",
+              "description": "A declared `perView` as both tiers use it: a whole number, one at least.\n\n**The clamp is here because the arithmetic is here**, and the two readers\nof this number have to be given the same one. A fraction is floored, since\na position is a whole slide along: one and a half across leaves a last\nposition the track runs out before reaching, which is the fault `goTo`\nalready carries a comment about. Zero and a negative divide the track into\nnothing and into a pane facing the wrong way, and a non-numeric attribute\nparses to `NaN`, which `Math.max` propagates: it counted `NaN` positions,\ndrew no indicators at all and left `index` at `NaN`. All of them read as\none across, which is what a carousel with nothing sayable asked for.\n\n**A vertical `auto` is one of them.** Fitting divides the room the page\ngave the track, and a vertical track's room is a height the consumer chose\nwith `--carousel-block-size`: there is nothing there to fit against that\nthey did not already decide, so the count is theirs to state. It also\ncannot be had cheaply, the block axis wanting `container-type: size`, which\nlays a track out as empty wherever its height is not definite.\n\nNot clamped to the number of slides. Six across four slides is four panes\nat a sixth of the track each and the one place to stand, which is what was\nasked for as nearly as it can be had, and the slide count is a fact the\nserver does not have: clamping to it would draw one width there and another\non upgrade.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixHeadlessCarousel",
+                "module": "src/carousel/root/carousel-root.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "fits",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "description": "Whether the track is fitting slides to its own box rather than to a count.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixHeadlessCarousel",
+                "module": "src/carousel/root/carousel-root.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "across",
+              "type": {
+                "text": "number | undefined"
+              },
+              "privacy": "private",
+              "description": "How many slides go across, and `undefined` while a fitted track is unlaid.\n\n**Undefined is the honest answer and the indicators read it as one**, which\nis the whole of how a fitted carousel keeps from drawing a run of dots at\none length and correcting it at another. The count a fitted track goes\nacross is whatever its box resolved to, so nothing knows it until there is\na box: not the server, which has no layout, and not the render that draws\nthe panes, layout being what follows a render rather than what precedes it.\nThe dots wait for it, which costs them nothing, because a server serves no\nindicators for any carousel, `slides` being empty there.\n\nMeasured 16 Sep 2026 in Chromium 151.0.7922.34 and WebKit 26.5, recording\nevery run of dots a carousel has from the upgrade on: a fitted one goes\nnone, then five, and never another number; a declared one goes straight to\nsix. What a reader can see is the run missing, never the run wrong.",
               "readonly": true,
               "inheritedFrom": {
                 "name": "HelixHeadlessCarousel",
@@ -13551,13 +13587,108 @@
               "type": {
                 "text": "number"
               },
-              "description": "How many distinct views the track holds, which is what the indicators count.\n\nA window of `perView` slides sliding one at a time over `n` of them stops\n`n - perView + 1` times, so six slides four across is three: 0 to 3, 1 to 4,\n2 to 5. One at minimum, since a carousel showing everything it has still\nhas the one place to be.",
+              "description": "How many distinct views the track holds, which is what the indicators count.\n\nA window of `perView` slides sliding one at a time over `n` of them stops\n`n - perView + 1` times, so six slides four across is three: 0 to 3, 1 to 4,\n2 to 5. One at minimum, since a carousel showing everything it has still\nhas the one place to be.\n\nOne across until a fitted track has been laid out, which is the same answer\na carousel that has never been told anything gives, and the dots are\nwithheld rather than counted from it. See `across`.",
               "readonly": true,
               "inheritedFrom": {
                 "name": "HelixHeadlessCarousel",
                 "module": "src/carousel/root/carousel-root.ts"
               }
             },
+            {
+              "kind": "method",
+              "name": "measure",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "number | undefined"
+                }
+              },
+              "description": "How many slides the box turned out to hold, from the pane it laid out.\n\n**The measurement asks what happened rather than what was asked for**, and\nthat is why it is the pane's width and not the count in the declaration.\nThe sheet divides the track by `--carousel-per-view`, which under `auto` is\narithmetic rather than a number, and a consumer's own sheet may divide it\nsome other way entirely or grow the panes to fill a track holding\neverything it has. Reading the box back gets the same answer as the\ndeclaration wherever the two agree and the true one wherever they do not,\nso a width and a count cannot disagree in either direction.\n\nThe sheet's own arithmetic run backward, on the lengths that were actually\nused: a gap added to the room, divided by a pane and a gap. Rounded,\nbecause the pane a sheet lays out is a sixty-fourth off its exact share by\ndesign and the quotient lands a ten-thousandth off a whole number.\n\nUndefined where there is nothing to measure, which is a harness rather than\na browser: happy-dom lays nothing out and reports zero for every box, and a\ncount taken from zeros would be a number with no layout behind it.",
+              "inheritedFrom": {
+                "name": "HelixHeadlessCarousel",
+                "module": "src/carousel/root/carousel-root.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "readFit",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Takes the reading, and puts the index back inside what it leaves.\n\n**A fitted carousel's last position moves with the window**, which a\ndeclared one's never does: eight slides at one across has eight places to\nstand and four across has five, so a track widened while the reader sits on\nthe last of them is a track resting somewhere it can no longer be. Through\n`goTo`, so the correction goes out as the same cancelable announcement\nevery other index change does and a consumer holding `index` hears it\nrather than being overwritten.\n\nOnly on a change, so the observer's own re-render cannot feed itself.",
+              "inheritedFrom": {
+                "name": "HelixHeadlessCarousel",
+                "module": "src/carousel/root/carousel-root.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "handed",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "string | typeof nothing"
+                }
+              },
+              "description": "The count handed to the styles, and nothing at all where they work it out.\n\nA declared count is this file's: it decides how many places the track can\nstop, so the number the panes are divided by has to be the number the\npositions were counted from, and writing it on the track inside the\ncomponent's own shadow root is what keeps a sheet from having to enumerate\nthe values it will answer for.\n\nA fitted one is the sheet's, and handing it anything would take it back: an\ninline declaration outranks every rule short of `!important`, so a track\ntold `1` here could never be told three by the rule that fits it. The\nabsence is not a gap either, because the rule that computes the count\ndeclares it on this same element, which beats anything a consumer inherits\nin exactly as the inline one did.",
+              "inheritedFrom": {
+                "name": "HelixHeadlessCarousel",
+                "module": "src/carousel/root/carousel-root.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "fitted",
+              "type": {
+                "text": "number | undefined"
+              },
+              "privacy": "private",
+              "description": "What the box resolved to, and `undefined` until it has been laid out.",
+              "inheritedFrom": {
+                "name": "HelixHeadlessCarousel",
+                "module": "src/carousel/root/carousel-root.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "sizes",
+              "type": {
+                "text": "ResizeObserver | undefined"
+              },
+              "privacy": "private",
+              "description": "Watches the pane a fitted track laid out, while `auto` is what was asked.",
+              "inheritedFrom": {
+                "name": "HelixHeadlessCarousel",
+                "module": "src/carousel/root/carousel-root.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "watched",
+              "type": {
+                "text": "HTMLElement | undefined"
+              },
+              "privacy": "private",
+              "description": "The pane being watched, so a re-rendered run moves the watch with it.",
+              "inheritedFrom": {
+                "name": "HelixHeadlessCarousel",
+                "module": "src/carousel/root/carousel-root.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "watchPane",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Starts or stops watching, according to what the count was asked to be.\n\n**The pane and not the track, because both questions move it.** A narrower\ntrack divides into a narrower pane, and so does a slide arriving or leaving\nwhere the panes grow to fill a track holding everything it has. A watch on\nthe track answers the first and sleeps through the second.\n\n**An observation is delivered after layout and inside the same rendering\nstep**, and the update it asks for is a microtask on the end of it, so the\ndots are added to a frame that has not been painted. Taking the reading\nfrom `updated` instead would be the same arithmetic one Lit warning\nearlier, and the warning is about the right thing: a render that has to\nread layout is a render that has to run twice.\n\nCalled from `connectedCallback`, `firstUpdated` and `updated`, so a\nconsumer switching to `auto` after mount is watched, one switching away\nstops being, and a carousel moved in the DOM is watched again. Observing is\nwhat asks for the first reading, so the watch is rebuilt rather than kept\nacross a mode change.",
+              "inheritedFrom": {
+                "name": "HelixHeadlessCarousel",
+                "module": "src/carousel/root/carousel-root.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "panes",
@@ -14356,9 +14487,9 @@
             {
               "name": "per-view",
               "type": {
-                "text": "number | undefined"
+                "text": "number | 'auto' | undefined"
               },
-              "description": "How many slides are shown across the track at once. Absent shows one.\n\n**Here rather than on the styled tier, because it decides how many places\nthe track can stop.** From the stylesheet it looks like a width, one rule\nper value setting a custom property that the slides divide the track by.\nBut a carousel showing four of six slides has three positions, not six, and\neverything that counts positions is in this file. Declared up there, `goTo`\nclamps to the last *slide*, so three of the six indicators point at an\noffset the track has already reached: pressing next walks the dots to the\nend while the slides stop moving a third of the way through.\n\n**The number is published to the styles rather than enumerated by them**,\nas `--carousel-per-view` on the track, which is what keeps a width and a\ncount from disagreeing. A sheet can only name a value it wrote a rule for,\nso the styled tier enumerated `per-view=\"2\"` through `5` and called five a\njudgment; above it the pane fell back to one across while this file went on\ncounting positions. Measured in Chromium over eight slides, six across gave\nthree dots, a pane taking the whole track and five slides reachable only by\ndragging. Written from here there is no ceiling to exceed, and a consumer's\nown sheet reads the same declaration the styled one does. `runEnd` publishes\nits correction the same way and for the same reason.\n\n**On the track and not on the host.** A custom property on the host is a\nreflected attribute by another name: it would arrive on upgrade, and a\nconsumer's server markup never had it. Inside the component's own shadow\nroot it serializes with the rest of the template on the server, and the\ntrack's own declaration beats anything a consumer inherits in, so the\nattribute is the one answer to how wide a pane is.\n\nA value the track cannot honor is taken to the nearest one it can, by\n`across`, and both tiers read that rather than this.\n\nNo default, because it reflects. A reflected property with a value writes\nits attribute on upgrade, and the host then carries something a consumer's\nserver markup never had, which React reports as a mismatch. The one-across\ncase is the absent attribute, and the styles read it that way.",
+              "description": "How many slides are shown across the track at once. Absent shows one.\n\n**Here rather than on the styled tier, because it decides how many places\nthe track can stop.** From the stylesheet it looks like a width, one rule\nper value setting a custom property that the slides divide the track by.\nBut a carousel showing four of six slides has three positions, not six, and\neverything that counts positions is in this file. Declared up there, `goTo`\nclamps to the last *slide*, so three of the six indicators point at an\noffset the track has already reached: pressing next walks the dots to the\nend while the slides stop moving a third of the way through.\n\n**The number is published to the styles rather than enumerated by them**,\nas `--carousel-per-view` on the track, which is what keeps a width and a\ncount from disagreeing. A sheet can only name a value it wrote a rule for,\nso the styled tier enumerated `per-view=\"2\"` through `5` and called five a\njudgment; above it the pane fell back to one across while this file went on\ncounting positions. Measured in Chromium over eight slides, six across gave\nthree dots, a pane taking the whole track and five slides reachable only by\ndragging. Written from here there is no ceiling to exceed, and a consumer's\nown sheet reads the same declaration the styled one does. `runEnd` publishes\nits correction the same way and for the same reason.\n\n**On the track and not on the host.** A custom property on the host is a\nreflected attribute by another name: it would arrive on upgrade, and a\nconsumer's server markup never had it. Inside the component's own shadow\nroot it serializes with the rest of the template on the server, and the\ntrack's own declaration beats anything a consumer inherits in, so the\nattribute is the one answer to how wide a pane is.\n\nA value the track cannot honor is taken to the nearest one it can, by\n`across`, and both tiers read that rather than this.\n\n**`auto` fits as many as the track can hold**, at `--carousel-slide-min`\napiece, and nothing is written onto the track: the count is the sheet's,\nand the sheet's alone, because it is the one number here CSS can work out\nfor itself. Everything it takes is a length the sheet already has, so the\npanes are laid out at their final width by the first rule that runs, on a\nserver's markup as on the client's, and no script is waited on. That is the\nwhole reason a declared count was ever the only option: a carousel that\nasks how wide its container is can only ask on the client, so the panes go\ndown at one width and move to another when the answer arrives. Written\ninline the count would outrank the sheet that computes it, which is why an\n`auto` track is handed nothing. A count stays for the design that calls for\nexactly three.\n\nThe styled sheet says how it divides, and the headless `auto` example\ncarries the same three lines for a consumer writing their own.\n\n**A value rather than the resting behavior**, which is what the\nresponsiveness policy asks of every axis that a box decides: a splitter\nturns on `orientation=\"auto\"` and a plain one does not turn at all. Fitting\nchanges what the carousel *does*, since how many are across is how many\nplaces the track can stop, so a carousel that had not asked for it would\nfind its position count moving with the window.\n\nNo default, because it reflects. A reflected property with a value writes\nits attribute on upgrade, and the host then carries something a consumer's\nserver markup never had, which React reports as a mismatch. The one-across\ncase is the absent attribute, and the styles read it that way.",
               "fieldName": "perView",
               "inheritedFrom": {
                 "name": "HelixHeadlessCarousel",
@@ -14389,6 +14520,10 @@
                 "description": "Slides with controls and indicators, one at a time.",
                 "slug": "preview"
               },
+              {
+                "description": "As many slides as the track holds, from a minimum width and no count.",
+                "slug": "auto"
+              },
               {
                 "description": "A carousel the page owns, so the slide it shows can be driven from elsewhere.",
                 "slug": "controlled"
@@ -93482,7 +93617,7 @@
                 "text": "number"
               },
               "default": "0",
-              "description": "What the panel's height becomes when it is closed.\n\nZero closes it outright. A panel whose contents include the control that\nreopens it, a row of tabs being the usual one, wants that row left showing,\nand only whoever slotted it knows how tall that is.",
+              "description": "What the panel's height becomes when it is closed.\n\nZero closes it outright. A panel whose contents include the control that\nreopens it, a row of tabs being the usual one, wants that row left showing,\nand only whoever slotted it knows how tall that is.\n\n**A floor rather than a second state**, which is what keeps `panel-size` the\nwhole truth about the panel: a divider driven to the end lands here and\n`panel-size` reads this number, so \"closed\" is something a consumer already\nstores rather than a property they have to learn. The splitter inside has a\n`collapsed` of its own and it is refused, for the reason `handleCollapse`\ngives.",
               "attribute": "panel-collapsed-size"
             },
             {
@@ -93592,6 +93727,16 @@
               "description": "`panel-collapsed-size` in the units the splitter works in.",
               "readonly": true
             },
+            {
+              "kind": "field",
+              "name": "panelFloor",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "description": "The least the panel goes to, in the pixels this element holds it in.\n\nThe same number as `panelSliver` and not the same arithmetic, which is the\npoint of having both: bounding the splitter at `100 - panelSliver` instead\nwould ask a percentage to come back through a string and compare equal to\nthe one the splitter derives, and the collapse it is meant to land on is an\n`>=` on those two floats. Held here, in whole pixels a consumer stated, it\nis exact.",
+              "readonly": true
+            },
             {
               "kind": "method",
               "name": "fromSource",
@@ -93739,6 +93884,13 @@
               "privacy": "private",
               "readonly": true
             },
+            {
+              "kind": "field",
+              "name": "handleCollapse",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Refuses a pane of either splitter declaring itself shut.\n\n**The collapse is a second state, and this element has nowhere to put\none.** A splitter's `collapsed` overrides its `position` and remembers what\nit was open at, and it answers to neither `split` nor `panel-size`. Allowed\nin here, it would leave the arrangement in a state nothing outside this\nelement can see or set: assigning `panel-size` back moves nothing while\n`collapsed` stands, and a consumer who stored the two numbers this element\npublishes and restored a sandbox from them would get it open. That is one\nelement holding the arrangement and the other showing it, which is the state\nthe two requests above were rewritten to end.\n\n**So \"shut\" is spelled in pixels here.** `panel-collapsed-size` is the floor\n`handlePanelChange` holds the panel to, `panel-size` reads it when the\ndivider is at the end, and `helix-before-panel-resize` is where a consumer\nhears about it, in the units they already store. That is the same trade the\nother two make: the sandbox is the single decision point because it refuses\nwhat the splitter asks and re-announces the move in its own vocabulary.\n\n**Stopped as well as refused**, because `start` and `end` name the panes of\na splitter a consumer of this element is not supposed to know about, and the\ntwo events above already say which divider moved. A collapse from something\nslotted into a pane is somebody else's and passes through untouched, which\nis what `target` against `currentTarget` is asking.\n\nReached at all only since Splitter stopped returning on a refused\n`helix-before-resize`. While it did, every collapse in here was unreachable\nand `panel-collapsed-size` was inert with it."
+            },
             {
               "kind": "method",
               "name": "answer",
@@ -94120,7 +94272,7 @@
               "type": {
                 "text": "HelixBeforePanelResizeEvent"
               },
-              "description": "Fired before the panel's divider is let go, with its height in pixels. Cancelable: refusing it takes the decision and nothing moves.",
+              "description": "Fired before the panel's divider is let go, with its height in pixels, and a panel driven shut arrives as `panel-collapsed-size`, which is the least it goes to. Cancelable: refusing it takes the decision and nothing moves.",
               "name": "helix-before-panel-resize",
               "reactProp": "onhelix-before-panel-resize"
             },
@@ -94202,7 +94354,7 @@
                 "text": "number"
               },
               "default": "0",
-              "description": "What the panel's height becomes when it is closed.\n\nZero closes it outright. A panel whose contents include the control that\nreopens it, a row of tabs being the usual one, wants that row left showing,\nand only whoever slotted it knows how tall that is.",
+              "description": "What the panel's height becomes when it is closed.\n\nZero closes it outright. A panel whose contents include the control that\nreopens it, a row of tabs being the usual one, wants that row left showing,\nand only whoever slotted it knows how tall that is.\n\n**A floor rather than a second state**, which is what keeps `panel-size` the\nwhole truth about the panel: a divider driven to the end lands here and\n`panel-size` reads this number, so \"closed\" is something a consumer already\nstores rather than a property they have to learn. The splitter inside has a\n`collapsed` of its own and it is refused, for the reason `handleCollapse`\ngives.",
               "fieldName": "panelCollapsedSize"
             },
             {
@@ -106076,7 +106228,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**The second announcement is conditional on the first, because it is derived\nfrom it.** `shutAt` reads the position the gesture ended on, so a refused\n`helix-before-resize` leaves a collapse computed from a number that was\nrefused. Announced anyway, the refusal produced the outcome it was refusing:\nmeasured on a divider at 40 with a listener calling `preventDefault`, Home\nleft `position` reporting 0 and `collapsed` reporting `start`, because the\ncollapse applied and `position` reads the sliver once a pane is shut. The\nreturn of the first request is what says so, and it was being dropped: a\ncancelable event dispatched as a bare statement with nothing reading the\nanswer, which is the shape the navigation cohort named on `Outline` and left.\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. What a consumer cannot have is a pane that collapses\nout from under a position they said no to.\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 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.",
               "inheritedFrom": {
                 "name": "HelixHeadlessSplitter",
                 "module": "src/splitter/root/splitter-root.ts"
@@ -106879,7 +107031,7 @@
               "type": {
                 "text": "HelixBeforeCollapseEvent"
               },
-              "description": "Fired before a pane shuts or reopens, and only where the position it is derived from stood. Cancelable: refusing it leaves the pane as it was and the divider where the gesture put it.",
+              "description": "Fired before a pane shuts or reopens, whether or not the resize that reached it was allowed, and carrying its own position: a shut pane sits at `collapsed-size` rather than at the number the resize named. Cancelable: refusing it leaves the pane as it was and the divider where the gesture put it.",
               "name": "helix-before-collapse",
               "reactProp": "onhelix-before-collapse",
               "inheritedFrom": {
@@ -106891,7 +107043,7 @@
               "type": {
                 "text": "HelixBeforeResizeEvent"
               },
-              "description": "Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own.",
+              "description": "Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the position and leaves the rest of the gesture, so a collapse the gesture reached is still announced and still yours to refuse. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own.",
               "name": "helix-before-resize",
               "reactProp": "onhelix-before-resize",
               "inheritedFrom": {

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

@@ -194,6 +194,21 @@ scrollbar-width: none;
 display: none;
 }
 
+:host([per-view="auto"]:not([orientation="vertical"])) [part="track"] {
+--carousel-per-view: max(
+1,
+round(
+down,
+calc(
+(100cqi + var(--_carousel-gap)) /
+(var(--carousel-slide-min, 100cqi) + var(--_carousel-gap))
+),
+1
+)
+);
+container-type: inline-size;
+}
+
 :host([orientation="vertical"]) [part="track"] {
 block-size: var(--carousel-block-size, 20rem);
 flex-direction: column;
@@ -209,6 +224,10 @@ margin-inline-end: var(--carousel-run-end, 0px);
 scroll-snap-align: start;
 }
 
+:host([per-view="auto"]:not([orientation="vertical"])) [part="slide"] {
+flex-grow: 1;
+}
+
 [part="slide"] ::slotted(*) {
 flex: 1 1 0;
 min-block-size: 0;

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

@@ -33,7 +33,7 @@ import type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';
  * @slot toolbar - A bar across the top, spanning both panes.
  *
  * @event {HelixBeforeEditEvent} helix-before-edit - Fired before the source is edited, by the source pane and heard here. Cancelable: refusing it takes the decision and nothing moves.
- * @event {HelixBeforePanelResizeEvent} helix-before-panel-resize - Fired before the panel's divider is let go, with its height in pixels. Cancelable: refusing it takes the decision and nothing moves.
+ * @event {HelixBeforePanelResizeEvent} helix-before-panel-resize - Fired before the panel's divider is let go, with its height in pixels, and a panel driven shut arrives as `panel-collapsed-size`, which is the least it goes to. Cancelable: refusing it takes the decision and nothing moves.
  * @event {HelixBeforeSplitEvent} helix-before-split - Fired before the panes' divider is let go, with the lead pane's share. Cancelable: refusing it takes the decision and nothing moves.
  * @event {HelixCaretEvent} helix-caret - Fired when the cursor moves in the source, by the source pane and heard here.
  * @event {HelixConsoleEvent} helix-console - Relayed from the frame by the preview pane, one per console call.
@@ -108,6 +108,13 @@ export declare class HelixSandbox extends HelixElement {
      * Zero closes it outright. A panel whose contents include the control that
      * reopens it, a row of tabs being the usual one, wants that row left showing,
      * and only whoever slotted it knows how tall that is.
+     *
+     * **A floor rather than a second state**, which is what keeps `panel-size` the
+     * whole truth about the panel: a divider driven to the end lands here and
+     * `panel-size` reads this number, so "closed" is something a consumer already
+     * stores rather than a property they have to learn. The splitter inside has a
+     * `collapsed` of its own and it is refused, for the reason `handleCollapse`
+     * gives.
      */
     panelCollapsedSize: number;
     /**
@@ -176,6 +183,17 @@ export declare class HelixSandbox extends HelixElement {
     private get homePanelPosition();
     /** `panel-collapsed-size` in the units the splitter works in. */
     private get panelSliver();
+    /**
+     * The least the panel goes to, in the pixels this element holds it in.
+     *
+     * The same number as `panelSliver` and not the same arithmetic, which is the
+     * point of having both: bounding the splitter at `100 - panelSliver` instead
+     * would ask a percentage to come back through a string and compare equal to
+     * the one the splitter derives, and the collapse it is meant to land on is an
+     * `>=` on those two floats. Held here, in whole pixels a consumer stated, it
+     * is exact.
+     */
+    private get panelFloor();
     /**
      * Whether a change came from inside this sandbox's source region.
      *
@@ -296,6 +314,37 @@ export declare class HelixSandbox extends HelixElement {
      */
     private readonly handlePanesChange;
     private readonly handlePanelChange;
+    /**
+     * Refuses a pane of either splitter declaring itself shut.
+     *
+     * **The collapse is a second state, and this element has nowhere to put
+     * one.** A splitter's `collapsed` overrides its `position` and remembers what
+     * it was open at, and it answers to neither `split` nor `panel-size`. Allowed
+     * in here, it would leave the arrangement in a state nothing outside this
+     * element can see or set: assigning `panel-size` back moves nothing while
+     * `collapsed` stands, and a consumer who stored the two numbers this element
+     * publishes and restored a sandbox from them would get it open. That is one
+     * element holding the arrangement and the other showing it, which is the state
+     * the two requests above were rewritten to end.
+     *
+     * **So "shut" is spelled in pixels here.** `panel-collapsed-size` is the floor
+     * `handlePanelChange` holds the panel to, `panel-size` reads it when the
+     * divider is at the end, and `helix-before-panel-resize` is where a consumer
+     * hears about it, in the units they already store. That is the same trade the
+     * other two make: the sandbox is the single decision point because it refuses
+     * what the splitter asks and re-announces the move in its own vocabulary.
+     *
+     * **Stopped as well as refused**, because `start` and `end` name the panes of
+     * a splitter a consumer of this element is not supposed to know about, and the
+     * two events above already say which divider moved. A collapse from something
+     * slotted into a pane is somebody else's and passes through untouched, which
+     * is what `target` against `currentTarget` is asking.
+     *
+     * Reached at all only since Splitter stopped returning on a refused
+     * `helix-before-resize`. While it did, every collapse in here was unreachable
+     * and `panel-collapsed-size` was inert with it.
+     */
+    private readonly handleCollapse;
     /**
      * Puts a divider where this element says it is.
      *

package/dist/sandbox/root/sandbox-root.js

@@ -83,10 +83,17 @@ let HelixSandbox = class HelixSandbox extends HelixElement {
             event.stopPropagation();
             event.preventDefault();
             if (this.bodyHeight > 0) {
-                this.requestPanelSize(Math.max(0, ((100 - Number(value)) / 100) * this.bodyHeight));
+                this.requestPanelSize(Math.max(this.panelFloor, ((100 - Number(value)) / 100) * this.bodyHeight));
             }
             this.answer(event.currentTarget, this.panelPosition);
         };
+        this.handleCollapse = (event) => {
+            if (event.target !== event.currentTarget) {
+                return;
+            }
+            event.stopPropagation();
+            event.preventDefault();
+        };
         this.readPanel = () => {
             this.hasPanel = this.querySelector(':scope > [slot="panel"]') !== null;
         };
@@ -114,6 +121,10 @@ let HelixSandbox = class HelixSandbox extends HelixElement {
         }
         return Math.min(100, Math.max(0, (this.panelCollapsedSize / this.bodyHeight) * 100));
     }
+    get panelFloor() {
+        const size = Number.isFinite(this.panelCollapsedSize) ? this.panelCollapsedSize : 0;
+        return Math.min(this.bodyHeight, Math.max(0, size));
+    }
     fromSource(target) {
         if (!(target instanceof Node)) {
             return false;
@@ -219,6 +230,7 @@ let HelixSandbox = class HelixSandbox extends HelixElement {
         default-position=${this.homePanelPosition}
         min=${100 - PANEL_MAX * 100}
         .position=${this.panelPosition}
+        @helix-before-collapse=${this.handleCollapse}
         @helix-before-resize=${this.handlePanelChange}
       >
         <helix-splitter
@@ -229,6 +241,7 @@ let HelixSandbox = class HelixSandbox extends HelixElement {
           label=${this.separatorLabel}
           orientation=${vertical ? 'vertical' : 'horizontal'}
           .position=${split}
+          @helix-before-collapse=${this.handleCollapse}
           @helix-before-resize=${this.handlePanesChange}
         >
           ${''}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fusion.dev/helix",
   "description": "Styled component tier. Extends the headless tier with token-driven presentation.",
-  "version": "0.50.0",
+  "version": "0.51.0",
   "license": "MIT",
   "author": "Ross Sheppard <ross.sheppard@fusion.dev>",
   "repository": {
@@ -47,14 +47,14 @@
   },
   "bugs": "https://github.com/project-fusion/fusion/issues",
   "dependencies": {
-    "@fusion.dev/helix-core": "0.50.0",
-    "@fusion.dev/helix-headless": "0.50.0",
-    "@fusion.dev/helix-styles": "0.50.0"
+    "@fusion.dev/helix-core": "0.51.0",
+    "@fusion.dev/helix-headless": "0.51.0",
+    "@fusion.dev/helix-styles": "0.51.0"
   },
   "devDependencies": {
     "@custom-elements-manifest/analyzer": "^0.11.0",
-    "@fusion.dev/helix-cem": "0.50.0",
-    "@fusion.dev/helix-testing": "0.50.0",
+    "@fusion.dev/helix-cem": "0.51.0",
+    "@fusion.dev/helix-testing": "0.51.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

@@ -2838,6 +2838,29 @@ attribute is the one answer to how wide a pane is.
 A value the track cannot honor is taken to the nearest one it can, by
 `across`, and both tiers read that rather than this.
 
+**`auto` fits as many as the track can hold**, at `--carousel-slide-min`
+apiece, and nothing is written onto the track: the count is the sheet's,
+and the sheet's alone, because it is the one number here CSS can work out
+for itself. Everything it takes is a length the sheet already has, so the
+panes are laid out at their final width by the first rule that runs, on a
+server's markup as on the client's, and no script is waited on. That is the
+whole reason a declared count was ever the only option: a carousel that
+asks how wide its container is can only ask on the client, so the panes go
+down at one width and move to another when the answer arrives. Written
+inline the count would outrank the sheet that computes it, which is why an
+`auto` track is handed nothing. A count stays for the design that calls for
+exactly three.
+
+The styled sheet says how it divides, and the headless `auto` example
+carries the same three lines for a consumer writing their own.
+
+**A value rather than the resting behavior**, which is what the
+responsiveness policy asks of every axis that a box decides: a splitter
+turns on `orientation="auto"` and a plain one does not turn at all. Fitting
+changes what the carousel *does*, since how many are across is how many
+places the track can stop, so a carousel that had not asked for it would
+find its position count moving with the window.
+
 No default, because it reflects. A reflected property with a value writes
 its attribute on upgrade, and the host then carries something a consumer's
 server markup never had, which React reports as a mismatch. The one-across
@@ -2875,6 +2898,29 @@ attribute is the one answer to how wide a pane is.
 A value the track cannot honor is taken to the nearest one it can, by
 `across`, and both tiers read that rather than this.
 
+**`auto` fits as many as the track can hold**, at `--carousel-slide-min`
+apiece, and nothing is written onto the track: the count is the sheet's,
+and the sheet's alone, because it is the one number here CSS can work out
+for itself. Everything it takes is a length the sheet already has, so the
+panes are laid out at their final width by the first rule that runs, on a
+server's markup as on the client's, and no script is waited on. That is the
+whole reason a declared count was ever the only option: a carousel that
+asks how wide its container is can only ask on the client, so the panes go
+down at one width and move to another when the answer arrives. Written
+inline the count would outrank the sheet that computes it, which is why an
+`auto` track is handed nothing. A count stays for the design that calls for
+exactly three.
+
+The styled sheet says how it divides, and the headless `auto` example
+carries the same three lines for a consumer writing their own.
+
+**A value rather than the resting behavior**, which is what the
+responsiveness policy asks of every axis that a box decides: a splitter
+turns on `orientation="auto"` and a plain one does not turn at all. Fitting
+changes what the carousel *does*, since how many are across is how many
+places the track can stop, so a carousel that had not asked for it would
+find its position count moving with the window.
+
 No default, because it reflects. A reflected property with a value writes
 its attribute on upgrade, and the host then carries something a consumer's
 server markup never had, which React reports as a mismatch. The one-across
@@ -3111,6 +3157,29 @@ attribute is the one answer to how wide a pane is.
 A value the track cannot honor is taken to the nearest one it can, by
 `across`, and both tiers read that rather than this.
 
+**`auto` fits as many as the track can hold**, at `--carousel-slide-min`
+apiece, and nothing is written onto the track: the count is the sheet's,
+and the sheet's alone, because it is the one number here CSS can work out
+for itself. Everything it takes is a length the sheet already has, so the
+panes are laid out at their final width by the first rule that runs, on a
+server's markup as on the client's, and no script is waited on. That is the
+whole reason a declared count was ever the only option: a carousel that
+asks how wide its container is can only ask on the client, so the panes go
+down at one width and move to another when the answer arrives. Written
+inline the count would outrank the sheet that computes it, which is why an
+`auto` track is handed nothing. A count stays for the design that calls for
+exactly three.
+
+The styled sheet says how it divides, and the headless `auto` example
+carries the same three lines for a consumer writing their own.
+
+**A value rather than the resting behavior**, which is what the
+responsiveness policy asks of every axis that a box decides: a splitter
+turns on `orientation="auto"` and a plain one does not turn at all. Fitting
+changes what the carousel *does*, since how many are across is how many
+places the track can stop, so a carousel that had not asked for it would
+find its position count moving with the window.
+
 No default, because it reflects. A reflected property with a value writes
 its attribute on upgrade, and the host then carries something a consumer's
 server markup never had, which React reports as a mismatch. The one-across
@@ -3148,6 +3217,29 @@ attribute is the one answer to how wide a pane is.
 A value the track cannot honor is taken to the nearest one it can, by
 `across`, and both tiers read that rather than this.
 
+**`auto` fits as many as the track can hold**, at `--carousel-slide-min`
+apiece, and nothing is written onto the track: the count is the sheet's,
+and the sheet's alone, because it is the one number here CSS can work out
+for itself. Everything it takes is a length the sheet already has, so the
+panes are laid out at their final width by the first rule that runs, on a
+server's markup as on the client's, and no script is waited on. That is the
+whole reason a declared count was ever the only option: a carousel that
+asks how wide its container is can only ask on the client, so the panes go
+down at one width and move to another when the answer arrives. Written
+inline the count would outrank the sheet that computes it, which is why an
+`auto` track is handed nothing. A count stays for the design that calls for
+exactly three.
+
+The styled sheet says how it divides, and the headless `auto` example
+carries the same three lines for a consumer writing their own.
+
+**A value rather than the resting behavior**, which is what the
+responsiveness policy asks of every axis that a box decides: a splitter
+turns on `orientation="auto"` and a plain one does not turn at all. Fitting
+changes what the carousel *does*, since how many are across is how many
+places the track can stop, so a carousel that had not asked for it would
+find its position count moving with the window.
+
 No default, because it reflects. A reflected property with a value writes
 its attribute on upgrade, and the host then carries something a consumer's
 server markup never had, which React reports as a mismatch. The one-across
@@ -14599,13 +14691,27 @@ attribute at all. */
 
 Zero closes it outright. A panel whose contents include the control that
 reopens it, a row of tabs being the usual one, wants that row left showing,
-and only whoever slotted it knows how tall that is. */
+and only whoever slotted it knows how tall that is.
+
+**A floor rather than a second state**, which is what keeps `panel-size` the
+whole truth about the panel: a divider driven to the end lands here and
+`panel-size` reads this number, so "closed" is something a consumer already
+stores rather than a property they have to learn. The splitter inside has a
+`collapsed` of its own and it is refused, for the reason `handleCollapse`
+gives. */
   "panel-collapsed-size"?: (HelixSandbox["panelCollapsedSize"] | `${number}`) | undefined;
   /** What the panel's height becomes when it is closed.
 
 Zero closes it outright. A panel whose contents include the control that
 reopens it, a row of tabs being the usual one, wants that row left showing,
-and only whoever slotted it knows how tall that is. */
+and only whoever slotted it knows how tall that is.
+
+**A floor rather than a second state**, which is what keeps `panel-size` the
+whole truth about the panel: a divider driven to the end lands here and
+`panel-size` reads this number, so "closed" is something a consumer already
+stores rather than a property they have to learn. The splitter inside has a
+`collapsed` of its own and it is refused, for the reason `handleCollapse`
+gives. */
   panelCollapsedSize?: (HelixSandbox["panelCollapsedSize"]) | undefined;
   /** Accessible name for the panel's divider. */
   "panel-label"?: (HelixSandbox["panelLabel"]) | undefined;
@@ -14624,7 +14730,7 @@ and only whoever slotted it knows how tall that is. */
 
   /** Fired before the source is edited, by the source pane and heard here. Cancelable: refusing it takes the decision and nothing moves. */
   "onhelix-before-edit"?: ((e: HelixSandboxHelixBeforeEditElementEvent) => void) | undefined;
-  /** Fired before the panel's divider is let go, with its height in pixels. Cancelable: refusing it takes the decision and nothing moves. */
+  /** Fired before the panel's divider is let go, with its height in pixels, and a panel driven shut arrives as `panel-collapsed-size`, which is the least it goes to. Cancelable: refusing it takes the decision and nothing moves. */
   "onhelix-before-panel-resize"?: ((
     e: HelixSandboxHelixBeforePanelResizeElementEvent,
   ) => void) | undefined;
@@ -14704,13 +14810,27 @@ attribute at all. */
 
 Zero closes it outright. A panel whose contents include the control that
 reopens it, a row of tabs being the usual one, wants that row left showing,
-and only whoever slotted it knows how tall that is. */
+and only whoever slotted it knows how tall that is.
+
+**A floor rather than a second state**, which is what keeps `panel-size` the
+whole truth about the panel: a divider driven to the end lands here and
+`panel-size` reads this number, so "closed" is something a consumer already
+stores rather than a property they have to learn. The splitter inside has a
+`collapsed` of its own and it is refused, for the reason `handleCollapse`
+gives. */
   "attr:panel-collapsed-size"?: (HelixSandbox["panelCollapsedSize"] | `${number}`) | undefined;
   /** What the panel's height becomes when it is closed.
 
 Zero closes it outright. A panel whose contents include the control that
 reopens it, a row of tabs being the usual one, wants that row left showing,
-and only whoever slotted it knows how tall that is. */
+and only whoever slotted it knows how tall that is.
+
+**A floor rather than a second state**, which is what keeps `panel-size` the
+whole truth about the panel: a divider driven to the end lands here and
+`panel-size` reads this number, so "closed" is something a consumer already
+stores rather than a property they have to learn. The splitter inside has a
+`collapsed` of its own and it is refused, for the reason `handleCollapse`
+gives. */
   "prop:panelCollapsedSize"?: (HelixSandbox["panelCollapsedSize"]) | undefined;
   /** Accessible name for the panel's divider. */
   "attr:panel-label"?: (HelixSandbox["panelLabel"]) | undefined;
@@ -14728,7 +14848,7 @@ and only whoever slotted it knows how tall that is. */
   "prop:split"?: (HelixSandbox["split"]) | undefined;
   /** Fired before the source is edited, by the source pane and heard here. Cancelable: refusing it takes the decision and nothing moves. */
   "on:helix-before-edit"?: ((e: HelixSandboxHelixBeforeEditElementEvent) => void) | undefined;
-  /** Fired before the panel's divider is let go, with its height in pixels. Cancelable: refusing it takes the decision and nothing moves. */
+  /** Fired before the panel's divider is let go, with its height in pixels, and a panel driven shut arrives as `panel-collapsed-size`, which is the least it goes to. Cancelable: refusing it takes the decision and nothing moves. */
   "on:helix-before-panel-resize"?: ((
     e: HelixSandboxHelixBeforePanelResizeElementEvent,
   ) => void) | undefined;
@@ -16063,11 +16183,11 @@ has an honest answer. */
   /** How far one arrow press moves it, as a percentage. */
   step?: (HelixSplitter["step"]) | undefined;
 
-  /** Fired before a pane shuts or reopens, and only where the position it is derived from stood. Cancelable: refusing it leaves the pane as it was and the divider where the gesture put it. */
+  /** Fired before a pane shuts or reopens, whether or not the resize that reached it was allowed, and carrying its own position: a shut pane sits at `collapsed-size` rather than at the number the resize named. Cancelable: refusing it leaves the pane as it was and the divider where the gesture put it. */
   "onhelix-before-collapse"?: ((
     e: HelixSplitterHelixBeforeCollapseElementEvent,
   ) => void) | undefined;
-  /** Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own. */
+  /** Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the position and leaves the rest of the gesture, so a collapse the gesture reached is still announced and still yours to refuse. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own. */
   "onhelix-before-resize"?: ((
     e: HelixSplitterHelixBeforeResizeElementEvent,
   ) => void) | undefined;
@@ -16183,11 +16303,11 @@ has an honest answer. */
   "prop:orientation"?: (HelixSplitter["orientation"]) | undefined;
   /** How far one arrow press moves it, as a percentage. */
   "prop:step"?: (HelixSplitter["step"]) | undefined;
-  /** Fired before a pane shuts or reopens, and only where the position it is derived from stood. Cancelable: refusing it leaves the pane as it was and the divider where the gesture put it. */
+  /** Fired before a pane shuts or reopens, whether or not the resize that reached it was allowed, and carrying its own position: a shut pane sits at `collapsed-size` rather than at the number the resize named. Cancelable: refusing it leaves the pane as it was and the divider where the gesture put it. */
   "on:helix-before-collapse"?: ((
     e: HelixSplitterHelixBeforeCollapseElementEvent,
   ) => void) | undefined;
-  /** Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own. */
+  /** Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the position and leaves the rest of the gesture, so a collapse the gesture reached is still announced and still yours to refuse. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own. */
   "on:helix-before-resize"?: ((
     e: HelixSplitterHelixBeforeResizeElementEvent,
   ) => void) | undefined;
@@ -23019,6 +23139,29 @@ export type CustomElements = {
    * A value the track cannot honor is taken to the nearest one it can, by
    * `across`, and both tiers read that rather than this.
    *
+   * **`auto` fits as many as the track can hold**, at `--carousel-slide-min`
+   * apiece, and nothing is written onto the track: the count is the sheet's,
+   * and the sheet's alone, because it is the one number here CSS can work out
+   * for itself. Everything it takes is a length the sheet already has, so the
+   * panes are laid out at their final width by the first rule that runs, on a
+   * server's markup as on the client's, and no script is waited on. That is the
+   * whole reason a declared count was ever the only option: a carousel that
+   * asks how wide its container is can only ask on the client, so the panes go
+   * down at one width and move to another when the answer arrives. Written
+   * inline the count would outrank the sheet that computes it, which is why an
+   * `auto` track is handed nothing. A count stays for the design that calls for
+   * exactly three.
+   *
+   * The styled sheet says how it divides, and the headless `auto` example
+   * carries the same three lines for a consumer writing their own.
+   *
+   * **A value rather than the resting behavior**, which is what the
+   * responsiveness policy asks of every axis that a box decides: a splitter
+   * turns on `orientation="auto"` and a plain one does not turn at all. Fitting
+   * changes what the carousel *does*, since how many are across is how many
+   * places the track can stop, so a carousel that had not asked for it would
+   * find its position count moving with the window.
+   *
    * No default, because it reflects. A reflected property with a value writes
    * its attribute on upgrade, and the host then carries something a consumer's
    * server markup never had, which React reports as a mismatch. The one-across
@@ -23028,7 +23171,11 @@ export type CustomElements = {
    * A window of `perView` slides sliding one at a time over `n` of them stops
    * `n - perView + 1` times, so six slides four across is three: 0 to 3, 1 to 4,
    * 2 to 5. One at minimum, since a carousel showing everything it has still
-   * has the one place to be. (property only) (readonly)
+   * has the one place to be.
+   *
+   * One across until a fitted track has been laid out, which is the same answer
+   * a carousel that has never been told anything gives, and the dots are
+   * withheld rather than counted from it. See `across`. (property only) (readonly)
    * - `slides`: The slides, in light-DOM order. Empty on the server, which has no tree. (property only) (readonly)
    * - `whenSettled`: Resolves a frame after the first update, when transitions are switched on.
    *
@@ -23077,8 +23224,9 @@ export type CustomElements = {
    * - `--carousel-block-size`: Height of a vertical track. (default: `undefined`)
    * - `--carousel-gap`: Space between slides. A sheet sets it and the component measures the run with it. (default: `undefined`)
    * - `--carousel-pane`: The size one pane is laid out at. A sheet sets it and the component measures the run with it. (default: `undefined`)
-   * - `--carousel-per-view`: How many slides go across, written onto the track by the component so a sheet divides the track by the same number the positions are counted from. Read it rather than selecting on `per-view`, which cannot be enumerated without a ceiling. See `perView`. (default: `undefined`)
+   * - `--carousel-per-view`: How many slides go across, written onto the track by the component so a sheet divides the track by the same number the positions are counted from. Read it rather than selecting on `per-view`, which cannot be enumerated without a ceiling. Under `per-view="auto"` the component writes nothing and the sheet declares it instead, so the same name answers in both modes. See `perView`. (default: `undefined`)
    * - `--carousel-run-end`: How far short of a whole pixel the run ends, on the last slide alone, for a sheet to take up as `margin-inline-end`. See `runEnd`. (default: `undefined`)
+   * - `--carousel-slide-min`: The narrowest a slide may be laid out, which is what `per-view="auto"` fits the track with. A length, since the sheet divides by it. Unset is the whole track, which is one across. (default: `undefined`)
    *
    * ## CSS Parts
    *
@@ -33869,6 +34017,13 @@ export type CustomElements = {
    * Zero closes it outright. A panel whose contents include the control that
    * reopens it, a row of tabs being the usual one, wants that row left showing,
    * and only whoever slotted it knows how tall that is.
+   *
+   * **A floor rather than a second state**, which is what keeps `panel-size` the
+   * whole truth about the panel: a divider driven to the end lands here and
+   * `panel-size` reads this number, so "closed" is something a consumer already
+   * stores rather than a property they have to learn. The splitter inside has a
+   * `collapsed` of its own and it is refused, for the reason `handleCollapse`
+   * gives.
    * - `panel-label`/`panelLabel`: Accessible name for the panel's divider.
    * - `panel-size`/`panelSize`: Height of the panel, in pixels.
    * - `separator-label`/`separatorLabel`: Accessible name for the divider.
@@ -33899,7 +34054,7 @@ export type CustomElements = {
    * Events that will be emitted by the component.
    *
    * - `helix-before-edit`: Fired before the source is edited, by the source pane and heard here. Cancelable: refusing it takes the decision and nothing moves.
-   * - `helix-before-panel-resize`: Fired before the panel's divider is let go, with its height in pixels. Cancelable: refusing it takes the decision and nothing moves.
+   * - `helix-before-panel-resize`: Fired before the panel's divider is let go, with its height in pixels, and a panel driven shut arrives as `panel-collapsed-size`, which is the least it goes to. Cancelable: refusing it takes the decision and nothing moves.
    * - `helix-before-split`: Fired before the panes' divider is let go, with the lead pane's share. Cancelable: refusing it takes the decision and nothing moves.
    * - `helix-caret`: Fired when the cursor moves in the source, by the source pane and heard here.
    * - `helix-console`: Relayed from the frame by the preview pane, one per console call.
@@ -35654,8 +35809,8 @@ export type CustomElements = {
    *
    * Events that will be emitted by the component.
    *
-   * - `helix-before-collapse`: Fired before a pane shuts or reopens, and only where the position it is derived from stood. Cancelable: refusing it leaves the pane as it was and the divider where the gesture put it.
-   * - `helix-before-resize`: Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own.
+   * - `helix-before-collapse`: Fired before a pane shuts or reopens, whether or not the resize that reached it was allowed, and carrying its own position: a shut pane sits at `collapsed-size` rather than at the number the resize named. Cancelable: refusing it leaves the pane as it was and the divider where the gesture put it.
+   * - `helix-before-resize`: Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the position and leaves the rest of the gesture, so a collapse the gesture reached is still announced and still yours to refuse. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own.
    *
    * ## Slots
    *
@@ -42467,6 +42622,29 @@ export type CustomElementsSolidJs = {
    * A value the track cannot honor is taken to the nearest one it can, by
    * `across`, and both tiers read that rather than this.
    *
+   * **`auto` fits as many as the track can hold**, at `--carousel-slide-min`
+   * apiece, and nothing is written onto the track: the count is the sheet's,
+   * and the sheet's alone, because it is the one number here CSS can work out
+   * for itself. Everything it takes is a length the sheet already has, so the
+   * panes are laid out at their final width by the first rule that runs, on a
+   * server's markup as on the client's, and no script is waited on. That is the
+   * whole reason a declared count was ever the only option: a carousel that
+   * asks how wide its container is can only ask on the client, so the panes go
+   * down at one width and move to another when the answer arrives. Written
+   * inline the count would outrank the sheet that computes it, which is why an
+   * `auto` track is handed nothing. A count stays for the design that calls for
+   * exactly three.
+   *
+   * The styled sheet says how it divides, and the headless `auto` example
+   * carries the same three lines for a consumer writing their own.
+   *
+   * **A value rather than the resting behavior**, which is what the
+   * responsiveness policy asks of every axis that a box decides: a splitter
+   * turns on `orientation="auto"` and a plain one does not turn at all. Fitting
+   * changes what the carousel *does*, since how many are across is how many
+   * places the track can stop, so a carousel that had not asked for it would
+   * find its position count moving with the window.
+   *
    * No default, because it reflects. A reflected property with a value writes
    * its attribute on upgrade, and the host then carries something a consumer's
    * server markup never had, which React reports as a mismatch. The one-across
@@ -42476,7 +42654,11 @@ export type CustomElementsSolidJs = {
    * A window of `perView` slides sliding one at a time over `n` of them stops
    * `n - perView + 1` times, so six slides four across is three: 0 to 3, 1 to 4,
    * 2 to 5. One at minimum, since a carousel showing everything it has still
-   * has the one place to be. (property only) (readonly)
+   * has the one place to be.
+   *
+   * One across until a fitted track has been laid out, which is the same answer
+   * a carousel that has never been told anything gives, and the dots are
+   * withheld rather than counted from it. See `across`. (property only) (readonly)
    * - `slides`: The slides, in light-DOM order. Empty on the server, which has no tree. (property only) (readonly)
    * - `whenSettled`: Resolves a frame after the first update, when transitions are switched on.
    *
@@ -42525,8 +42707,9 @@ export type CustomElementsSolidJs = {
    * - `--carousel-block-size`: Height of a vertical track. (default: `undefined`)
    * - `--carousel-gap`: Space between slides. A sheet sets it and the component measures the run with it. (default: `undefined`)
    * - `--carousel-pane`: The size one pane is laid out at. A sheet sets it and the component measures the run with it. (default: `undefined`)
-   * - `--carousel-per-view`: How many slides go across, written onto the track by the component so a sheet divides the track by the same number the positions are counted from. Read it rather than selecting on `per-view`, which cannot be enumerated without a ceiling. See `perView`. (default: `undefined`)
+   * - `--carousel-per-view`: How many slides go across, written onto the track by the component so a sheet divides the track by the same number the positions are counted from. Read it rather than selecting on `per-view`, which cannot be enumerated without a ceiling. Under `per-view="auto"` the component writes nothing and the sheet declares it instead, so the same name answers in both modes. See `perView`. (default: `undefined`)
    * - `--carousel-run-end`: How far short of a whole pixel the run ends, on the last slide alone, for a sheet to take up as `margin-inline-end`. See `runEnd`. (default: `undefined`)
+   * - `--carousel-slide-min`: The narrowest a slide may be laid out, which is what `per-view="auto"` fits the track with. A length, since the sheet divides by it. Unset is the whole track, which is one across. (default: `undefined`)
    *
    * ## CSS Parts
    *
@@ -53534,6 +53717,13 @@ export type CustomElementsSolidJs = {
    * Zero closes it outright. A panel whose contents include the control that
    * reopens it, a row of tabs being the usual one, wants that row left showing,
    * and only whoever slotted it knows how tall that is.
+   *
+   * **A floor rather than a second state**, which is what keeps `panel-size` the
+   * whole truth about the panel: a divider driven to the end lands here and
+   * `panel-size` reads this number, so "closed" is something a consumer already
+   * stores rather than a property they have to learn. The splitter inside has a
+   * `collapsed` of its own and it is refused, for the reason `handleCollapse`
+   * gives.
    * - `panel-label`/`panelLabel`: Accessible name for the panel's divider.
    * - `panel-size`/`panelSize`: Height of the panel, in pixels.
    * - `separator-label`/`separatorLabel`: Accessible name for the divider.
@@ -53564,7 +53754,7 @@ export type CustomElementsSolidJs = {
    * Events that will be emitted by the component.
    *
    * - `helix-before-edit`: Fired before the source is edited, by the source pane and heard here. Cancelable: refusing it takes the decision and nothing moves.
-   * - `helix-before-panel-resize`: Fired before the panel's divider is let go, with its height in pixels. Cancelable: refusing it takes the decision and nothing moves.
+   * - `helix-before-panel-resize`: Fired before the panel's divider is let go, with its height in pixels, and a panel driven shut arrives as `panel-collapsed-size`, which is the least it goes to. Cancelable: refusing it takes the decision and nothing moves.
    * - `helix-before-split`: Fired before the panes' divider is let go, with the lead pane's share. Cancelable: refusing it takes the decision and nothing moves.
    * - `helix-caret`: Fired when the cursor moves in the source, by the source pane and heard here.
    * - `helix-console`: Relayed from the frame by the preview pane, one per console call.
@@ -55361,8 +55551,8 @@ export type CustomElementsSolidJs = {
    *
    * Events that will be emitted by the component.
    *
-   * - `helix-before-collapse`: Fired before a pane shuts or reopens, and only where the position it is derived from stood. Cancelable: refusing it leaves the pane as it was and the divider where the gesture put it.
-   * - `helix-before-resize`: Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own.
+   * - `helix-before-collapse`: Fired before a pane shuts or reopens, whether or not the resize that reached it was allowed, and carrying its own position: a shut pane sits at `collapsed-size` rather than at the number the resize named. Cancelable: refusing it leaves the pane as it was and the divider where the gesture put it.
+   * - `helix-before-resize`: Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the position and leaves the rest of the gesture, so a collapse the gesture reached is still announced and still yours to refuse. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own.
    *
    * ## Slots
    *
@@ -60010,10 +60200,12 @@ export type CustomCssProperties = {
   "--carousel-gap"?: (string) | undefined;
   /** The size one pane is laid out at. A sheet sets it and the component measures the run with it. */
   "--carousel-pane"?: (string) | undefined;
-  /** How many slides go across, written onto the track by the component so a sheet divides the track by the same number the positions are counted from. Read it rather than selecting on `per-view`, which cannot be enumerated without a ceiling. See `perView`. */
+  /** How many slides go across, written onto the track by the component so a sheet divides the track by the same number the positions are counted from. Read it rather than selecting on `per-view`, which cannot be enumerated without a ceiling. Under `per-view="auto"` the component writes nothing and the sheet declares it instead, so the same name answers in both modes. See `perView`. */
   "--carousel-per-view"?: (string) | undefined;
   /** How far short of a whole pixel the run ends, on the last slide alone, for a sheet to take up as `margin-inline-end`. See `runEnd`. */
   "--carousel-run-end"?: (string) | undefined;
+  /** The narrowest a slide may be laid out, which is what `per-view="auto"` fits the track with. A length, since the sheet divides by it. Unset is the whole track, which is one across. */
+  "--carousel-slide-min"?: (string) | undefined;
   /** Fill behind the composer. */
   "--chat-composer-background-color"?: (string) | undefined;
   /** The composer's edge, so a theme can remove it. */

package/types/vue.d.ts

@@ -1561,6 +1561,29 @@ attribute is the one answer to how wide a pane is.
 A value the track cannot honor is taken to the nearest one it can, by
 `across`, and both tiers read that rather than this.
 
+**`auto` fits as many as the track can hold**, at `--carousel-slide-min`
+apiece, and nothing is written onto the track: the count is the sheet's,
+and the sheet's alone, because it is the one number here CSS can work out
+for itself. Everything it takes is a length the sheet already has, so the
+panes are laid out at their final width by the first rule that runs, on a
+server's markup as on the client's, and no script is waited on. That is the
+whole reason a declared count was ever the only option: a carousel that
+asks how wide its container is can only ask on the client, so the panes go
+down at one width and move to another when the answer arrives. Written
+inline the count would outrank the sheet that computes it, which is why an
+`auto` track is handed nothing. A count stays for the design that calls for
+exactly three.
+
+The styled sheet says how it divides, and the headless `auto` example
+carries the same three lines for a consumer writing their own.
+
+**A value rather than the resting behavior**, which is what the
+responsiveness policy asks of every axis that a box decides: a splitter
+turns on `orientation="auto"` and a plain one does not turn at all. Fitting
+changes what the carousel *does*, since how many are across is how many
+places the track can stop, so a carousel that had not asked for it would
+find its position count moving with the window.
+
 No default, because it reflects. A reflected property with a value writes
 its attribute on upgrade, and the host then carries something a consumer's
 server markup never had, which React reports as a mismatch. The one-across
@@ -1598,6 +1621,29 @@ attribute is the one answer to how wide a pane is.
 A value the track cannot honor is taken to the nearest one it can, by
 `across`, and both tiers read that rather than this.
 
+**`auto` fits as many as the track can hold**, at `--carousel-slide-min`
+apiece, and nothing is written onto the track: the count is the sheet's,
+and the sheet's alone, because it is the one number here CSS can work out
+for itself. Everything it takes is a length the sheet already has, so the
+panes are laid out at their final width by the first rule that runs, on a
+server's markup as on the client's, and no script is waited on. That is the
+whole reason a declared count was ever the only option: a carousel that
+asks how wide its container is can only ask on the client, so the panes go
+down at one width and move to another when the answer arrives. Written
+inline the count would outrank the sheet that computes it, which is why an
+`auto` track is handed nothing. A count stays for the design that calls for
+exactly three.
+
+The styled sheet says how it divides, and the headless `auto` example
+carries the same three lines for a consumer writing their own.
+
+**A value rather than the resting behavior**, which is what the
+responsiveness policy asks of every axis that a box decides: a splitter
+turns on `orientation="auto"` and a plain one does not turn at all. Fitting
+changes what the carousel *does*, since how many are across is how many
+places the track can stop, so a carousel that had not asked for it would
+find its position count moving with the window.
+
 No default, because it reflects. A reflected property with a value writes
 its attribute on upgrade, and the host then carries something a consumer's
 server markup never had, which React reports as a mismatch. The one-across
@@ -7517,13 +7563,27 @@ attribute at all. */
 
 Zero closes it outright. A panel whose contents include the control that
 reopens it, a row of tabs being the usual one, wants that row left showing,
-and only whoever slotted it knows how tall that is. */
+and only whoever slotted it knows how tall that is.
+
+**A floor rather than a second state**, which is what keeps `panel-size` the
+whole truth about the panel: a divider driven to the end lands here and
+`panel-size` reads this number, so "closed" is something a consumer already
+stores rather than a property they have to learn. The splitter inside has a
+`collapsed` of its own and it is refused, for the reason `handleCollapse`
+gives. */
   "panel-collapsed-size"?: (HelixSandbox["panelCollapsedSize"] | `${number}`) | undefined;
   /** What the panel's height becomes when it is closed.
 
 Zero closes it outright. A panel whose contents include the control that
 reopens it, a row of tabs being the usual one, wants that row left showing,
-and only whoever slotted it knows how tall that is. */
+and only whoever slotted it knows how tall that is.
+
+**A floor rather than a second state**, which is what keeps `panel-size` the
+whole truth about the panel: a divider driven to the end lands here and
+`panel-size` reads this number, so "closed" is something a consumer already
+stores rather than a property they have to learn. The splitter inside has a
+`collapsed` of its own and it is refused, for the reason `handleCollapse`
+gives. */
   panelCollapsedSize?: (HelixSandbox["panelCollapsedSize"]) | undefined;
   /** Accessible name for the panel's divider. */
   "panel-label"?: (HelixSandbox["panelLabel"]) | undefined;
@@ -7544,7 +7604,7 @@ and only whoever slotted it knows how tall that is. */
 export type HelixSandboxVueEvents = {
   /** Fired before the source is edited, by the source pane and heard here. Cancelable: refusing it takes the decision and nothing moves. */
   "helix-before-edit": HelixSandboxHelixBeforeEditElementEvent;
-  /** Fired before the panel's divider is let go, with its height in pixels. Cancelable: refusing it takes the decision and nothing moves. */
+  /** Fired before the panel's divider is let go, with its height in pixels, and a panel driven shut arrives as `panel-collapsed-size`, which is the least it goes to. Cancelable: refusing it takes the decision and nothing moves. */
   "helix-before-panel-resize": HelixSandboxHelixBeforePanelResizeElementEvent;
   /** Fired before the panes' divider is let go, with the lead pane's share. Cancelable: refusing it takes the decision and nothing moves. */
   "helix-before-split": HelixSandboxHelixBeforeSplitElementEvent;
@@ -8287,9 +8347,9 @@ has an honest answer. */
 };
 
 export type HelixSplitterVueEvents = {
-  /** Fired before a pane shuts or reopens, and only where the position it is derived from stood. Cancelable: refusing it leaves the pane as it was and the divider where the gesture put it. */
+  /** Fired before a pane shuts or reopens, whether or not the resize that reached it was allowed, and carrying its own position: a shut pane sits at `collapsed-size` rather than at the number the resize named. Cancelable: refusing it leaves the pane as it was and the divider where the gesture put it. */
   "helix-before-collapse": HelixSplitterHelixBeforeCollapseElementEvent;
-  /** Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the whole of where the gesture ended, so no collapse follows from it either. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own. */
+  /** Fired before the divider settles, and only where the gesture moved it: a press that moved nothing, a drag that came back, an arrow with nowhere left to go and a corner that moved the other divider are all silent on this one. Cancelable: refusing it takes the position and leaves the rest of the gesture, so a collapse the gesture reached is still announced and still yours to refuse. A drag has already drawn itself by then and holds where it was dropped until the consumer assigns their own. */
   "helix-before-resize": HelixSplitterHelixBeforeResizeElementEvent;
 };
 
@@ -10732,10 +10792,12 @@ export type CustomCssProperties = {
   "--carousel-gap"?: (string) | undefined;
   /** The size one pane is laid out at. A sheet sets it and the component measures the run with it. */
   "--carousel-pane"?: (string) | undefined;
-  /** How many slides go across, written onto the track by the component so a sheet divides the track by the same number the positions are counted from. Read it rather than selecting on `per-view`, which cannot be enumerated without a ceiling. See `perView`. */
+  /** How many slides go across, written onto the track by the component so a sheet divides the track by the same number the positions are counted from. Read it rather than selecting on `per-view`, which cannot be enumerated without a ceiling. Under `per-view="auto"` the component writes nothing and the sheet declares it instead, so the same name answers in both modes. See `perView`. */
   "--carousel-per-view"?: (string) | undefined;
   /** How far short of a whole pixel the run ends, on the last slide alone, for a sheet to take up as `margin-inline-end`. See `runEnd`. */
   "--carousel-run-end"?: (string) | undefined;
+  /** The narrowest a slide may be laid out, which is what `per-view="auto"` fits the track with. A length, since the sheet divides by it. Unset is the whole track, which is one across. */
+  "--carousel-slide-min"?: (string) | undefined;
   /** Fill behind the composer. */
   "--chat-composer-background-color"?: (string) | undefined;
   /** The composer's edge, so a theme can remove it. */