@fusion.dev/helix-headless 0.50.0 → 0.52.0

package/types/jsx.d.ts

@@ -1861,6 +1861,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
@@ -1898,6 +1921,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
@@ -2004,6 +2050,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
@@ -2041,6 +2110,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
@@ -13358,11 +13450,11 @@ has an honest answer. */
   /** How far one arrow press moves it, as a percentage. */
   step?: (HelixHeadlessSplitter["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: HelixHeadlessSplitterHelixBeforeCollapseElementEvent,
   ) => 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: HelixHeadlessSplitterHelixBeforeResizeElementEvent,
   ) => void) | undefined;
@@ -13462,11 +13554,11 @@ has an honest answer. */
   "prop:orientation"?: (HelixHeadlessSplitter["orientation"]) | undefined;
   /** How far one arrow press moves it, as a percentage. */
   "prop:step"?: (HelixHeadlessSplitter["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: HelixHeadlessSplitterHelixBeforeCollapseElementEvent,
   ) => 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: HelixHeadlessSplitterHelixBeforeResizeElementEvent,
   ) => void) | undefined;
@@ -19516,6 +19608,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
@@ -19525,7 +19640,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.
    *
@@ -19572,8 +19691,9 @@ export type CustomElements = {
    *
    * - `--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
    *
@@ -31067,10 +31187,12 @@ export type CustomElements = {
    * **A pane can be shut, and that is not the same as a divider at the edge.**
    * The geometry is identical and the knowledge is not: only a shut pane knows
    * where to open back to. So `collapsed` is a second state rather than a reading
-   * of the position, and the position it opens to is the one collapsing never
-   * overwrote. `collapsed-size` keeps a sliver showing where a pane has a tab
-   * strip worth leaving, and collapse overrides `min` and `max`, which is what
-   * those are for.
+   * of the position, and the position it opens to is where the gesture that shut
+   * it began, whichever gesture that was: a drag takes its reading on the press,
+   * and every other door takes it in `settle`, nothing having been applied there
+   * yet. `collapsed-size` keeps a sliver showing where a pane has a tab strip
+   * worth leaving, and collapse overrides `min` and `max`, which is what those
+   * are for.
    *
    * ## Attributes & Properties
    *
@@ -31175,8 +31297,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
    *
@@ -37403,6 +37525,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
@@ -37412,7 +37557,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.
    *
@@ -37459,8 +37608,9 @@ export type CustomElementsSolidJs = {
    *
    * - `--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
    *
@@ -49121,10 +49271,12 @@ export type CustomElementsSolidJs = {
    * **A pane can be shut, and that is not the same as a divider at the edge.**
    * The geometry is identical and the knowledge is not: only a shut pane knows
    * where to open back to. So `collapsed` is a second state rather than a reading
-   * of the position, and the position it opens to is the one collapsing never
-   * overwrote. `collapsed-size` keeps a sliver showing where a pane has a tab
-   * strip worth leaving, and collapse overrides `min` and `max`, which is what
-   * those are for.
+   * of the position, and the position it opens to is where the gesture that shut
+   * it began, whichever gesture that was: a drag takes its reading on the press,
+   * and every other door takes it in `settle`, nothing having been applied there
+   * yet. `collapsed-size` keeps a sliver showing where a pane has a tab strip
+   * worth leaving, and collapse overrides `min` and `max`, which is what those
+   * are for.
    *
    * ## Attributes & Properties
    *
@@ -49229,8 +49381,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
    *
@@ -53651,10 +53803,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;
   /** The chosen color, to paint over the transparency check. */
   "--color-input-swatch"?: (string) | undefined;
   /** The chosen brightness, 0 to 100, as a percentage. */

package/types/vue.d.ts

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