@fusion.dev/helix-core 0.182.1 → 0.182.2

package/custom-elements.json

@@ -11757,6 +11757,17 @@
               ],
               "description": "Re-emits a native event from the host, under its own name.\n\nA native event fired by an inner `<input>` or `<textarea>` is not composed,\nso it stops at the shadow boundary and a consumer listening on\n`<helix-input>` hears nothing. Re-dispatching it from the host is what\nmakes the component behave like the control it wraps.\n\nThe relayed event keeps the native name deliberately. `change` is `change`,\nwhich is what a consumer already knows to listen for, and it is what\nreaches React: its synthetic system claims `onChange` and wires it to that\nname, so a prefixed one would never arrive.\n\n`composed` is not forced. It defaults to the original event's own value, so\na relayed `change` stops at the next shadow boundary exactly as a native\none would. Pass it explicitly only where escaping is the intent, and say so\nwhere you do."
             },
+            {
+              "kind": "field",
+              "name": "markRules",
+              "type": {
+                "text": "readonly string[]"
+              },
+              "privacy": "protected",
+              "static": true,
+              "default": "[]",
+              "description": "The rules from `mark-rules.ts` for the marks this element writes in its\nown shadow root: `data-scroller`, `data-virtual`, `data-spoken` and\n`data-mirror`.\n\nA component that writes a mark names its rule here, and a subclass\ninherits the list. One that writes none takes only the three rules every\nshadow root gets, which is what keeps the other four out of a Button."
+            },
             {
               "kind": "method",
               "name": "finalizeStyles",
@@ -11776,7 +11787,7 @@
                   }
                 }
               ],
-              "description": "Prepends the shadow-root reset to every subclass's styles, so no component\nhas to remember to include it."
+              "description": "Prepends the shadow-root reset to every subclass's styles, so no component\nhas to remember to include it, with the rules for the marks it writes."
             },
             {
               "kind": "method",
@@ -11854,6 +11865,82 @@
         }
       ]
     },
