@fusion.dev/helix 0.50.0 → 0.52.0

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/dist/sandbox/source/sandbox-source.d.ts

@@ -14,7 +14,7 @@ import type { CSSResultGroup, TemplateResult } from 'lit';
  * is the documented escape hatch for exactly this trade.
  *
  * @since 0.1.0
- * @status experimental
+ * @status stable
  * @aliases Editor, Code pane
  * @documentation https://fusion.dev/helix/components/sandbox
  *

package/dist/sandbox/status-bar/sandbox-status-bar.d.ts

@@ -18,7 +18,7 @@ import type { CSSResultGroup, TemplateResult } from 'lit';
  * empty, or the bar keeps a gap where a value is not.
  *
  * @since 0.1.0
- * @status experimental
+ * @status stable
  * @aliases Status line
  * @documentation https://fusion.dev/helix/components/sandbox
  *

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

@@ -18,7 +18,7 @@ import type { CSSResultGroup, TemplateResult } from 'lit';
  * the whole panel being re-announced each time.
  *
  * @since 0.1.0
- * @status experimental
+ * @status stable
  * @aliases Console, Output
  * @documentation https://fusion.dev/helix/components/sandbox
  *

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

@@ -16,7 +16,7 @@ import type { CSSResultGroup, TemplateResult } from 'lit';
  * Both slots are bare, so an unfilled one generates no box and costs no gap.
  *
  * @since 0.1.0
- * @status experimental
+ * @status stable
  * @aliases Action bar
  * @documentation https://fusion.dev/helix/components/sandbox
  *

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

@@ -32,7 +32,7 @@ import type { CSSResultGroup } from 'lit';
  * gesture.
  *
  * @since 0.1.0
- * @status experimental
+ * @status stable
  * @category layout
  * @aliases SplitPane, Resizable, SplitView
  * @documentation https://fusion.dev/helix/components/splitter

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.52.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.52.0",
+    "@fusion.dev/helix-headless": "0.52.0",
+    "@fusion.dev/helix-styles": "0.52.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.52.0",
+    "@fusion.dev/helix-testing": "0.52.0",
     "@fusion.dev/scripts": "0.0.0-dev",
     "@happy-dom/global-registrator": "^20.0.0",
     "@lit-labs/ssr": "^4.1.0",

package/types/jsx.d.ts

@@ -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. */