react-luna-form 0.0.84 → 0.0.86

package/dist/types/luna-react/src/client/lib/compose-list-value.d.ts

@@ -1,5 +1,7 @@
+import { type Nullable } from '../../../../luna-core/index';
 import type { MountedList } from './list-store';
-import type { Nullable } from '../../../../luna-core/index';
+/** A list's rows as a consumer is given them, in order. */
+export type ListRows = Array<Record<string, unknown>>;
 export declare function itemKey(listName: string, stableId: number, leafName: string): string;
 /**
  * The three places a leaf can be found, declared in the order they are tried.
@@ -38,4 +40,29 @@ export type ValueSources = {
  * @param listName - The list's name, already carrying its ancestors' stable
  *   ids (`rules.0.rule`), which is what makes the keys unambiguous.
  */
-export declare function composeListValue(listName: string, { items, leafNames }: MountedList, sources: ValueSources): Array<Record<string, unknown>>;
+export declare function composeListValue(listName: string, { items, leafNames }: MountedList, sources: ValueSources): ListRows;
+/**
+ * Every positional name a change to a list's rows can have left out of date,
+ * each with what it holds now.
+ *
+ * A consumer that keeps each report in one record -- the way the docs suggest
+ * keeping values -- holds a row's leaves there twice: inside the list's array,
+ * and under their own positional names, `items.0.value`, from the reports the
+ * leaves made as they were typed in. Removing a row moves every row after it
+ * up one position; assigning rows rewrites what every position holds. The
+ * array is reported again either way, but the names would go on holding what
+ * the rows used to hold, and `resolveEntry` tries a flat name before the path
+ * into the array: the next row to read one of them gets a row that is gone.
+ *
+ * So every name from `from` to the end of the longer of the two lists comes
+ * back, with what its position holds now, or `undefined` where no row is left
+ * -- whether or not that differs from before, because what the consumer holds
+ * is not necessarily what the list last said.
+ *
+ * @param base - The list's positional name, as the consumer addresses it.
+ * @param from - The first position the change can have touched.
+ */
+export declare function positionalEntries(base: string, from: number, previous: ListRows, next: ListRows): Array<{
+    name: string;
+    value: unknown;
+}>;

package/dist/types/luna-react/src/client/lib/error-store.d.ts

@@ -1,6 +1,9 @@
 export declare const clearInputErrorAtom: import("jotai").WritableAtom<null, [names: string[]], void> & {
     init: null;
 };
+export declare const releaseInputErrorAtom: import("jotai").WritableAtom<null, [names: string[]], void> & {
+    init: null;
+};
 export declare const reportErrorAtom: import("jotai").WritableAtom<null, [newValue: Record<string, string[]>], void> & {
     init: null;
 };

package/dist/types/luna-react/src/client/lib/host-value-store.d.ts

@@ -0,0 +1,30 @@
+import type { Nullable } from '../../../../luna-core/index';
+export declare const hostValueAtom: import("jotai").PrimitiveAtom<Nullable<Record<string, unknown>>> & {
+    init: Nullable<Record<string, unknown>>;
+};
+/**
+ * One field's entry in that record.
+ *
+ * Keyed by the name the record actually uses -- the POSITIONAL one. A leaf
+ * inside a list is named after its row's stable id, and the two diverge the
+ * moment a non-tail row is removed, so the caller translates before it
+ * subscribes. That translation lives in a React context, which an atom cannot
+ * read; doing it at the call site is what keeps this correct where a memo
+ * comparator could not be. See `ListPathContext`.
+ *
+ * Not released the way the per-name families in `store-helper` are, and it does
+ * not need to be for the same reason it is keyed this way: a position is reused
+ * where a stable id only ever climbs, so the keys here are bounded by the
+ * widest the form has ever been rather than by every row it has ever held.
+ * Measured going 1 -> 20 -> 14 -> 20 rows: the released families fall back to
+ * 23 and this one stays at 29, its high-water mark. Worth knowing before
+ * someone reads the absence of a release as an oversight.
+ */
+/** What the host says about one field, with the sentinel already read. */
+export type HostEntry = {
+    /** The host names this field. A field it does not name reads `undefined`. */
+    found: boolean;
+    value: unknown;
+};
+export declare function readHostEntry(entry: unknown): HostEntry;
+export declare const hostEntryAtom: import("jotai-family").AtomFamily<string, import("jotai").Atom<unknown>>;