+    {
+      "kind": "javascript-module",
+      "path": "src/helix-element/mark-rules.ts",
+      "declarations": [
+        {
+          "kind": "variable",
+          "name": "SCROLLER_RULE",
+          "type": {
+            "text": "string"
+          },
+          "default": "'[data-scroller]{overflow:auto}'",
+          "description": "Makes an element a scroll container, where a component says it is one.\n\n**A box that scrolls is the headless tier's, and the headless tier had no way to say\nso.** `overflow` is what creates a scrollport: without it `scrollTop` is\npermanently zero and every scroll API on the element is inert. So a component\nthat reads `scrollTop` and cannot declare `overflow` is one whose behavior\nlives in somebody else's stylesheet.\n\nMeasured before deciding: `helix-headless-scroll-area`, the component whose\nentire purpose is scrolling, computes `overflow-y: visible` on its viewport\nwith `scrollHeight` equal to `clientHeight`. Standing alone it is a div, and\nthe virtual list is worse because it *acts* on the reading.\n\n**It goes in `core` rather than in a stylesheet**, with `BOX_SIZING`,\n`HIDDEN` and `SETTLED`, which are the token-free structural rules `core`\nships into every shadow root. \"The headless tier has no CSS\" has never meant\n`core` has none; it means `helix/headless` must not depend on\n`@fusion.dev/helix-styles`, and a rule with no token in it does not.\n\n**And a rule rather than an inline style, which was the first idea and is\nwrong.** An inline `style` on a rendered part outranks every author rule\nshort of `!important`, so a consumer wanting `overflow: hidden` on that part\nwould have to fight it and would need `!important` of their own. A shadow rule\nloses to a document rule, so `::part(viewport) { overflow: … }` from a\nconsumer simply wins, which is the right way round.\n\nBoth axes, and nothing else. Which *kind* of scrolling, how much room,\n`overscroll-behavior`, `scroll-snap`, a gutter, a scrollbar treatment: those\nare decisions and stay in `helix/styled`. This is only the mechanism, and the\nstyled sheet is prepended-after so it overrides at equal specificity anyway.\n\n**A component marks a box whose scroll state it reads, and no other**, which\nis narrower than \"every box that ends up scrolling\". `Megamenu`'s panel\nscrolls, and only because the styled tier gives it a `max-block-size`: that is\na decision, the `overflow` that serves it belongs with it, and the headless\ntier never asks the panel where it is scrolled to. Marking it anyway moved a\nheading four pixels, because `overflow` establishes a block formatting context\nand margins that had been collapsing stopped. A mechanism with a layout\nconsequence is one to apply exactly where it is needed.\n\n`ScrollArea`, `VirtualList`, `Carousel`, `ObjectInspector`, `Chat` and a\n`windowed` `DataTable` mark theirs, each reading `scrollTop` or `scrollLeft`\nand acting on the answer. The last two took their `overflow` from their\nstyled sheet until they were marked, so the window each drew was inert on a\npage that loads only `helix/headless`; marking them moved nothing on the\nstyled tier, where both boxes already scrolled."
+        },
+        {
+          "kind": "variable",
+          "name": "VIRTUAL_RULE",
+          "type": {
+            "text": "string"
+          },
+          "default": "'[data-virtual]{overflow-anchor:none}'",
+          "description": "A box whose rows are drawn and taken away as it scrolls, which\n`VirtualizeController` marks `data-virtual` once it watches it.\n\n**The browser's scroll anchoring fights the window.** Chromium keeps the\ncontent a reader was looking at in place when what is above it changes, and\na virtual window changes exactly that on every move: the spacer above grows\nand the rows are swapped. Measured on a 500 row list scrolled to 330, the\noffset went to 138, then 522, then back to 330 before it settled, and the\nlist reported four ranges for one scroll. The window already keeps the rows\nwhere they belong, so anchoring has nothing left to do here but move them."
+        },
+        {
+          "kind": "variable",
+          "name": "SPOKEN_RULE",
+          "type": {
+            "text": "string"
+          },
+          "default": "'[data-spoken]{position:absolute;inline-size:1px;block-size:1px;overflow:hidden;clip-path:inset(50%);white-space:nowrap}'",
+          "description": "Words a screen reader reads where the eye reads something else, which a\ncomponent marks `data-spoken`: `⇧⌘P` in Kbd is read as `Shift Command P`.\n\nThe drawn text is `aria-hidden` and the words sit beside it, in no box the\neye sees. The rule takes the words out of the layout and paints none of\nthem, and names no token, so it belongs with the mechanisms here. Without\nit a page that loads only `helix/headless` showed both."
+        },
+        {
+          "kind": "variable",
+          "name": "MIRROR_RULE",
+          "type": {
+            "text": "string"
+          },
+          "default": "':host(:dir(rtl)) [data-mirror]{scale:-1 1}'",
+          "description": "Turns a drawing that runs along the line of text, or a glyph that points\nalong it, round with it on a right-to-left page.\n\n**A chart computes its geometry from the left, because an SVG's coordinates\ndo.** `x` grows rightward whatever `direction` says, while the words around a\ndrawing are HTML written in logical properties and turn on their own. Before\nthis, a bar chart on an Arabic page wrote Q4 to Q1 from the left under\ncolumns still drawn Q1 to Q4, so each name stood under its mirror's column.\n\n**A rule rather than a second set of coordinates, and three things decide\nit.** A server renders the same markup whichever way the page reads, so the\ndrawing it sends is right before a script runs. Everything drawn on a mark\nturns with it: a column rounded at its far end, a gradient toward its base,\nthe hole a ring terminus cuts, each of which arithmetic would have to mirror\nagain in every stylesheet that draws one. And it follows `dir` when it\nchanges, which a render would only do on its next update.\n\n**About the vertical axis, never the horizontal.** Up is more in every\nscript, so a value keeps its height and only the run along the line turns.\nThe numbers are text beside the drawing rather than inside it, so they read\nthe right way round.\n\n**Keyed on `:dir()`, which is what every sheet here mirrors a caret with.**\nThe pointer arithmetic that has to agree with it asks the computed\n`direction`, the question the table and the splitter already ask, and the two\npart only where a sheet sets `direction` without `dir`.\n\nA component marks the drawing with `data-mirror`, and a drawing with no line\nof text to follow is left unmarked: a whole ring's slices run clockwise from\ntwelve, which is a clock's convention and not a script's. `scale` rather than\n`transform`, so a consumer's `transform` on the same part composes with it,\nand a consumer's `scale` there wins, a shadow rule losing to a document one.\n\n**A glyph that points along the line is the same case, marked the same\nway**: a caret meaning next or previous, the one between two crumbs, a shut\ndisclosure. The component drawing it knows what it means, so the headless\ntier points it the right way with no stylesheet at all. Before the mark each\nstyled sheet turned its own and a headless page had to know to, which the\ncarousel's and the pagination's did not. A glyph a *sheet* stands on its side\nis that sheet's to turn: a tree draws its chevron pointing down, and a mark\nwould come out right under a `transform: rotate()`, which applies before\n`scale`, and do nothing under the `rotate` property, which applies after it.\nA glyph for playing media is left unmarked too, a tape running one way\nwhatever the script, and so is a picture of a key."
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "SCROLLER_RULE",
+          "declaration": {
+            "name": "SCROLLER_RULE",
+            "module": "src/helix-element/mark-rules.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "VIRTUAL_RULE",
+          "declaration": {
+            "name": "VIRTUAL_RULE",
+            "module": "src/helix-element/mark-rules.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "SPOKEN_RULE",
+          "declaration": {
+            "name": "SPOKEN_RULE",
+            "module": "src/helix-element/mark-rules.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "MIRROR_RULE",
+          "declaration": {
+            "name": "MIRROR_RULE",
+            "module": "src/helix-element/mark-rules.ts"
+          }
+        }
+      ]
+    },
     {
       "kind": "javascript-module",
       "path": "src/helix-element/react-audit-off.ts",
@@ -12081,12 +12168,12 @@
     },
     {
       "kind": "javascript-module",
-      "path": "src/helix-form-element/helix-form-element.ts",
+      "path": "src/helix-form-element/helix-form-element-base.ts",
       "declarations": [
         {
           "kind": "class",
-          "description": "`HelixFormElement` is a class because the browser reads `formAssociated` from\nthe constructor during element upgrade, and a mixin or controller cannot\nsupply it.\n\n`internals` comes from `HelixElement`, which attaches it for every component.\n`attachInternals()` throws on a second call, so only one class attaches it.\n\nThe class carries only what every form participant needs. `value` and the\nreset and restore callbacks are added with the first input component.\n\n**The validity API is the platform's, read through `internals`**, so\n`checkValidity()`, `reportValidity()` and `setCustomValidity()` work on the\nhost as they do on a native control. A custom message is laid over whatever\nthe control itself reports, which is why `setValidity` is wrapped below.\n\n**Focus goes to the control's first tab stop**, for `focus()` and for a\npress on a `<label>` that names the host. A host is not focusable itself, so\nwithout this a label press focused nothing on half the controls.",
-          "name": "HelixFormElement",
+          "description": "`HelixFormElementBase` carries form ownership, `disabled` and the fieldset\nthat disables it, `name`, focus, and the validity API with a custom message\nas its only verdict. `HelixFormElement` extends it with what a control that\njudges its own value needs: the wrapped `setValidity`, `feedback` from a\nfield, and the `input` and `change` announcements.\n\n**Two classes, because a button pays for the half it never calls.** Button\nreports nothing through `setValidity` and holds no value, so a message from\n`setCustomValidity` is the whole of its verdict, the same as on a native\n`<button>`. Measured on the styled Button bundled alone, October 7, 2026:\nthe validating half was 347 of its 12,973 bytes brotli.\n\nA family extends this one only where it never calls\n`internals.setValidity` and takes no `MixinField`. Every other control\nextends `HelixFormElement`.",
+          "name": "HelixFormElementBase",
           "members": [
             {
               "kind": "field",
@@ -12097,7 +12184,841 @@
               "static": true,
               "readonly": true,
               "default": "true",
-              "description": "Opts the element into form ownership, labels, and submission."
+              "description": "Opts the element into form ownership, labels, and submission."
+            },
+            {
+              "kind": "field",
+              "name": "disabled",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether the control is disabled and cannot be used.\n\nReflected, because the styled tier selects on it, and mirrored to\n`aria-disabled` rather than removing the element from the accessibility\ntree, so a screen reader can still announce that the control exists.\n\nThe mirror itself is in `willUpdate` below, here rather than in each\ncontrol, because here is where `disabled` is.",
+              "attribute": "disabled",
+              "reflects": true
+            },
+            {
+              "kind": "field",
+              "name": "formDisabled",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "default": "false",
+              "description": "Whether an ancestor `<fieldset disabled>` has switched this control off.\n\nThe platform tells a form-associated element through `formDisabledCallback`\nand nothing else does, so without this a control inside a disabled fieldset\nstays fully typeable and announces itself as enabled.\n\nThe submission half is already the platform's: measured, the fieldset's\ncontrols are absent from the form's entry list and the host matches\n`:disabled`, so the value never goes anywhere. What is missing without this\nis everything a reader can see or touch.\n\nState rather than the `disabled` property. Writing that would reflect an\nattribute the consumer's server markup does not have, which React reports\non hydration and does not patch up, and it would also silently overwrite\nwhat the consumer set."
+            },
+            {
+              "kind": "method",
+              "name": "formDisabledCallback",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "disabled",
+                  "type": {
+                    "text": "boolean"
+                  }
+                }
+              ],
+              "description": "Called by the browser when an ancestor fieldset is disabled or enabled.\n\n**The argument is the effective state, and taking it whole is what latched\nevery control in the library.** The platform calls this for the element's\nown `disabled` as well as for a fieldset, and our own arrives here at the\nworst possible moment: reflecting `disabled` to the attribute happens\ninside Lit's `update()`, the UA fires this synchronously from that write,\nand a reactive write during an update is a change-in-update Lit does not\nre-render for. So `formDisabled` ran exactly one update behind forever.\n\nMeasured on Slider, logging what `render` saw:\n\n```\nset true    disabled true   formDisabled false  isDisabled true\nset false   disabled false  formDisabled true   isDisabled true   <- stale\n(no third render)\n```\n\nThe host came out right every time, `disabled` false, `:disabled` not\nmatching, and the inner control kept the attribute, so a control disabled\nonce could never be re-enabled. It only shows when something re-enables,\nwhich is the same shape of bug `inheritDisabled` was written for.\n\nOur own half is already in `this.disabled` and `isDisabled` is an or, so\nthis records only what the fieldset adds. That also removes the write\nentirely on the own-disabled path rather than moving it.\n\nThe one case this cannot see is a control that is disabled itself *and*\ninside a disabled fieldset, whose own `disabled` is then removed: the\neffective state does not change, so the platform does not call again, and\nthe fieldset's hold is not recorded. There is no callback to learn it from\nand reading `:disabled` here would answer about the attribute we are in the\nmiddle of removing."
+            },
+            {
+              "kind": "field",
+              "name": "heldByFieldset",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "description": "Whether an ancestor `<fieldset disabled>` holds the control, outside its\nfirst `<legend>`, read from the tree.\n\nFor the one case the callback cannot report: a control disabled itself and\nby a fieldset, whose own `disabled` is then removed. The effective state does\nnot change, so the platform does not call, and the fieldset's hold has to\nbe read.",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "formResetCallback",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Called by the browser when the form is reset. It does nothing here, and\nevery override calls it.\n\n**A chain rather than a leaf**, because more than one layer owes a reset\nsomething: the value mixin its default, and the field mixin beneath it the\nforgetting of a reader's past attempt, whose message otherwise showed over\nthe emptied control the moment the form was reset."
+            },
+            {
+              "kind": "field",
+              "name": "name",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "The name the control's value is submitted under.\n\n**Reflected, and it is the exception to \"reflect only what CSS selects\non\".** The platform builds a form's entry list from the `name` *content\nattribute*, not from the property, so a control named through the property\nsubmitted under no name at all and was silently dropped. Measured: two\ninputs in one form, one named by attribute and one by property, and the\nform carried a single entry.\n\nSafe for a React consumer, which is what the rule is protecting: React\nrenders a custom element's props as attributes on the server, so the name\nis already in the markup being hydrated and reflecting it writes what is\nthere. It is only a change to the markup when a consumer assigns it\nimperatively later, and nothing is hydrating by then.\n\nHere rather than on each control.",
+              "attribute": "name",
+              "reflects": true
+            },
+            {
+              "kind": "field",
+              "name": "customValidity",
+              "type": {
+                "text": "string"
+              },
+              "privacy": "protected",
+              "default": "''",
+              "description": "The message `setCustomValidity` was given."
+            },
+            {
+              "kind": "method",
+              "name": "applyValidity",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Hands the platform the control's verdict, anchored where focus can go.\n\nHere the verdict is the custom message alone. `HelixFormElement` lays the\nmessage over what the control itself reported."
+            },
+            {
+              "kind": "field",
+              "name": "validity",
+              "type": {
+                "text": "ValidityState"
+              },
+              "description": "Whether the control meets its constraints, and why not.",
+              "readonly": true,
+              "helix": {
+                "references": [
+                  {
+                    "label": "ElementInternals.validity",
+                    "url": "https://developer.mozilla.org/docs/Web/API/ElementInternals/validity"
+                  }
+                ]
+              }
+            },
+            {
+              "kind": "field",
+              "name": "validationMessage",
+              "type": {
+                "text": "string"
+              },
+              "description": "The message the browser would show for the control, or an empty string.",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "updateRunning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another."
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "runPendingUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.\n\nProtected for a control that submits on its own, which has to hand the\nform the verdict for what it holds now: Pin Input's `autosubmit`."
+            },
+            {
+              "kind": "field",
+              "name": "willValidate",
+              "type": {
+                "text": "boolean"
+              },
+              "description": "Whether the control is checked when its form is submitted.",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "checkValidity",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that."
+            },
+            {
+              "kind": "method",
+              "name": "reportValidity",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "description": "Returns whether the control is valid, and when it is not, fires `invalid`\nand shows the browser's message at the control."
+            },
+            {
+              "kind": "method",
+              "name": "setCustomValidity",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "message",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "Marks the control invalid with `message`, or clears that with an empty\nstring, as on a native control. The form does not submit while it is set."
+            },
+            {
+              "kind": "field",
+              "name": "focusTarget",
+              "type": {
+                "text": "HTMLElement | null"
+              },
+              "privacy": "protected",
+              "description": "The element focus goes to: the control's first tab stop, or `null` where\nthere is none.\n\nRead through shadow roots and slots, so a group lands on the member that\nholds its tab stop, which is the chosen radio in a radio group.",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "focus",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "FocusOptions"
+                  }
+                }
+              ],
+              "description": "Moves focus to the control, as focusing a native control does."
+            },
+            {
+              "kind": "field",
+              "name": "focusFromLabel",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Focuses the control when its `<label>` is pressed.\n\nThe label sends the host a click of the browser's own after trying to\nfocus it, and a host that is not focusable takes nothing from that try.\nOnly a click that starts at the host and that the browser sent: one from\ninside has landed where it meant to, and `click()` from a script does not\nfocus a native control either."
+            },
+            {
+              "kind": "field",
+              "name": "refreshAnchor",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Re-anchors the verdict as the form checks it, because the control's\nmembers may have rendered since it last reported, and the anchor read then\nwas the best there was."
+            },
+            {
+              "kind": "field",
+              "name": "unwatchLabels",
+              "type": {
+                "text": "(() => void) | undefined"
+              },
+              "privacy": "private",
+              "description": "Stops listening for the labels in this control's tree."
+            },
+            {
+              "kind": "field",
+              "name": "form",
+              "type": {
+                "text": "HTMLFormElement | null"
+              },
+              "description": "The form the control belongs to, or `null`.",
+              "readonly": true,
+              "helix": {
+                "references": [
+                  {
+                    "label": "form-associated custom elements",
+                    "url": "https://html.spec.whatwg.org/multipage/custom-elements.html#form-associated-custom-elements"
+                  }
+                ]
+              }
+            },
+            {
+              "kind": "field",
+              "name": "labels",
+              "type": {
+                "text": "NodeList"
+              },
+              "description": "The labels associated with the control.",
+              "readonly": true,
+              "helix": {
+                "references": [
+                  {
+                    "label": "form-associated custom elements",
+                    "url": "https://html.spec.whatwg.org/multipage/custom-elements.html#form-associated-custom-elements"
+                  }
+                ]
+              }
+            },
+            {
+              "kind": "field",
+              "name": "tier",
+              "type": {
+                "text": "string"
+              },
+              "static": true,
+              "default": "'helix-headless-'",
+              "description": "The prefix this tier registers its elements under.\n\n**A component that renders another renders its own tier's version of it**,\nso `helix-headless-pagination-size` composes `helix-headless-select` and\n`helix-pagination-size` composes `helix-select`. One template says\n`${this.tag('select')}` and each tier answers with its own name.\n\n**The public tag may not be the composed one, in either tier.** Using it\ncosts three things: the name means two different things depending on what a\nconsumer imported, the headless tier composes an element it does not ship,\nand the composition cannot be tested there at all, because there is no\n`helix-select` on that tier to test it against.\n\n**A prefix rather than an override per composition**, which was the first\nplan and does not compile. An override re-renders the fragment from the\nsubclass, and the fragment reads members the base keeps private:\n`PaginationSize` alone would have had to widen `options`, `current` and\n`handleChange` to `protected` so a subclass could say the same thing again.\nSixteen families of that is a lot of encapsulation spent on saying one\nword differently.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "tag",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "StaticValue"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "One composed tag, as a static value a template can interpolate.\n\nWhat `unsafeStatic` returns, safe by construction: the name is a literal in\nour own source and the prefix is one of two strings this class defines.\nCalled per render and not cached, which costs nothing, because\n`static-html` keys its template cache on the joined string rather than on\nthe object.\n\n**Written out rather than imported, for every element that never renders\none.** `lit/static-html.js` declares no side effects, so importing\n`unsafeStatic` alone kept the module's three `withStatic` calls in every\nbundle: about 210 bytes gzipped on each of the families that compose no\ntag, Divider and Badge among them. The value is lit's cross-copy protocol,\nkeyed by `Symbol.for('')` so that two copies of lit on a page read each\nother's, and a spec holds it equal to `unsafeStatic`'s.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "partNamed",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "T | null"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "One of this element's own parts, by name, or null where it is not rendered.\n\nNot `part`, which every element already has: `Element.part` is the\n`DOMTokenList` of the names the element itself carries, and a method under\nthat name is a type error on every subclass.\n\n**One guard for every lookup.** Lit's server shim has no `querySelector`\non the render root, so a lookup reached during a server render, from a\ngetter a template reads or from `willUpdate`, throws there and nowhere\nelse. Four spellings of the same guard had grown across the library, and\na fifth site with none. Null on the server, which is what the rest of the\ncode already treats a part that has not rendered as.\n\n**`~=` and not `=`.** A part drawn in a state carries a second name while\nthe state holds, `part=\"page page-current\"`, and an exact match stops\nfinding it for exactly as long as it is the one that matters.\n\n`helix component`'s `selectors` reads these calls the way it reads a\n`querySelector('[part=\"x\"]')`, so a name nothing renders is a finding\nrather than a null an optional chain swallows.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "internals",
+              "type": {
+                "text": "ElementInternals"
+              },
+              "privacy": "protected",
+              "readonly": true,
+              "description": "The element's semantics, set without touching the DOM.\n\n`ElementInternals` sets the implicit role, which an author's own `role`\nattribute still overrides, and it writes no attribute. Setting `role` on the\nhost directly would: that is an attribute the element gives itself after it\nupgrades, which a React consumer's server markup never had, and hydration\nreports it as a mismatch.\n\nAvailable during server rendering. Lit's shim implements `attachInternals`,\nso nothing here needs a guard.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "toggleState",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "on",
+                  "type": {
+                    "text": "boolean"
+                  }
+                }
+              ],
+              "description": "Records a boolean fact about this element as a custom state.\n\n**The host belongs to whoever rendered it, and a component's own\nbookkeeping may not be kept there.** An attribute written on the first\nupdate is markup a consumer's server never sent, so a React consumer\nhydrates a DOM that has gained attributes since and reports a mismatch it\nwill not patch up. A custom state is not in the DOM at all: it carries the\nfact to a stylesheet through `:state()` and leaves the markup alone, so the\nserver's output and the client's agree by construction.\n\n`SETTLED` carries the long version of that argument; `checked`, `open`,\n`invalid` and `has-label` are recorded the same way, each of them a state a\n`default-*` attribute resolves before React reaches the node.\n\n**Deferring the definitions is not a fix and could not be.** Importing them\nfrom an effect so the upgrades fall the other side of hydration works only\nwhile hydration is one pass: anything that splits it, a streamed segment or\na suspended boundary, puts an upgrade back inside the window. Timing cannot\nbe the guarantee when the fact is kept somewhere React reconciles.\n\nFeature-tested rather than assumed, the way `hostAria` tests element\nreferences. An engine without `CustomStateSet` records nothing and keeps\nwhatever the resting rule draws, which is the safe direction to fail.\n\n**The engines the test is for are browsers**: Safari below 17.4 and Firefox\nbelow 126, where the write is a `TypeError`, so a component bypassing this\nfails to render rather than rendering without whatever the state draws.\nLit's server shim sets `states`, so the guard passes there and records a\nstate nothing reads, which is harmless.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "whenSettled",
+              "type": {
+                "text": "Promise<void>"
+              },
+              "readonly": true,
+              "description": "Resolves a frame after the first update, when transitions are switched on.\n\n**Named `whenSettled` because `settled` is taken four times over**, by\nImage, Splitter and both color controls, none of them about transitions. A\nbase class takes the name every subclass then cannot use.\n\n**The state it reports cannot be watched, which is why this exists.** A\ncustom state is deliberately not in the DOM, so there is no\n`MutationObserver` equivalent for `ElementInternals.states`. Await this\ninstead.\n\nSeparate from `updateComplete`, which resolves in the microtask checkpoint\nthe suppression is still active in. That is the distinction `readyToMove`\nin `@fusion.dev/helix-testing` is written around.\n\nIt never resolves where `requestAnimationFrame` never fires, which is a\nserver, a hidden tab, and happy-dom. Callers that must not hang there race\nit against a timeout, as the happy-dom harness's `readyToMove` does. The\nbrowser harness's awaits it alone: a browser always runs the frame, and a\ntimer beside it was a bet on how long one takes, which a busy run lost.",
+              "default": "new Promise<void>((resolve) => { this.resolveSettled = resolve })",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "resolveSettled",
+              "type": {
+                "text": "() => void"
+              },
+              "privacy": "private",
+              "description": "Resolves `whenSettled`, once, from the frame that records the state.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "fromServer",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether the shadow root was a server's, parsed from declarative shadow DOM.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "hydrating",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this update is hydrating a server's markup, and so has to render\nexactly what the server rendered.\n\n**Lit hydrates by assuming the markup already shows the first render.** A\nvalue that differs is recorded and never written, so the page keeps the\nserver's, and a template that differs throws. The server has no children,\nso anything a component reads from its children waits for the update after\nhydration, which `finishHydration` asks for. Without a server's markup the\nfirst render reads them and there is one render.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "serverRendered",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this element hydrated a server's markup rather than rendering its own.\n\nFor what happened before hydration and cannot be heard after it: an image\nthe parser fetched fires `load` or `error` before any listener exists, so a\ncomponent asks the image instead, once, when this is true.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "finishHydration",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Asks for the update a hydration put off, so the reads it skipped happen.\n\nCalled from `firstUpdated`, the end of the hydrating update. The render it\nschedules can only follow that one, which is the exception Lit's\nchange-in-update warning names, and it happens only on a page a server\nrendered.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "childrenKnown",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this render can know the children.\n\nA server cannot: its element shim carries attributes and no tree, so\n`children` is undefined there. A render hydrating what a server sent must\nnot, because it has to be the server's render. Anywhere else it can. A\ncomponent whose render depends on its children reads them through\n`knownChildren`, and treats \"not known\" as its own answer rather than as\n\"none\": a list that renders its empty state because nobody has looked yet is\nthe one thing an empty state must never do.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "knownChildren",
+              "type": {
+                "text": "Element[]"
+              },
+              "privacy": "protected",
+              "description": "The children a render may read: all of them where they are known, and none otherwise.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "assignsByName",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this element's slots route by name although it asked to assign them\nby hand.\n\n**A declarative shadow root is always the by-name kind.** HTML has no way to\nask for manual assignment, so a component that assigns by hand and hydrates\na server's root gets one where `slot.assign()` does nothing, and its\nchildren land wherever their `slot` attribute sends them. The way through is\nto write that attribute, which is what `route` does. Only there: on a root\nthis element made, assignment stays manual and the consumer's markup is\nnever touched, which is what a React consumer's hydration requires.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "route",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "child",
+                  "type": {
+                    "text": "Element"
+                  }
+                },
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string | undefined"
+                  }
+                }
+              ],
+              "description": "Sends a child to a slot by name, on a root that routes by name.\n\n`undefined` is the default slot. Written only when it differs, so routing\nthe same child again on every update writes nothing.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "stopInner",
+              "privacy": "protected",
+              "readonly": true,
+              "description": "Stops an inner control's own announcement at this element's boundary.\n\n**A composed control is one control to a consumer, and the natives had no\nequivalent of the stop the prefixed events already get.** `<helix-select>`\nrenders a `<helix-listbox>`, and both announce: the listbox dispatches\n`input` and `change` from its own host, `input` is composed by\nspecification, and a consumer listening on the select therefore heard one\nchoice twice. Measured before this existed, on the styled tier, one choice\non the inner listbox: select `input` twice and `change` three times,\ncombobox, date input, time input and color input twice each. `Command` was\nthe only one that was right, because it happened to reach for\n`stopImmediatePropagation` for a different reason.\n\nBound on the child in the parent's template, so it runs while the event is\nstill at the child and before it can cross. The guard is for the case where\na component binds this on itself: an element must never stop its own\nannouncement, which is the one it exists to make.\n\nThis is the same job the `helix-before-*` handlers do with their own\n`stopPropagation`, and it is separate rather than folded into them because\na consumer may legitimately refuse a request without the notification ever\nhappening: the two travel at different times and one can be absent.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "relayNativeEvent",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "event",
+                  "type": {
+                    "text": "Event"
+                  }
+                },
+                {
+                  "name": "init",
+                  "optional": true,
+                  "type": {
+                    "text": "EventInit"
+                  }
+                }
+              ],
+              "description": "Re-emits a native event from the host, under its own name.\n\nA native event fired by an inner `<input>` or `<textarea>` is not composed,\nso it stops at the shadow boundary and a consumer listening on\n`<helix-input>` hears nothing. Re-dispatching it from the host is what\nmakes the component behave like the control it wraps.\n\nThe relayed event keeps the native name deliberately. `change` is `change`,\nwhich is what a consumer already knows to listen for, and it is what\nreaches React: its synthetic system claims `onChange` and wires it to that\nname, so a prefixed one would never arrive.\n\n`composed` is not forced. It defaults to the original event's own value, so\na relayed `change` stops at the next shadow boundary exactly as a native\none would. Pass it explicitly only where escaping is the intent, and say so\nwhere you do.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "markRules",
+              "type": {
+                "text": "readonly string[]"
+              },
+              "privacy": "protected",
+              "static": true,
+              "default": "[]",
+              "description": "The rules from `mark-rules.ts` for the marks this element writes in its\nown shadow root: `data-scroller`, `data-virtual`, `data-spoken` and\n`data-mirror`.\n\nA component that writes a mark names its rule here, and a subclass\ninherits the list. One that writes none takes only the three rules every\nshadow root gets, which is what keeps the other four out of a Button.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "finalizeStyles",
+              "privacy": "protected",
+              "static": true,
+              "return": {
+                "type": {
+                  "text": "CSSResultOrNative[]"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "styles",
+                  "optional": true,
+                  "type": {
+                    "text": "CSSResultOrNative | CSSResultOrNative[]"
+                  }
+                }
+              ],
+              "description": "Prepends the shadow-root reset to every subclass's styles, so no component\nhas to remember to include it, with the rules for the marks it writes.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            }
+          ],
+          "attributes": [
+            {
+              "name": "disabled",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether the control is disabled and cannot be used.\n\nReflected, because the styled tier selects on it, and mirrored to\n`aria-disabled` rather than removing the element from the accessibility\ntree, so a screen reader can still announce that the control exists.\n\nThe mirror itself is in `willUpdate` below, here rather than in each\ncontrol, because here is where `disabled` is.",
+              "fieldName": "disabled"
+            },
+            {
+              "name": "name",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "The name the control's value is submitted under.\n\n**Reflected, and it is the exception to \"reflect only what CSS selects\non\".** The platform builds a form's entry list from the `name` *content\nattribute*, not from the property, so a control named through the property\nsubmitted under no name at all and was silently dropped. Measured: two\ninputs in one form, one named by attribute and one by property, and the\nform carried a single entry.\n\nSafe for a React consumer, which is what the rule is protecting: React\nrenders a custom element's props as attributes on the server, so the name\nis already in the markup being hydrated and reflecting it writes what is\nthere. It is only a change to the markup when a consumer assigns it\nimperatively later, and nothing is hydrating by then.\n\nHere rather than on each control.",
+              "fieldName": "name"
+            }
+          ],
+          "superclass": {
+            "name": "HelixElement",
+            "module": "/src/helix-element/helix-element.js"
+          },
+          "summary": "Base for a form element that reports no validity of its own, as a native button does.",
+          "helix": {
+            "since": "0.176.0",
+            "status": "experimental",
+            "documentation": "https://fusion.dev/helix/docs/tiers",
+            "tier": "core"
+          },
+          "cssStates": [
+            {
+              "description": "Set one frame after the first render. Transitions wait for it, so an element does not animate its own arrival.",
+              "name": "settled",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            }
+          ]
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "HelixFormElementBase",
+          "declaration": {
+            "name": "HelixFormElementBase",
+            "module": "src/helix-form-element/helix-form-element-base.ts"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/helix-form-element/helix-form-element.ts",
+      "declarations": [
+        {
+          "kind": "class",
+          "description": "`HelixFormElement` is a class because the browser reads `formAssociated` from\nthe constructor during element upgrade, and a mixin or controller cannot\nsupply it.\n\n`internals` comes from `HelixElement`, which attaches it for every component.\n`attachInternals()` throws on a second call, so only one class attaches it.\n\nThe class carries only what every form participant needs. `value` and the\nreset and restore callbacks are added with the first input component.\n\n**The validity API is the platform's, read through `internals`**, so\n`checkValidity()`, `reportValidity()` and `setCustomValidity()` work on the\nhost as they do on a native control. A custom message is laid over whatever\nthe control itself reports, which is why `setValidity` is wrapped below.\n\n**Focus goes to the control's first tab stop**, for `focus()` and for a\npress on a `<label>` that names the host. A host is not focusable itself, so\nwithout this a label press focused nothing on half the controls.\n\nOwnership, `disabled`, `name`, focus and the validity API are\n`HelixFormElementBase`'s, which a control that reports no verdict of its\nown, as Button does, extends directly.",
+          "name": "HelixFormElement",
+          "members": [
+            {
+              "kind": "method",
+              "name": "announceInput",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Announces `input` from the host, the way the control it stands for would.\n\nComposed, as the native one is: `input` crosses shadow boundaries by\nspecification, so a consumer listening above a composition hears it."
+            },
+            {
+              "kind": "method",
+              "name": "announceChange",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Announces `change` from the host, the way the control it stands for would.\n\n**Not composed, and that is the shape of the native event rather than a\nchoice made here.** `change` stops at a shadow boundary, so a composed\ncontrol hears its inner control's and relays it under the same name from\nits own host, which is what `onChange` binds. Every control here that\ncommits a value announces it through this, whether the commit came from an\ninner control's own `change`, a step, a scrub or a completed code, so the\nevent is one shape in one place."
+            },
+            {
+              "kind": "field",
+              "name": "reportValidityTo",
+              "type": {
+                "text": "ElementInternals['setValidity']"
+              },
+              "privacy": "private",
+              "readonly": true,
+              "description": "The platform's own `setValidity`, which the wrapper above calls.",
+              "default": "report"
+            },
+            {
+              "kind": "field",
+              "name": "reported",
+              "type": {
+                "text": "Reported"
+              },
+              "privacy": "private",
+              "default": "{ anchor: undefined, flags: {}, message: '' }",
+              "description": "What the control last reported, before any custom error is laid over it."
+            },
+            {
+              "kind": "field",
+              "name": "appliedFeedback",
+              "type": {
+                "text": "string"
+              },
+              "privacy": "private",
+              "default": "''",
+              "description": "The `validityFeedback` the platform was last told about."
+            },
+            {
+              "kind": "method",
+              "name": "applyValidity",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Hands the platform the control's own verdict with any custom error on top,\nanchored where focus can go.",
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "validationAnchor",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "HTMLElement | undefined"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "anchor",
+                  "optional": true,
+                  "type": {
+                    "text": "HTMLElement"
+                  }
+                }
+              ],
+              "description": "Where the browser points its bubble: the anchor a control gave if focus\ncan go there, and its first tab stop otherwise.\n\nA group anchors on a part that holds its members and cannot take focus,\nand the platform then refuses the submission, logs that the control is\nnot focusable, and leaves the reader on the submit button."
+            },
+            {
+              "kind": "method",
+              "name": "checkValidity",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that.",
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "checkInProgress",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires."
+            },
+            {
+              "kind": "method",
+              "name": "formAssociatedCallback",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "form",
+                  "type": {
+                    "text": "HTMLFormElement | null"
+                  }
+                }
+              ],
+              "description": "Called by the browser when the control's form changes: watches the new\nform's `checkValidity()`, as connecting does for the form it starts in."
+            },
+            {
+              "kind": "field",
+              "name": "formAssociated",
+              "type": {
+                "text": "boolean"
+              },
+              "static": true,
+              "readonly": true,
+              "default": "true",
+              "description": "Opts the element into form ownership, labels, and submission.",
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "field",
@@ -12108,7 +13029,11 @@
               "default": "false",
               "description": "Whether the control is disabled and cannot be used.\n\nReflected, because the styled tier selects on it, and mirrored to\n`aria-disabled` rather than removing the element from the accessibility\ntree, so a screen reader can still announce that the control exists.\n\nThe mirror itself is in `willUpdate` below, here rather than in each\ncontrol, because here is where `disabled` is.",
               "attribute": "disabled",
-              "reflects": true
+              "reflects": true,
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "field",
@@ -12118,7 +13043,11 @@
               },
               "privacy": "protected",
               "default": "false",
