@fusion.dev/helix-headless 0.0.0-dev → 0.0.2

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

@@ -48,10 +48,6 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * @csspart placeholder - What stands in until it arrives.
  */
 export declare class HelixHeadlessImage extends HelixElement {
-    /**
-     * Where the picture is.
-     */
-    src: string;
     /**
      * What it shows, for a reader who cannot see it.
      *
@@ -60,21 +56,18 @@ export declare class HelixHeadlessImage extends HelixElement {
      */
     alt: string;
     /**
-     * Whether to wait until it is nearly on screen.
-     *
-     * `lazy` by default, which is the opposite of the platform's, because a
-     * picture worth putting in a component is usually below the fold and the one
-     * that is not is the exception worth writing down.
-     */
-    loading?: 'eager' | 'lazy';
-    /**
-     * The candidate widths, passed through to the picture.
+     * How the picture is fetched across origins, which decides whether a canvas
+     * can read it.
      */
-    srcset: string;
+    crossOrigin: 'anonymous' | 'use-credentials' | null;
     /**
-     * How much of the line it will take, passed through to the picture.
+     * Whether the browser may decode off the main thread.
+     *
+     * `async` is the resting value and right for a picture in a page. `sync` is
+     * what a consumer reaches for when the picture is about to be composited with
+     * something else and a tear would show.
      */
-    sizes: string;
+    decoding: 'async' | 'auto' | 'sync';
     /**
      * How urgently to fetch it, for the one picture that is the page.
      *
@@ -86,25 +79,29 @@ export declare class HelixHeadlessImage extends HelixElement {
      */
     fetchPriority: 'auto' | 'high' | 'low';
     /**
-     * Whether the browser may decode off the main thread.
+     * Whether to wait until it is nearly on screen.
      *
-     * **The template hardcoded `async` and a consumer could not reach it**, which
-     * is worse than the property being absent: the decision was taken on their
-     * behalf and nothing said so. `async` is still the resting value and still
-     * right for a picture in a page, and `sync` is what a consumer reaches for
-     * when the picture is about to be composited with something else and a tear
-     * would show.
-     */
-    decoding: 'async' | 'auto' | 'sync';
-    /**
-     * How the picture is fetched across origins, which decides whether a canvas
-     * can read it.
+     * `lazy` by default, which is the opposite of the platform's, because a
+     * picture worth putting in a component is usually below the fold and the one
+     * that is not is the exception worth writing down.
      */
-    crossOrigin: 'anonymous' | 'use-credentials' | null;
+    loading?: 'eager' | 'lazy';
     /**
      * How much of the referring URL to send with the request.
      */
     referrerPolicy: string;
+    /**
+     * How much of the line it will take, passed through to the picture.
+     */
+    sizes: string;
+    /**
+     * Where the picture is.
+     */
+    src: string;
+    /**
+     * The candidate widths, passed through to the picture.
+     */
+    srcset: string;
     /**
      * Whether the picture is on its way, here, or never coming.
      *
@@ -115,14 +112,12 @@ export declare class HelixHeadlessImage extends HelixElement {
      * a consumer rendered: React reads the attribute appearing at upgrade as a
      * hydration mismatch, and a serialized `<helix-image status="loaded">` pasted
      * back declares that a picture has arrived which this element has never
-     * fetched. The `data-` name is the library's answer to both, being a
-     * different name a re-parse cannot mistake for a declaration, and it is what
-     * `data-closed` on `Toast.Item` already does, and `AppHeader` did until its
-     * own moved to `:state(scrolled)` for the hydration reason recorded there.
-     * A picture arrives after somebody fetched it, which puts this on the safe
-     * side of hydration: a fact that can be true on the *first* update mirrors to
-     * a custom state instead, which is what `:state(open)` and `:state(checked)`
-     * became on 27 Aug 2026 for exactly that reason.
+     * fetched. The `data-` name is the library's answer to both, being a name a
+     * re-parse cannot mistake for a declaration, and it is what `data-closed` on
+     * `Toast.Item` already does. A picture arrives after somebody fetched it,
+     * which puts this on the safe side of hydration: a fact that can be true on
+     * the *first* update mirrors to a custom state instead, which is what
+     * `:state(open)` and `:state(checked)` are.
      *
      * `loading` writes nothing, because it is where every image starts and the
      * resting state of a mirror is the attribute's absence.
@@ -136,22 +131,18 @@ export declare class HelixHeadlessImage extends HelixElement {
      * Says so under the platform's own name, because the platform's cannot escape.
      *
      * `load` and `error` on an `<img>` neither bubble nor compose, so the ones
-     * fired inside this shadow root reach nobody outside it. A consumer had a
-     * reflected attribute and a `MutationObserver` and nothing else. Re-emitting
-     * from the host is what `relayNativeEvent` is for, and it is what `Avatar`
-     * already did for the same pair on the same element.
+     * fired inside this shadow root reach nobody outside it. Re-emitting from the
+     * host is what `relayNativeEvent` is for, and it is what `Avatar` already does
+     * for the same pair on the same element.
      *
-     * **These were `helix-load` and `helix-error`, and the rename is the fix.**
-     * The argument for a prefix is a collision with a native name, and there was
-     * none to collide with here: the native events cannot reach a consumer at
-     * all. So the prefix bought nothing and cost the two spellings this library
-     * had for one idea, `Avatar` relaying `load` while `Image` invented one. See
-     * 294 and 295.
+     * **Unprefixed, unlike every other event here.** The prefix exists to stop a
+     * collision with a native name, and there is none to collide with: the native
+     * events cannot reach a consumer at all.
      *
-     * **Not bubbling, and that is not a small point.** The retired events were
-     * `bubbles: true, composed: true` deliberately, so a gallery could count its
-     * pictures with one listener. A bubbling relay of `load` reaches nothing in
-     * React: `load` is in react-dom's `nonDelegatedEvents`, so there is no root
+     * **Not bubbling, and that is not a small point.** A bubbling relay of `load`
+     * would be the tempting one, letting a gallery count its pictures with one
+     * listener, and it reaches nothing in React: `load` is in react-dom's
+     * `nonDelegatedEvents`, so there is no root
      * listener to catch it, and React attaches a direct one for `<img>` and never
      * for a custom element. `bindReactHandler` binds exactly the non-bubbling
      * ones, so matching the native propagation is what makes `onLoad` work at
@@ -173,8 +164,8 @@ export declare class HelixHeadlessImage extends HelixElement {
      * **It can only ever conclude success.** A picture that has not been attempted
      * looks exactly like one that failed: `complete` is true and `naturalWidth` is
      * zero for both, and a DOM that never fetches anything reports that for every
-     * image it has. Deciding `error` here called every picture broken the moment
-     * it rendered. Failure has an event of its own and that event is reliable, so
+     * image it has, so deciding `error` here calls every picture broken the moment
+     * it renders. Failure has an event of its own and that event is reliable, so
      * this is only here to catch the success that happened too early to hear.
      */
     private settle;
@@ -184,12 +175,11 @@ export declare class HelixHeadlessImage extends HelixElement {
     /**
      * The picture's own state, under the platform's own names.
      *
-     * The `<img>` is inside this shadow root, so a consumer asking how big the
-     * picture turned out to be, or whether it is already there, had nowhere to
-     * ask: `querySelector` does not cross a shadow boundary. `status` answers a
-     * narrower question and answers it in this library's words, which is the
-     * right report for the three states this element draws and is not a
-     * substitute for the numbers.
+     * The `<img>` is inside this shadow root and `querySelector` does not cross a
+     * shadow boundary, so a consumer asking how big the picture turned out to be,
+     * or whether it is already there, has nowhere else to ask. `status` answers a
+     * narrower question in this library's words and is no substitute for the
+     * numbers.
      *
      * `naturalWidth` and `naturalHeight` are the case worth having: they are how
      * a consumer sizes a lightbox or works out an aspect ratio, and they exist

package/dist/image/root/image-root.js

@@ -57,10 +57,6 @@ import { property, state } from 'lit/decorators.js';
 let HelixHeadlessImage = class HelixHeadlessImage extends HelixElement {
     constructor() {
         super(...arguments);
-        /**
-         * Where the picture is.
-         */
-        this.src = '';
         /**
          * What it shows, for a reader who cannot see it.
          *
@@ -69,13 +65,18 @@ let HelixHeadlessImage = class HelixHeadlessImage extends HelixElement {
          */
         this.alt = '';
         /**
-         * The candidate widths, passed through to the picture.
+         * How the picture is fetched across origins, which decides whether a canvas
+         * can read it.
          */
-        this.srcset = '';
+        this.crossOrigin = null;
         /**
-         * How much of the line it will take, passed through to the picture.
+         * Whether the browser may decode off the main thread.
+         *
+         * `async` is the resting value and right for a picture in a page. `sync` is
+         * what a consumer reaches for when the picture is about to be composited with
+         * something else and a tear would show.
          */
-        this.sizes = '';
+        this.decoding = 'async';
         /**
          * How urgently to fetch it, for the one picture that is the page.
          *
@@ -87,25 +88,21 @@ let HelixHeadlessImage = class HelixHeadlessImage extends HelixElement {
          */
         this.fetchPriority = 'auto';
         /**
-         * Whether the browser may decode off the main thread.
-         *
-         * **The template hardcoded `async` and a consumer could not reach it**, which
-         * is worse than the property being absent: the decision was taken on their
-         * behalf and nothing said so. `async` is still the resting value and still
-         * right for a picture in a page, and `sync` is what a consumer reaches for
-         * when the picture is about to be composited with something else and a tear
-         * would show.
+         * How much of the referring URL to send with the request.
          */
-        this.decoding = 'async';
+        this.referrerPolicy = '';
         /**
-         * How the picture is fetched across origins, which decides whether a canvas
-         * can read it.
+         * How much of the line it will take, passed through to the picture.
          */
-        this.crossOrigin = null;
+        this.sizes = '';
         /**
-         * How much of the referring URL to send with the request.
+         * Where the picture is.
          */
-        this.referrerPolicy = '';
+        this.src = '';
+        /**
+         * The candidate widths, passed through to the picture.
+         */
+        this.srcset = '';
         /**
          * Whether the picture is on its way, here, or never coming.
          *
@@ -116,14 +113,12 @@ let HelixHeadlessImage = class HelixHeadlessImage extends HelixElement {
          * a consumer rendered: React reads the attribute appearing at upgrade as a
          * hydration mismatch, and a serialized `<helix-image status="loaded">` pasted
          * back declares that a picture has arrived which this element has never
-         * fetched. The `data-` name is the library's answer to both, being a
-         * different name a re-parse cannot mistake for a declaration, and it is what
-         * `data-closed` on `Toast.Item` already does, and `AppHeader` did until its
-         * own moved to `:state(scrolled)` for the hydration reason recorded there.
-         * A picture arrives after somebody fetched it, which puts this on the safe
-         * side of hydration: a fact that can be true on the *first* update mirrors to
-         * a custom state instead, which is what `:state(open)` and `:state(checked)`
-         * became on 27 Aug 2026 for exactly that reason.
+         * fetched. The `data-` name is the library's answer to both, being a name a
+         * re-parse cannot mistake for a declaration, and it is what `data-closed` on
+         * `Toast.Item` already does. A picture arrives after somebody fetched it,
+         * which puts this on the safe side of hydration: a fact that can be true on
+         * the *first* update mirrors to a custom state instead, which is what
+         * `:state(open)` and `:state(checked)` are.
          *
          * `loading` writes nothing, because it is where every image starts and the
          * resting state of a mirror is the attribute's absence.
@@ -144,22 +139,18 @@ let HelixHeadlessImage = class HelixHeadlessImage extends HelixElement {
      * Says so under the platform's own name, because the platform's cannot escape.
      *
      * `load` and `error` on an `<img>` neither bubble nor compose, so the ones
-     * fired inside this shadow root reach nobody outside it. A consumer had a
-     * reflected attribute and a `MutationObserver` and nothing else. Re-emitting
-     * from the host is what `relayNativeEvent` is for, and it is what `Avatar`
-     * already did for the same pair on the same element.
+     * fired inside this shadow root reach nobody outside it. Re-emitting from the
+     * host is what `relayNativeEvent` is for, and it is what `Avatar` already does
+     * for the same pair on the same element.
      *
-     * **These were `helix-load` and `helix-error`, and the rename is the fix.**
-     * The argument for a prefix is a collision with a native name, and there was
-     * none to collide with here: the native events cannot reach a consumer at
-     * all. So the prefix bought nothing and cost the two spellings this library
-     * had for one idea, `Avatar` relaying `load` while `Image` invented one. See
-     * 294 and 295.
+     * **Unprefixed, unlike every other event here.** The prefix exists to stop a
+     * collision with a native name, and there is none to collide with: the native
+     * events cannot reach a consumer at all.
      *
-     * **Not bubbling, and that is not a small point.** The retired events were
-     * `bubbles: true, composed: true` deliberately, so a gallery could count its
-     * pictures with one listener. A bubbling relay of `load` reaches nothing in
-     * React: `load` is in react-dom's `nonDelegatedEvents`, so there is no root
+     * **Not bubbling, and that is not a small point.** A bubbling relay of `load`
+     * would be the tempting one, letting a gallery count its pictures with one
+     * listener, and it reaches nothing in React: `load` is in react-dom's
+     * `nonDelegatedEvents`, so there is no root
      * listener to catch it, and React attaches a direct one for `<img>` and never
      * for a custom element. `bindReactHandler` binds exactly the non-bubbling
      * ones, so matching the native propagation is what makes `onLoad` work at
@@ -192,8 +183,8 @@ let HelixHeadlessImage = class HelixHeadlessImage extends HelixElement {
      * **It can only ever conclude success.** A picture that has not been attempted
      * looks exactly like one that failed: `complete` is true and `naturalWidth` is
      * zero for both, and a DOM that never fetches anything reports that for every
-     * image it has. Deciding `error` here called every picture broken the moment
-     * it rendered. Failure has an event of its own and that event is reliable, so
+     * image it has, so deciding `error` here calls every picture broken the moment
+     * it renders. Failure has an event of its own and that event is reliable, so
      * this is only here to catch the success that happened too early to hear.
      */
     settle() {
@@ -237,12 +228,11 @@ let HelixHeadlessImage = class HelixHeadlessImage extends HelixElement {
     /**
      * The picture's own state, under the platform's own names.
      *
-     * The `<img>` is inside this shadow root, so a consumer asking how big the
-     * picture turned out to be, or whether it is already there, had nowhere to
-     * ask: `querySelector` does not cross a shadow boundary. `status` answers a
-     * narrower question and answers it in this library's words, which is the
-     * right report for the three states this element draws and is not a
-     * substitute for the numbers.
+     * The `<img>` is inside this shadow root and `querySelector` does not cross a
+     * shadow boundary, so a consumer asking how big the picture turned out to be,
+     * or whether it is already there, has nowhere else to ask. `status` answers a
+     * narrower question in this library's words and is no substitute for the
+     * numbers.
      *
      * `naturalWidth` and `naturalHeight` are the case worth having: they are how
      * a consumer sizes a lightbox or works out an aspect ratio, and they exist
@@ -298,31 +288,31 @@ let HelixHeadlessImage = class HelixHeadlessImage extends HelixElement {
 };
 __decorate([
     property()
-], HelixHeadlessImage.prototype, "src", void 0);
+], HelixHeadlessImage.prototype, "alt", void 0);
+__decorate([
+    property({ attribute: 'crossorigin' })
+], HelixHeadlessImage.prototype, "crossOrigin", void 0);
 __decorate([
     property()
-], HelixHeadlessImage.prototype, "alt", void 0);
+], HelixHeadlessImage.prototype, "decoding", void 0);
+__decorate([
+    property({ attribute: 'fetchpriority' })
+], HelixHeadlessImage.prototype, "fetchPriority", void 0);
 __decorate([
     property({ reflect: true })
 ], HelixHeadlessImage.prototype, "loading", void 0);
 __decorate([
-    property()
-], HelixHeadlessImage.prototype, "srcset", void 0);
+    property({ attribute: 'referrerpolicy' })
+], HelixHeadlessImage.prototype, "referrerPolicy", void 0);
 __decorate([
     property()
 ], HelixHeadlessImage.prototype, "sizes", void 0);
-__decorate([
-    property({ attribute: 'fetchpriority' })
-], HelixHeadlessImage.prototype, "fetchPriority", void 0);
 __decorate([
     property()
-], HelixHeadlessImage.prototype, "decoding", void 0);
-__decorate([
-    property({ attribute: 'crossorigin' })
-], HelixHeadlessImage.prototype, "crossOrigin", void 0);
+], HelixHeadlessImage.prototype, "src", void 0);
 __decorate([
-    property({ attribute: 'referrerpolicy' })
-], HelixHeadlessImage.prototype, "referrerPolicy", void 0);
+    property()
+], HelixHeadlessImage.prototype, "srcset", void 0);
 __decorate([
     property({ attribute: false })
 ], HelixHeadlessImage.prototype, "status", void 0);

package/dist/index.d.ts

@@ -2,11 +2,11 @@ import './element-events.generated.js';
 /**
  * Everything core exports, forwarded whole.
  *
- * Named individually before, and the list drifted every time a component used
- * something new: a value-change event, a placement type, a close event. Each
- * one compiled here and broke in the generated React package, which imports
- * the type a public property is declared with. Forwarding the module has
- * nothing to keep in step.
+ * Not a named list. The generated React package imports the type each public
+ * property is declared with, so anything a component newly reaches for (a
+ * value-change event, a placement type, a close event) compiles here and breaks
+ * there the moment the list misses it. Forwarding the module has nothing to
+ * keep in step.
  */
 export * from '@fusion.dev/helix-core';
 export * from './accordion/index.js';

package/dist/index.js

@@ -2,11 +2,11 @@ import './element-events.generated.js';
 /**
  * Everything core exports, forwarded whole.
  *
- * Named individually before, and the list drifted every time a component used
- * something new: a value-change event, a placement type, a close event. Each
- * one compiled here and broke in the generated React package, which imports
- * the type a public property is declared with. Forwarding the module has
- * nothing to keep in step.
+ * Not a named list. The generated React package imports the type each public
+ * property is declared with, so anything a component newly reaches for (a
+ * value-change event, a placement type, a close event) compiles here and breaks
+ * there the moment the list misses it. Forwarding the module has nothing to
+ * keep in step.
  */
 export * from '@fusion.dev/helix-core';
 export * from './accordion/index.js';

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

@@ -28,19 +28,12 @@ declare const HelixHeadlessInput_base: (new (...args: any[]) => import("@fusion.
  * here guesses. What this adds is the anchor, so `reportValidity` points the
  * bubble at the input rather than at the host.
  *
- * `pattern`, `minlength` and `maxlength` are forwarded with them. They were
- * promised by this paragraph and did not exist, so a consumer following the
- * sentence wrote an attribute on the host that reached no input and constrained
- * nothing: the field looked as though it were checked and was not.
+ * `pattern`, `minlength` and `maxlength` are forwarded with them.
  *
- * **`clearable` and `reveal` are the field's, not the consumer's.** The `end`
- * slot used to be the answer to both, which meant every consumer of
- * `type="search"` built the same button and every consumer of
- * `type="password"` either built the same toggle or shipped a field a reader
- * cannot check what they typed into. Neither is a slot's worth of variation:
- * one empties the value, the other flips the type, and both want the same
- * position, the same size and the same disabled behavior. The slot stays for
- * what actually varies, a unit or a prefix.
+ * **`clearable` and `reveal` are the field's, not the consumer's.** Neither is
+ * a slot's worth of variation: one empties the value, the other flips the type,
+ * and both want the same position, the same size and the same disabled
+ * behavior. The `end` slot stays for what actually varies, a unit or a prefix.
  *
  * Both opt in rather than following from `type`, and are booleans that default
  * to false. A Lit boolean property that defaults to *true* cannot be turned off
@@ -67,7 +60,6 @@ declare const HelixHeadlessInput_base: (new (...args: any[]) => import("@fusion.
  * @csspart feedback - What is wrong with it.
  * @csspart field - The box holding everything.
  * @csspart hint - Help under the field, while nothing is wrong.
- * @csspart icon - A glyph this component draws.
  * @csspart label - The question, over the field.
  * @csspart reveal - The button that shows and hides a password.
  */
@@ -82,54 +74,6 @@ export declare class HelixHeadlessInput extends HelixHeadlessInput_base {
      * a token like `email` or `bday` to ask for autofill, or to `off` to refuse.
      */
     autocomplete: string;
-    /**
-     * Shown while the field is empty.
-     *
-     * Not a label: it goes when typing starts.
-     */
-    placeholder: string;
-    /**
-     * Whether the field refuses input while still submitting its value.
-     *
-     * **`readonly`, which is the platform's spelling, and it was `read-only`
-     * until 28 Aug 2026.** A camelCase property needs an explicit `attribute`
-     * and the library had been answering that question two ways: thirteen
-     * attributes kept the name HTML uses (`crossorigin`, `maxlength`,
-     * `formnovalidate`, `dirname` and the rest) and five dash-cased a word the
-     * platform writes as one. `readonly` was the only one on both lists, this
-     * spelling on `Rating` and `read-only` on the eight other fields, so one
-     * library shipped both and each was inert on the other's families.
-     *
-     * The cost of the dash-cased form is the one this repository keeps writing
-     * down about attributes: nothing warns. `<helix-input readonly>` is what
-     * anybody who has written HTML types, it parsed to no property at all, and
-     * the field stayed editable with no error anywhere. Measured before the
-     * rename: `readOnly` came back `false`.
-     *
-     * Taken now for the reason [#213](../../../../../docs/19-queue.md) gives
-     * about the part it renamed for the same kind of reason: there is no
-     * `helix-v` tag, so no consumer is holding the old spelling, and this is free
-     * today and a deprecation after the first release.
-     * `check:attribute-names` holds it from here.
-     */
-    readOnly: boolean;
-    /**
-     * What the field accepts, which decides the keyboard and the validation.
-     *
-     * **Not reflected**, and it was. Reflection exists so a selector can reach a
-     * value, and no stylesheet in this repository selects on `type`: what it did
-     * instead was write `type="text"` onto every `<helix-input>` ever rendered,
-     * an attribute no consumer's markup had. That is precisely the fault `Button`
-     * had with `href`, `target` and `rel`, written up in the area rules as the
-     * reason the rule exists, and this was the last property in the library still
-     * doing it. Audited: ten reflected attributes have no selector anywhere, and
-     * this is the only one of them with a value that puts itself on the host.
-     *
-     * Nothing reads it from the attribute either. The real `<input>` inside takes
-     * it as a property binding, which is what makes the keyboard and the
-     * validation follow.
-     */
-    type: InputType;
     /**
      * Whether the field offers a button that empties it.
      *
@@ -144,20 +88,44 @@ export declare class HelixHeadlessInput extends HelixHeadlessInput_base {
      */
     clearLabel: string;
     /**
-     * Whether a password field offers a toggle that shows what was typed.
+     * Most characters the value may have.
+     */
+    maxLength?: number;
+    /**
+     * Fewest characters the value may have.
+     */
+    minLength?: number;
+    /**
+     * A regular expression the value has to match, as the platform reads it.
      *
-     * Ignored on every other type. A reveal on an email field would be a button
-     * that does nothing visible, and guarding it here rather than asking the
-     * consumer not to means the property can be set once on a component that
-     * changes type.
+     * Forwarded rather than checked here, which is the whole reason validity is
+     * the platform's: the browser knows what a `pattern` means, anchors it at both
+     * ends, and produces the message in the reader's own language.
      */
-    reveal: boolean;
+    pattern: string;
     /**
-     * What the reveal toggle is called.
+     * Shown while the field is empty.
      *
-     * The state is `aria-pressed`, not this.
+     * Not a label: it goes when typing starts.
      */
-    revealLabel: string;
+    placeholder: string;
+    /**
+     * Whether the field refuses input while still submitting its value.
+     *
+     * **The attribute is `readonly`, which is the platform's spelling.** A
+     * camelCase property needs an explicit `attribute`, and dash-casing a word
+     * HTML writes as one costs what an attribute always costs here: nothing
+     * warns. `<helix-input readonly>` is what anybody who has written HTML types;
+     * against `read-only` it parses to no property at all, and the field stays
+     * editable with no error anywhere. Measured on the dash-cased form, `readOnly`
+     * came back `false`.
+     *
+     * A part was renamed for
+     * the same kind of reason: there is no `helix-v` tag, so no consumer is
+     * holding the old spelling, and this is free today and a deprecation after
+     * the first release.
+     */
+    readOnly: boolean;
     /**
      * Whether the password is currently showing.
      *
@@ -187,7 +155,7 @@ export declare class HelixHeadlessInput extends HelixHeadlessInput_base {
      * the boundary. An insert-at-cursor toolbar, a format button, a mask that
      * repositions the caret after rewriting the value, all of them need this and
      * none of them could be written. Textarea gained the same surface for the same
-     * reason. See 295.
+     * reason.
      *
      * Zero before there is a control, which is where an empty field's caret would
      * be anyway.
@@ -251,26 +219,34 @@ export declare class HelixHeadlessInput extends HelixHeadlessInput_base {
     protected willUpdate(changed: PropertyValues): void;
     protected updated(changed: PropertyValues): void;
     /**
-     * A regular expression the value has to match, as the platform reads it.
-     *
-     * The class documentation promised `pattern` and `minlength` "and the rest"
-     * were set on the real input, and no such properties existed: a consumer
-     * following that sentence wrote an attribute on the host, it reached no input,
-     * and the field constrained nothing while looking as though it did.
+     * Whether a password field offers a toggle that shows what was typed.
      *
-     * Forwarded rather than checked here, which is the whole reason validity is
-     * the platform's: the browser knows what a `pattern` means, anchors it at both
-     * ends, and produces the message in the reader's own language.
+     * Ignored on every other type. A reveal on an email field would be a button
+     * that does nothing visible, and guarding it here rather than asking the
+     * consumer not to means the property can be set once on a component that
+     * changes type.
      */
-    pattern: string;
+    reveal: boolean;
     /**
-     * Fewest characters the value may have.
+     * What the reveal toggle is called.
+     *
+     * The state is `aria-pressed`, not this.
      */
-    minLength?: number;
+    revealLabel: string;
     /**
-     * Most characters the value may have.
+     * What the field accepts, which decides the keyboard and the validation.
+     *
+     * **Not reflected.** Reflection exists so a selector can reach a value, and
+     * no stylesheet in this repository selects on `type`. Reflecting it writes
+     * `type="text"` onto every `<helix-input>` ever rendered, an attribute no
+     * consumer's markup has, which is the fault the area rules write up under
+     * `Button`'s `href`, `target` and `rel`.
+     *
+     * Nothing reads it from the attribute either. The real `<input>` inside takes
+     * it as a property binding, which is what makes the keyboard and the
+     * validation follow.
      */
-    maxLength?: number;
+    type: InputType;
     protected render(): TemplateResult;
 }
 declare global {