package/dist/types/luna-react/src/client/lib/list-store.d.ts

@@ -12,6 +12,27 @@ export declare const reportPendingListRowsAtom: import("jotai-family").AtomFamil
 export type MountedList = {
     items: readonly number[];
     leafNames: readonly string[];
+    /**
+     * The list's own `hidden`, as its definition declares it.
+     *
+     * Here rather than looked up, because there is nowhere to look it up: the
+     * schema registry `getField` answers from is filled by `onRegister` on the
+     * input path, and a container never goes through it. That gap is what let a
+     * list keep its values through a hide -- the branch that clears a target
+     * reverting to its static hidden asked only that registry, found nothing,
+     * and skipped the list, while an explicit `hidden: true` cleared it. Same
+     * declaration, two outcomes. See `tests/e2e/hidden-clear.spec.ts`.
+     *
+     * A list that is not on screen has no entry, and that is the right answer
+     * rather than a gap: the only target worth clearing is one that was showing.
+     */
+    hidden?: boolean;
+    /**
+     * The list's own `advanced.keepValue`, published for the same reason as
+     * `hidden` and flattened on the way in: this registry answers about a list
+     * that is on screen, not about the JSON that declared it.
+     */
+    keepValue?: boolean;
 };
 export declare const mountedListsAtom: import("jotai").PrimitiveAtom<Record<string, MountedList>> & {
     init: Record<string, MountedList>;

package/dist/types/luna-react/src/client/lib/source-store.d.ts

@@ -3,3 +3,6 @@ export declare const reportSourceAtom: import("jotai-family").AtomFamily<string,
 export declare const clearInputSourceAtom: import("jotai").WritableAtom<null, [contributorNames: string[]], void> & {
     init: null;
 };
+export declare const releaseInputSourceAtom: import("jotai").WritableAtom<null, [names: string[]], void> & {
+    init: null;
+};

package/dist/types/luna-react/src/client/lib/state-store.d.ts

@@ -2,4 +2,7 @@ import type { FieldState } from '../../../../luna-core/index';
 export declare const fieldStateAtom: import("jotai").PrimitiveAtom<Record<string, FieldState>> & {
     init: Record<string, FieldState>;
 };
+export declare const releaseFieldStateAtom: import("jotai").WritableAtom<null, [names: string[]], void> & {
+    init: null;
+};
 export declare const reportFieldStateAtom: import("jotai-family").AtomFamily<string, import("jotai").WritableAtom<FieldState | undefined, [newValue: FieldState | undefined], void>>;

package/dist/types/luna-react/src/client/lib/store-helper.d.ts

@@ -5,6 +5,11 @@ type NestedAtomFamilyOptions<TInner> = {
 };
 export declare function omitKey<T extends Record<string, unknown>>(obj: T, key: string): T;
 export declare function createNestedRecordAtomFamily<TInner, TRecord extends Record<string, Record<string, TInner>> = Record<string, Record<string, TInner>>>(baseAtom: PrimitiveAtom<TRecord>, options?: NestedAtomFamilyOptions<TInner>): import("jotai-family").AtomFamily<string, import("jotai").WritableAtom<TInner | undefined, [target: string, value: TInner | undefined], void>>;
+export declare function createNestedReleaseAtom(family: {
+    remove: (name: string) => void;
+}): import("jotai").WritableAtom<null, [names: string[]], void> & {
+    init: null;
+};
 export declare function createNestedClearAtom<TInner>(baseAtom: PrimitiveAtom<Record<string, Record<string, TInner>>>): import("jotai").WritableAtom<null, [contributorNames: string[]], void> & {
     init: null;
 };
@@ -21,6 +26,9 @@ export declare function createAtomStore<T>(initialValue?: Record<string, T>): {
     bulkReport: import("jotai").WritableAtom<null, [newValue: Record<string, T>], void> & {
         init: null;
     };
+    release: import("jotai").WritableAtom<null, [names: string[]], void> & {
+        init: null;
+    };
     report: import("jotai-family").AtomFamily<string, import("jotai").WritableAtom<NonNullable<T> | undefined, [newValue: T | undefined], void>>;
 };
 export {};

package/dist/types/luna-react/src/client/lib/value-store.d.ts

@@ -7,6 +7,9 @@ export declare const clearAllValueAtom: import("jotai").WritableAtom<null, [], v
 export declare const clearInputValueAtom: import("jotai").WritableAtom<null, [names: string[]], void> & {
     init: null;
 };
+export declare const releaseInputValueAtom: import("jotai").WritableAtom<null, [names: string[]], void> & {
+    init: null;
+};
 export declare const reportValueAtom: import("jotai-family").AtomFamily<string, import("jotai").WritableAtom<{} | undefined, [newValue: unknown], void>>;
 export declare const appliedAutoFillAtom: import("jotai").PrimitiveAtom<Record<string, unknown>> & {
     init: Record<string, unknown>;

package/dist/types/luna-react/src/component/collapsible.d.ts

@@ -1,4 +1,5 @@
-export declare function Collapsible({ children, visible, }: Readonly<{
+export declare function Collapsible({ children, onReveal, visible, }: Readonly<{
     children: React.ReactNode;
+    onReveal?: () => void;
     visible?: boolean;
 }>): import("react").JSX.Element;

package/dist/types/luna-react/src/component/form.d.ts

@@ -1,5 +1,6 @@
 import { type Definition, type Sections } from '../../../luna-core/index';
 import type { Config, Control, Slot } from '../type';
+import type { FormEvent } from 'react';
 export declare function Form(props: Readonly<{
     advanced?: {
         step?: boolean;
@@ -11,6 +12,7 @@ export declare function Form(props: Readonly<{
     definition?: Definition;
     isPending?: boolean;
     noValidate?: boolean;
+    onSubmit?: (event: FormEvent<HTMLFormElement>) => void;
     readOnly?: boolean;
     sections: Sections;
     translations?: Record<string, string>;

package/dist/types/luna-react/src/component/input/input-base.d.ts

@@ -7,5 +7,6 @@ export declare function InputBase(props: Readonly<{
     field: Field;
     horizontal?: boolean;
     lang?: string;
+    readOnly?: boolean;
     translations?: Record<string, string>;
 }>): import("react").ReactNode;

package/dist/types/luna-react/src/type.d.ts

@@ -12,6 +12,7 @@ export type Children = (props: {
     dataAttributes?: DataAttributes;
     field: Field;
     horizontal?: boolean;
+    readOnly?: boolean;
 }) => React.ReactNode;
 export type InputConfig<T extends React.ElementType> = {
     types: string | string[];

package/docs/events/change.md

@@ -159,7 +159,7 @@ A row's key can name a field that is itself a `list`, in which case its value is
 Every rule above holds one level down as well: an inner list assigns rather than adds, honours its own `advanced.length`, and keeps the identity of the rows that survive. Two more only come up here:
 
 - **A row that names an inner list without giving it rows empties it.** `"checks": []`, a `checks` key holding something that is not rows, and no `checks` key at all all mean the same thing — none — rather than leaving behind what the row in that position had.
-- **The consumer is told once for the whole tree**, under the outer list's name, with the inner rows already in it. The inner lists then report their own paths (`groups.0.checks`) as they take their rows, the same way they do when a row is added or removed by hand.
+- **The consumer is told the whole tree at once**, under the outer list's name, with the inner rows already in it, and then every positional name the assignment rewrote (`groups.0.label`, `groups.1.checks.0.v`) with what that position holds now, or nothing where no row is left. A consumer that keeps each report in one record would otherwise go on holding the values of the rows that went away under those names. The inner lists then report their own paths (`groups.0.checks`) as they take their rows, the same way they do when a row is added or removed by hand.
 
 This is what the relative syntax cannot do. `"groups/checks"` reaches the inner list of the row the sender is sitting in, and `"groups.0.checks"` reaches the first one; neither can say "every group", so a control that appends a group has to assign the outer list and carry the inner rows along with it.
 
@@ -232,6 +232,52 @@ A target that holds nothing is not announced — there is nothing to clear —
 and a target that keeps its own values under compound names (a `group`, a
 `list`) has each of those cleared and reported in its own right.
 
+It does not matter how the form phrases the hiding. A rule whose state is
+`hidden: true`, and a rule that reveals with `hidden: false` and stops matching
+so the field falls back to its own `hidden`, are the same act and clear the
+same values -- containers included.
+
+What the cleared target decided goes with it. A target with `state` rules of its
+own asserted them on the strength of its value, and that value is gone, so its
+rules are undone as if it held nothing: a field it revealed is hidden again --
+and cleared, if it too falls back to `hidden` -- and so on down the chain.
+Showing the first target again brings it back empty, and nothing it had revealed
+comes back with it. A target that keeps its value through the hide keeps what
+its rules decided as well; see below.
+
+#### Keeping a value through a hide
+
+A field that declares `advanced.keepValue: true` is put away rather than
+dropped: hiding it leaves what it held, showing it again gives it back, and the
+consumer is told nothing because nothing was taken.
+
+```json
+{
+  "label": "Raw text",
+  "name": "raw",
+  "type": "textarea",
+  "hidden": true,
+  "advanced": { "keepValue": true }
+}
+```
+
+It sits in `advanced` beside [`transient`](#transient-controls), which is the
+other key that decides what ends up stored, rather than beside `hidden`: the
+two read as a pair, but `hidden` is what the form does to the field and this is
+what the field is.
+
+It is declared on the FIELD and not on the rule, for the same reason the clear
+does not care how the hiding was phrased: a field either survives being put
+away or it does not, and which of several rules happened to hide it this time
+says nothing about that. A
+[`list`](../fields/list.md#advanced-configuration-advanced-object) may declare
+it too, and then it covers every value its rows hold.
+
+Reach for it where two fields are two views of the same thing and the form
+swaps between them -- there, hiding one is a change of scenery, not a change of
+mind. Leave it off everywhere else: a value the user cannot see and cannot
+correct is one that still gets submitted.
+
 #### What `when` compares against for a `chips` field
 
 A `chips` field [holds an array](../fields/select.md#a-chips-value-is-always-an-array),

package/docs/fields/custom-inputs.md

@@ -60,6 +60,10 @@ its own handlers must call the ones it received, or the form never learns the
 value changed: validation will not run, and neither will any `change` event the
 field declares.
 
+A `readonly` field arrives `disabled` and without a `name`. Its value is still
+submitted, but by the form, in hidden inputs of its own: nothing your component
+renders for it is sent, so it is sent once, whatever your component renders.
+
 ## Forwarding `id` is what gives the field its name
 
 The label is rendered by this library, outside your component, as

package/docs/fields/input.md

@@ -28,8 +28,8 @@ Luna Form's input fields inherit the standard logical properties available to al
   - Or an object payload: `{ title: string, message: string, collapsed?: boolean }`.
 - **`placeholder`** _(string, optional)_: The temporary placeholder text shown when the input is empty.
 - **`required`** _(boolean, optional)_: If `true`, standard browser/HTML5 validation makes the field mandatory.
-- **`disabled`** _(boolean, optional)_: If `true`, the field is non-interactive and blocked from events.
-- **`readonly`** _(boolean, optional)_: If `true`, the field's value is locked and cannot be modified by the user.
+- **`disabled`** _(boolean, optional)_: If `true`, the field is non-interactive and blocked from events, and its value is not submitted.
+- **`readonly`** _(boolean, optional)_: If `true`, the field's value is locked and cannot be modified by the user, but it is still submitted. The control renders disabled, the one lock every input component understands, and the form sends the value itself. A field that is both `readonly` and `disabled` is not submitted.
 - **`hidden`** _(boolean, optional)_: If `true`, the field is hidden from the user interface.
 - **`order`** _(number, optional)_: A numeric order determining the field's position relative to adjacent fields.
 
@@ -47,6 +47,7 @@ The `advanced` property dictates finer HTML details, interactive structures, and
 - **`reverse`** _(boolean)_: `checkbox` only, and it exists to turn a default **off**. A checkbox renders its box first and its label after it; `reverse: false` swaps them, `true` changes nothing, and on any other field type the key is not read. See [Layout](../structure/layout.md#advancedreverse-checkbox-only).
 - **`aria`** _(object)_: Map of specific ARIA attributes for screen readers (e.g., `{ "aria-label": "Custom label" }`).
 - **`data`** _(object)_: Map of specific HTML data attributes (e.g., `{ "data-test-id": "my-field" }`).
+- **`keepValue`** _(boolean)_: If `true`, hiding the field leaves its value behind instead of taking it — the field is put away rather than dropped. See [Keeping a value through a hide](../events/change.md#keeping-a-value-through-a-hide).
 - **`transient`** _(boolean)_: If `true`, the field fires its change events and keeps nothing of its own — it is neither stored nor reported to the consumer. For a control whose whole job is to write to _another_ field. See [Transient controls](../events/change.md#transient-controls).
 
 ### Text & Numeric Options (`input/text`, `input/email`, `input/tel`, `input/password`, `input/number`)
@@ -54,12 +55,17 @@ The `advanced` property dictates finer HTML details, interactive structures, and
 These basic field types support extra manipulation properties inside the `advanced` block:
 
 - **`length`** _({ min?: number, max?: number })_: Applies HTML structural limits (`minlength` / `maxlength`, or `min` / `max` depending on the input type).
+- **`step`** _(number)_ (`input/number` only): A number is whole unless it declares a step, which is the browser's own default of 1. The step is rendered on the input, so its arrows move by it, and validation accepts only values on it, counted from `length.min` when there is one, as the browser does: `0.01` for a price, `0.5` for halves, `0.001` for three decimals. A step has to be a number above 0. The browser ignores 0 and below, and so does the form; text such as `"any"` is no step either, and it is never rendered. Either way the number stays whole.
 - **`transform`** _(string | string[])_: Safely intercepts user inputs and manipulates content dynamically. Options include:
   - `"lowercase"`
   - `"uppercase"`
   - `"remove-space"`
   - `"remove-accent"`
 
+### Empty and required numbers
+
+A required `input/number` accepts `0` and negative numbers: required means a value is present, not that it is at least 1. An optional one left empty is not submitted at all, rather than submitted as `0`, and its `length` bounds only apply to a value that is there. `select/year` and `select/month` read an empty selection the same way.
+
 ### Temporal Options (`input/date`, `input/time`)
 
 Date and time inputs omit transformations and instead expose a `format` property directly under `advanced` for displaying values properly:
@@ -76,6 +82,7 @@ The `validation` object resolves form errors overriding generic defaults, mappin
 - **`required`** _(string)_: Specifies the error message exposed when the element is marked exactly as `required: true` and the field is empty.
 - **`email`** _(string)_: Error message specifically asserting an invalid email format.
 - **`length`** _({ min?: string, max?: string })_: Specific string messages shown when input lengths are breached.
+- **`step`** _(string)_: The message shown when an `input/number` is off its step: a decimal on a number that declares no step, or a value off the `advanced.step` it declares. The form's dictionary translates it, as it does every other message.
 - **`custom`** _(CustomValidation | CustomValidation[])_: Powerful conditional-based logic blocks. An array specifying:
   - `field`: Optional target reference string.
   - `operator`: Logical evaluation operations (e.g., `eq`, `neq`, `gt`, `lt`).

package/docs/fields/list.md

@@ -26,6 +26,8 @@ The `advanced` property customizes structural interaction rules and layout rende
 - **`length`** _({ min?: number, max?: number })_: Configures restrictions on how many items can be generated. Enforces boundary conditions where minimum instances ensure permanent default items and maximum instances automatically disable insertion toggles. The matching error messages are declared under the list's `validation.length` — see the [Validation reference](../validation/overview.md#list-length).
   Both bounds apply to the rows a list opens with, not only to the ones added by hand: an initial `value` shorter than `min` leaves the remainder standing and empty, and one longer than `max` stops at `max`. A [`value` event](../events/change.md#targeting-a-list) assigning rows is clamped the same way.
 - **`collapsed`** _(boolean)_: When enabled, list items default to a visually collapsed representation upon mounting or adding.
+  Collapsing only hides a row: its fields keep their values, still validate and are still submitted, and a submit that fails on one of them opens the row so the error can be seen.
+- **`keepValue`** _(boolean)_: If `true`, hiding the list leaves the values behind instead of taking them. A list holds nothing under its own name, so declaring it here is a statement about the rows: it covers every value they hold. See [Keeping a value through a hide](../events/change.md#keeping-a-value-through-a-hide).
 
 ### Collapsed Previews (`preview` object)
 

package/docs/fields/specialized-selectors.md

@@ -17,6 +17,8 @@ Renders a dropdown with the 12 months of the year.
 }
 ```
 
+An optional month nobody picked is not submitted at all, and a required one asks for a value, the way an [`input/number`](input.md#empty-and-required-numbers) does.
+
 ### 2. Year Selector (`select/year`)
 
 Renders a dropdown with a range of years.
@@ -38,6 +40,8 @@ Renders a dropdown with a range of years.
 }
 ```
 
+An optional year nobody picked is not submitted at all, and a required one asks for a value, the way an [`input/number`](input.md#empty-and-required-numbers) does.
+
 ### 3. Day Selector (`select/day`)
 
 Renders a dropdown with days 1 through 31.

package/docs/forms/submit.md

@@ -103,8 +103,13 @@ If the values have to survive, hold them outside the form: mirror
 people, which is that a key you stop sending is not the same as a key you send
 empty.
 
-A **failed** validation is the opposite: the submitted values are handed back to
-the form, so the user's typing is still on screen next to the errors.
+A **failed** submit is the opposite: nothing is cleared or reset, so what the
+user entered stays on screen next to the errors — typed text, ticked boxes and
+picked options alike. An error inside a collapsed
+[section](../structure/sections.md#advancedcollapsible) or list row is brought
+on screen too: the section or row holding it opens. The form does not take over
+`value` either. What you pass is still what the fields read, so you can change
+it, or put it back, while the errors are showing.
 
 ## Turning submit validation off
 

package/docs/structure/sections.md

@@ -95,7 +95,7 @@ Renders the section closed, with its title as the toggle:
 }
 ```
 
-Three things to know before using it:
+Four things to know before using it:
 
 - **It always starts closed.** There is no key that opens it, and reopening the
   form does not remember that the user had expanded it.
@@ -103,6 +103,8 @@ Three things to know before using it:
   them. They keep their values, they still validate, and they are still
   submitted. That is the opposite of what a [`state` action](../events/change.md#what-clearing-a-hidden-target-means)
   does when it hides a field, which unmounts it and clears the value.
+- **A failed submit opens it.** When a field inside fails validation, the
+  section opens so the error can be seen, and it stays open.
 - **The description moves inside.** It renders with the fields rather than under
   the title, so it is not visible while the section is closed.
 

package/docs/validation/overview.md

@@ -18,6 +18,7 @@ This page documents every key of the `validation` object plus the shared operato
 - **`required`** _(string)_: Message shown when a field marked `required: true` is empty.
 - **`email`** _(string)_: Message for an invalid email format (`input/email`).
 - **`length`** _({ min?: string, max?: string })_: Messages when the value's length breaches `advanced.length`.
+- **`step`** _(string)_: Message when an `input/number` is off its step: a decimal on a whole number, or a value off `advanced.step`. See [Input](../fields/input.md).
 - **`custom`** _(CustomValidation | CustomValidation[])_: Cross-field comparison. See [Custom (cross-field)](#custom-cross-field).
 - **`requiredWhen`** _(WhenRule | WhenRule[])_: Conditionally required. See [requiredWhen](#requiredwhen).
 - **`pattern`** _(PatternRule)_: Regex/format check. See [pattern](#pattern).
@@ -110,6 +111,14 @@ Validates a string value against a regular expression.
 
 `pattern` never fires on an empty value — pair it with `required`/`requiredWhen` when the field is mandatory.
 
+A `regex` or `flags` that does not compile is a mistake in the definition, not in the value. The rule then holds back every value it checks with its `message`, as it does a value that does not match, and the form keeps working. The same goes for a `pattern` among [`rules`](#rules).
+
+A `regex` that compiles runs as written, on what the user types: in the browser when the form is submitted, and on the server when it validates with `buildFormSchema`. Nothing inspects it first, so it is part of the code the form ships with. Accept one only from someone you would let write that code.
+
+The shape to avoid is a pattern that can split the same text between its repetitions in more than one way, such as `^(a+)+$`, `^(\w+\s?)+$` or `^(a|a)+$`. On a value that almost matches, it backtracks exponentially, and about thirty characters can hold the page, or the server, for seconds. A repetition that opens with a separator the one before cannot close with is not ambiguous and runs in linear time, as in `^[a-z]+(-[a-z]+)*$` or `^\d+(,\d+)*$`.
+
+If definitions reach you from other people, check their patterns with a ReDoS analyzer before you accept them.
+
 ---
 
 ## `rules`
@@ -258,7 +267,7 @@ if (!result.success) {
 
 | Rule                                          | Rendered `<Form>` submit | `buildFormSchema` (headless) |
 | --------------------------------------------- | ------------------------ | ---------------------------- |
-| `required`, `email`, `length` (field)         | ✅                       | ✅                           |
+| `required`, `email`, `length`, `step` (field) | ✅                       | ✅                           |
 | `custom`                                      | ✅                       | ✅                           |
 | `requiredWhen` (top-level)                    | ✅                       | ✅                           |
 | `pattern`                                     | ✅                       | ✅                           |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-luna-form",
-  "version": "0.0.84",
+  "version": "0.0.86",
   "description": "A React library for building forms based on JSON",
   "main": "./dist/client/cjs/index.js",
   "module": "./dist/client/esm/index.js",
@@ -30,12 +30,12 @@
     "zod": "^4.0.0"
   },
   "devDependencies": {
-    "@types/react": "19.2.18",
-    "@types/react-dom": "19.2.5",
+    "@luna-form/core": "0.0.86",
+    "@types/react": "19.3.0",
+    "@types/react-dom": "19.3.0",
     "eslint-plugin-react": "7.37.5",
     "eslint-plugin-react-hooks": "7.1.1",
-    "eslint-plugin-react-refresh": "0.5.5",
-    "@luna-form/core": "0.0.84"
+    "eslint-plugin-react-refresh": "0.5.7"
   },
   "license": "Apache-2.0",
   "repository": {