-              "description": "Whether an ancestor `<fieldset disabled>` has switched this control off.\n\nThe platform tells a form-associated element through `formDisabledCallback`\nand nothing else does, so without this a control inside a disabled fieldset\nstays fully typeable and announces itself as enabled.\n\nThe submission half is already the platform's: measured, the fieldset's\ncontrols are absent from the form's entry list and the host matches\n`:disabled`, so the value never goes anywhere. What is missing without this\nis everything a reader can see or touch.\n\nState rather than the `disabled` property. Writing that would reflect an\nattribute the consumer's server markup does not have, which React reports\non hydration and does not patch up, and it would also silently overwrite\nwhat the consumer set."
+              "description": "Whether an ancestor `<fieldset disabled>` has switched this control off.\n\nThe platform tells a form-associated element through `formDisabledCallback`\nand nothing else does, so without this a control inside a disabled fieldset\nstays fully typeable and announces itself as enabled.\n\nThe submission half is already the platform's: measured, the fieldset's\ncontrols are absent from the form's entry list and the host matches\n`:disabled`, so the value never goes anywhere. What is missing without this\nis everything a reader can see or touch.\n\nState rather than the `disabled` property. Writing that would reflect an\nattribute the consumer's server markup does not have, which React reports\non hydration and does not patch up, and it would also silently overwrite\nwhat the consumer set.",
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "method",
@@ -12136,7 +13065,11 @@
                   }
                 }
               ],
-              "description": "Called by the browser when an ancestor fieldset is disabled or enabled.\n\n**The argument is the effective state, and taking it whole is what latched\nevery control in the library.** The platform calls this for the element's\nown `disabled` as well as for a fieldset, and our own arrives here at the\nworst possible moment: reflecting `disabled` to the attribute happens\ninside Lit's `update()`, the UA fires this synchronously from that write,\nand a reactive write during an update is a change-in-update Lit does not\nre-render for. So `formDisabled` ran exactly one update behind forever.\n\nMeasured on Slider, logging what `render` saw:\n\n```\nset true    disabled true   formDisabled false  isDisabled true\nset false   disabled false  formDisabled true   isDisabled true   <- stale\n(no third render)\n```\n\nThe host came out right every time, `disabled` false, `:disabled` not\nmatching, and the inner control kept the attribute, so a control disabled\nonce could never be re-enabled. It only shows when something re-enables,\nwhich is the same shape of bug `inheritDisabled` was written for.\n\nOur own half is already in `this.disabled` and `isDisabled` is an or, so\nthis records only what the fieldset adds. That also removes the write\nentirely on the own-disabled path rather than moving it.\n\nThe one case this cannot see is a control that is disabled itself *and*\ninside a disabled fieldset, whose own `disabled` is then removed: the\neffective state does not change, so the platform does not call again, and\nthe fieldset's hold is not recorded. There is no callback to learn it from\nand reading `:disabled` here would answer about the attribute we are in the\nmiddle of removing."
+              "description": "Called by the browser when an ancestor fieldset is disabled or enabled.\n\n**The argument is the effective state, and taking it whole is what latched\nevery control in the library.** The platform calls this for the element's\nown `disabled` as well as for a fieldset, and our own arrives here at the\nworst possible moment: reflecting `disabled` to the attribute happens\ninside Lit's `update()`, the UA fires this synchronously from that write,\nand a reactive write during an update is a change-in-update Lit does not\nre-render for. So `formDisabled` ran exactly one update behind forever.\n\nMeasured on Slider, logging what `render` saw:\n\n```\nset true    disabled true   formDisabled false  isDisabled true\nset false   disabled false  formDisabled true   isDisabled true   <- stale\n(no third render)\n```\n\nThe host came out right every time, `disabled` false, `:disabled` not\nmatching, and the inner control kept the attribute, so a control disabled\nonce could never be re-enabled. It only shows when something re-enables,\nwhich is the same shape of bug `inheritDisabled` was written for.\n\nOur own half is already in `this.disabled` and `isDisabled` is an or, so\nthis records only what the fieldset adds. That also removes the write\nentirely on the own-disabled path rather than moving it.\n\nThe one case this cannot see is a control that is disabled itself *and*\ninside a disabled fieldset, whose own `disabled` is then removed: the\neffective state does not change, so the platform does not call again, and\nthe fieldset's hold is not recorded. There is no callback to learn it from\nand reading `:disabled` here would answer about the attribute we are in the\nmiddle of removing.",
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "field",
@@ -12146,7 +13079,11 @@
               },
               "privacy": "private",
               "description": "Whether an ancestor `<fieldset disabled>` holds the control, outside its\nfirst `<legend>`, read from the tree.\n\nFor the one case the callback cannot report: a control disabled itself and\nby a fieldset, whose own `disabled` is then removed. The effective state does\nnot change, so the platform does not call, and the fieldset's hold has to\nbe read.",
-              "readonly": true
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "method",
@@ -12156,29 +13093,11 @@
                   "text": "void"
                 }
               },
-              "description": "Called by the browser when the form is reset. It does nothing here, and\nevery override calls it.\n\n**A chain rather than a leaf**, because more than one layer owes a reset\nsomething: the value mixin its default, and the field mixin beneath it the\nforgetting of a reader's past attempt, whose message otherwise showed over\nthe emptied control the moment the form was reset."
-            },
-            {
-              "kind": "method",
-              "name": "announceInput",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "Announces `input` from the host, the way the control it stands for would.\n\nComposed, as the native one is: `input` crosses shadow boundaries by\nspecification, so a consumer listening above a composition hears it."
-            },
-            {
-              "kind": "method",
-              "name": "announceChange",
-              "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "Announces `change` from the host, the way the control it stands for would.\n\n**Not composed, and that is the shape of the native event rather than a\nchoice made here.** `change` stops at a shadow boundary, so a composed\ncontrol hears its inner control's and relays it under the same name from\nits own host, which is what `onChange` binds. Every control here that\ncommits a value announces it through this, whether the commit came from an\ninner control's own `change`, a step, a scrub or a completed code, so the\nevent is one shape in one place."
+              "description": "Called by the browser when the form is reset. It does nothing here, and\nevery override calls it.\n\n**A chain rather than a leaf**, because more than one layer owes a reset\nsomething: the value mixin its default, and the field mixin beneath it the\nforgetting of a reader's past attempt, whose message otherwise showed over\nthe emptied control the moment the form was reset.",
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "field",
@@ -12189,28 +13108,11 @@
               "default": "''",
               "description": "The name the control's value is submitted under.\n\n**Reflected, and it is the exception to \"reflect only what CSS selects\non\".** The platform builds a form's entry list from the `name` *content\nattribute*, not from the property, so a control named through the property\nsubmitted under no name at all and was silently dropped. Measured: two\ninputs in one form, one named by attribute and one by property, and the\nform carried a single entry.\n\nSafe for a React consumer, which is what the rule is protecting: React\nrenders a custom element's props as attributes on the server, so the name\nis already in the markup being hydrated and reflecting it writes what is\nthere. It is only a change to the markup when a consumer assigns it\nimperatively later, and nothing is hydrating by then.\n\nHere rather than on each control.",
               "attribute": "name",
-              "reflects": true
-            },
-            {
-              "kind": "field",
-              "name": "reportValidityTo",
-              "type": {
-                "text": "ElementInternals['setValidity']"
-              },
-              "privacy": "private",
-              "readonly": true,
-              "description": "The platform's own `setValidity`, which the wrapper above calls.",
-              "default": "report"
-            },
-            {
-              "kind": "field",
-              "name": "reported",
-              "type": {
-                "text": "Reported"
-              },
-              "privacy": "private",
-              "default": "{ anchor: undefined, flags: {}, message: '' }",
-              "description": "What the control last reported, before any custom error is laid over it."
+              "reflects": true,
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "field",
@@ -12218,50 +13120,13 @@
               "type": {
                 "text": "string"
               },
-              "privacy": "private",
-              "default": "''",
-              "description": "The message `setCustomValidity` was given."
-            },
-            {
-              "kind": "field",
-              "name": "appliedFeedback",
-              "type": {
-                "text": "string"
-              },
-              "privacy": "private",
-              "default": "''",
-              "description": "The `validityFeedback` the platform was last told about."
-            },
-            {
-              "kind": "method",
-              "name": "applyValidity",
-              "privacy": "private",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "Hands the platform the control's own verdict with any custom error on top,\nanchored where focus can go."
-            },
-            {
-              "kind": "method",
-              "name": "validationAnchor",
               "privacy": "protected",
-              "return": {
-                "type": {
-                  "text": "HTMLElement | undefined"
-                }
-              },
-              "parameters": [
-                {
-                  "name": "anchor",
-                  "optional": true,
-                  "type": {
-                    "text": "HTMLElement"
-                  }
-                }
-              ],
-              "description": "Where the browser points its bubble: the anchor a control gave if focus\ncan go there, and its first tab stop otherwise.\n\nA group anchors on a part that holds its members and cannot take focus,\nand the platform then refuses the submission, logs that the control is\nnot focusable, and leaves the reader on the submit button."
+              "default": "''",
+              "description": "The message `setCustomValidity` was given.",
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "field",
@@ -12278,6 +13143,10 @@
                     "url": "https://developer.mozilla.org/docs/Web/API/ElementInternals/validity"
                   }
                 ]
+              },
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
               }
             },
             {
@@ -12287,7 +13156,11 @@
                 "text": "string"
               },
               "description": "The message the browser would show for the control, or an empty string.",
-              "readonly": true
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "field",
@@ -12297,7 +13170,11 @@
               },
               "privacy": "private",
               "default": "false",
-              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another."
+              "description": "Whether an update is running, so `runPendingUpdate` never starts one inside another.",
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "method",
@@ -12323,7 +13200,11 @@
                   "text": "void"
                 }
               },
-              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.\n\nProtected for a control that submits on its own, which has to hand the\nform the verdict for what it holds now: Pin Input's `autosubmit`."
+              "description": "Runs an update that is on its way, so the verdict read next is the one\nfor what the control holds now.\n\n**A control reports its verdict as it updates, and an update waits for a\nmicrotask**, so a script that wrote `value` and asked at once was answered\nabout the value before: measured on Time Input, `value = '18:00'` past a\n`max` of 17:00 and `checkValidity()` returned true until `updateComplete`.\nA native control answers about the value it was just given, so the\nquestions a script can ask run the pending update first. Lit's\n`performUpdate` is the documented way to run one synchronously.\n\nProtected for a control that submits on its own, which has to hand the\nform the verdict for what it holds now: Pin Input's `autosubmit`.",
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "field",
@@ -12332,27 +13213,11 @@
                 "text": "boolean"
               },
               "description": "Whether the control is checked when its form is submitted.",
-              "readonly": true
-            },
-            {
-              "kind": "method",
-              "name": "checkValidity",
-              "return": {
-                "type": {
-                  "text": "boolean"
-                }
-              },
-              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot. The control shows no message for it: `reportValidity()` does that."
-            },
-            {
-              "kind": "field",
-              "name": "checkInProgress",
-              "type": {
-                "text": "boolean"
-              },
-              "privacy": "private",
-              "default": "false",
-              "description": "Whether `checkValidity()` is running, set only for the `invalid` it fires."
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "method",
@@ -12362,7 +13227,11 @@
                   "text": "boolean"
                 }
               },
-              "description": "Returns whether the control is valid, and when it is not, fires `invalid`\nand shows the browser's message at the control."
+              "description": "Returns whether the control is valid, and when it is not, fires `invalid`\nand shows the browser's message at the control.",
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "method",
@@ -12380,7 +13249,11 @@
                   }
                 }
               ],
-              "description": "Marks the control invalid with `message`, or clears that with an empty\nstring, as on a native control. The form does not submit while it is set."
+              "description": "Marks the control invalid with `message`, or clears that with an empty\nstring, as on a native control. The form does not submit while it is set.",
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "field",
@@ -12390,7 +13263,11 @@
               },
               "privacy": "protected",
               "description": "The element focus goes to: the control's first tab stop, or `null` where\nthere is none.\n\nRead through shadow roots and slots, so a group lands on the member that\nholds its tab stop, which is the chosen radio in a radio group.",
-              "readonly": true
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "method",
@@ -12409,21 +13286,33 @@
                   }
                 }
               ],
-              "description": "Moves focus to the control, as focusing a native control does."
+              "description": "Moves focus to the control, as focusing a native control does.",
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "field",
               "name": "focusFromLabel",
               "privacy": "private",
               "readonly": true,
-              "description": "Focuses the control when its `<label>` is pressed.\n\nThe label sends the host a click of the browser's own after trying to\nfocus it, and a host that is not focusable takes nothing from that try.\nOnly a click that starts at the host and that the browser sent: one from\ninside has landed where it meant to, and `click()` from a script does not\nfocus a native control either."
+              "description": "Focuses the control when its `<label>` is pressed.\n\nThe label sends the host a click of the browser's own after trying to\nfocus it, and a host that is not focusable takes nothing from that try.\nOnly a click that starts at the host and that the browser sent: one from\ninside has landed where it meant to, and `click()` from a script does not\nfocus a native control either.",
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "field",
               "name": "refreshAnchor",
               "privacy": "private",
               "readonly": true,
-              "description": "Re-anchors the verdict as the form checks it, because the control's\nmembers may have rendered since it last reported, and the anchor read then\nwas the best there was."
+              "description": "Re-anchors the verdict as the form checks it, because the control's\nmembers may have rendered since it last reported, and the anchor read then\nwas the best there was.",
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "field",
@@ -12432,25 +13321,11 @@
                 "text": "(() => void) | undefined"
               },
               "privacy": "private",
-              "description": "Stops listening for the labels in this control's tree."
-            },
-            {
-              "kind": "method",
-              "name": "formAssociatedCallback",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "parameters": [
-                {
-                  "name": "form",
-                  "type": {
-                    "text": "HTMLFormElement | null"
-                  }
-                }
-              ],
-              "description": "Called by the browser when the control's form changes: watches the new\nform's `checkValidity()`, as connecting does for the form it starts in."
+              "description": "Stops listening for the labels in this control's tree.",
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "kind": "field",
@@ -12467,6 +13342,10 @@
                     "url": "https://html.spec.whatwg.org/multipage/custom-elements.html#form-associated-custom-elements"
                   }
                 ]
+              },
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
               }
             },
             {
@@ -12484,6 +13363,10 @@
                     "url": "https://html.spec.whatwg.org/multipage/custom-elements.html#form-associated-custom-elements"
                   }
                 ]
+              },
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
               }
             },
             {
@@ -12785,6 +13668,21 @@
                 "module": "src/helix-element/helix-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "markRules",
+              "type": {
+                "text": "readonly string[]"
+              },
+              "privacy": "protected",
+              "static": true,
+              "default": "[]",
+              "description": "The rules from `mark-rules.ts` for the marks this element writes in its\nown shadow root: `data-scroller`, `data-virtual`, `data-spoken` and\n`data-mirror`.\n\nA component that writes a mark names its rule here, and a subclass\ninherits the list. One that writes none takes only the three rules every\nshadow root gets, which is what keeps the other four out of a Button.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "finalizeStyles",
@@ -12804,7 +13702,7 @@
                   }
                 }
               ],
-              "description": "Prepends the shadow-root reset to every subclass's styles, so no component\nhas to remember to include it.",
+              "description": "Prepends the shadow-root reset to every subclass's styles, so no component\nhas to remember to include it, with the rules for the marks it writes.",
               "inheritedFrom": {
                 "name": "HelixElement",
                 "module": "src/helix-element/helix-element.ts"
@@ -12812,6 +13710,17 @@
             }
           ],
           "events": [],
+          "superclass": {
+            "name": "HelixFormElementBase",
+            "module": "/src/helix-form-element/helix-form-element-base.js"
+          },
+          "summary": "Base for every element that participates in a form and judges what it holds.",
+          "helix": {
+            "since": "0.1.0",
+            "status": "experimental",
+            "documentation": "https://fusion.dev/helix/docs/tiers",
+            "tier": "core"
+          },
           "attributes": [
             {
               "name": "disabled",
@@ -12820,7 +13729,11 @@
               },
               "default": "false",
               "description": "Whether the control is disabled and cannot be used.\n\nReflected, because the styled tier selects on it, and mirrored to\n`aria-disabled` rather than removing the element from the accessibility\ntree, so a screen reader can still announce that the control exists.\n\nThe mirror itself is in `willUpdate` below, here rather than in each\ncontrol, because here is where `disabled` is.",
-              "fieldName": "disabled"
+              "fieldName": "disabled",
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             },
             {
               "name": "name",
@@ -12829,20 +13742,13 @@
               },
               "default": "''",
               "description": "The name the control's value is submitted under.\n\n**Reflected, and it is the exception to \"reflect only what CSS selects\non\".** The platform builds a form's entry list from the `name` *content\nattribute*, not from the property, so a control named through the property\nsubmitted under no name at all and was silently dropped. Measured: two\ninputs in one form, one named by attribute and one by property, and the\nform carried a single entry.\n\nSafe for a React consumer, which is what the rule is protecting: React\nrenders a custom element's props as attributes on the server, so the name\nis already in the markup being hydrated and reflecting it writes what is\nthere. It is only a change to the markup when a consumer assigns it\nimperatively later, and nothing is hydrating by then.\n\nHere rather than on each control.",
-              "fieldName": "name"
+              "fieldName": "name",
+              "inheritedFrom": {
+                "name": "HelixFormElementBase",
+                "module": "src/helix-form-element/helix-form-element-base.ts"
+              }
             }
           ],
-          "superclass": {
-            "name": "HelixElement",
-            "module": "/src/helix-element/helix-element.js"
-          },
-          "summary": "Base for every element that participates in a form.",
-          "helix": {
-            "since": "0.1.0",
-            "status": "experimental",
-            "documentation": "https://fusion.dev/helix/docs/tiers",
-            "tier": "core"
-          },
           "cssStates": [
             {
               "description": "Set one frame after the first render. Transitions wait for it, so an element does not animate its own arrival.",
@@ -14815,6 +15721,38 @@
             "module": "./helix-element/helix-element.js"
           }
         },
+        {
+          "kind": "js",
+          "name": "MIRROR_RULE",
+          "declaration": {
+            "name": "MIRROR_RULE",
+            "module": "./helix-element/mark-rules.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "SCROLLER_RULE",
+          "declaration": {
+            "name": "SCROLLER_RULE",
+            "module": "./helix-element/mark-rules.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "SPOKEN_RULE",
+          "declaration": {
+            "name": "SPOKEN_RULE",
+            "module": "./helix-element/mark-rules.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "VIRTUAL_RULE",
+          "declaration": {
+            "name": "VIRTUAL_RULE",
+            "module": "./helix-element/mark-rules.js"
+          }
+        },
         {
           "kind": "js",
           "name": "HelixFormElement",
@@ -14823,6 +15761,14 @@
             "module": "./helix-form-element/helix-form-element.js"
           }
         },
+        {
+          "kind": "js",
+          "name": "HelixFormElementBase",
+          "declaration": {
+            "name": "HelixFormElementBase",
+            "module": "./helix-form-element/helix-form-element-base.js"
+          }
+        },
         {
           "kind": "js",
           "name": "MixinChartSource",
@@ -24789,7 +25735,7 @@
               }
             }
           ],
-          "description": "Warns once, through the runtime channel, when a control has no accessible\nname: none on the host, and none on the control inside it.\n\n**Read a task after the control first renders**, so a label that arrives in\nthe same pass counts: slotted, written by a framework beside the control, or\nforwarded from a `<label for>`. One timer serves every control that asked in\nthat task, and an element is read once in its life, so a name taken away\nlater is not reported.\n\n**In a development build only.** Every field and Button calls it, so in\nproduction it would cost each of them about 450 bytes gzip for a sentence\nmeant for the person writing the page. Core imports it as `#audit-name`,\nwhich `package.json` resolves here under the `development` condition (Vite\nand webpack in development, `bun --conditions development`,\n`node --conditions=development`) and to `audit-name-off.ts`, which does\nnothing, everywhere else. Like every runtime warning it reports through the\none channel, and a project that wants the console quiet tells\n`@fusion.dev/helix-diagnostics` with `core.warnings: false`.\n\n`control` returns the control inside the host, `null` where the host is the\ncontrol, or `undefined` where the control is not drawn at the moment of the\nread: the host is then read again the next time it asks.\n\n`also` answers for a name the component gave through its internals, which no\nattribute shows. `fix` is the sentence that says how to name it. `shown` is\nthe part where the control shows its value or its placeholder, whose words\nare no name."
+          "description": "Warns once, through the runtime channel, when a control has no accessible\nname: none on the host, and none on the control inside it.\n\n**Read a task after the control first renders**, so a label that arrives in\nthe same pass counts: slotted, written by a framework beside the control, or\nforwarded from a `<label for>`. One timer serves every control that asked in\nthat task, and an element is read once in its life, so a name taken away\nlater is not reported.\n\n**In a development build only.** Every field and Button calls it, so in\nproduction it would cost each of them about 450 bytes gzip for a sentence\nmeant for the person writing the page. Core imports it as `#audit-name`,\nwhich `package.json` resolves here under the `development` condition (Vite\nand webpack in development, `bun --conditions development`,\n`node --conditions=development`) and to `audit-name-off.ts`, which does\nnothing, everywhere else. Like every runtime warning it reports through the\none channel, and a project that wants the console quiet tells\n`@fusion.dev/helix-diagnostics` with `core.warnings: false`.\n\n`control` returns the control inside the host, `null` where the host is the\ncontrol, or `undefined` where the control is not drawn at the moment of the\nread: the host is then read again the next time it asks.\n\n`also` answers for a name the component gave through its internals, which no\nattribute shows. `fix` is the sentence that says how to name it, or its key\nin `FIXES`. `shown` is the part where the control shows its value or its\nplaceholder, whose words are no name."
         }
       ],
       "exports": [
@@ -34094,7 +35040,7 @@
           "type": {
             "text": "string"
           },
-          "default": "'0.182.1'",
+          "default": "'0.182.2'",
           "description": "The version of the package this file ships in.\n\n**Written by `fusion/scripts/version.mjs`** wherever it writes the package's\n`package.json`, and stamped back into the repository beside it after a\nrelease, so the two never disagree; a spec beside this holds them to it.\nNothing else in the running code knows which release it is."
         }
       ],
@@ -34730,6 +35676,6 @@
   ],
   "helix": {
     "package": "@fusion.dev/helix-core",
-    "version": "0.182.1"
+    "version": "0.182.2"
   }
 }