@formisch/svelte 0.8.0 → 0.10.0

package/README.md

@@ -9,6 +9,7 @@ Formisch is also available for [Preact][formisch-preact], [Qwik][formisch-qwik],
 - Small bundle size starting at 2.5 kB
 - Schema-based validation with Valibot
 - Type safety with autocompletion in editor
+- Open source and fully tested with 100 % coverage
 - It's fast – DOM updates are fine-grained
 - Minimal, readable and well thought out API
 - Supports all native HTML form fields
@@ -55,7 +56,7 @@ Every form starts with the `createForm` function. It initializes your form's sto
 </Form>
 ```
 
-In addition, Formisch offers several functions (we call them "methods") that can be used to read and manipulate the form state. These include `focus`, `getErrors`, `getAllErrors`, `getInput`, `insert`, `move`, `remove`, `replace`, `reset`, `setErrors`, `setInput`, `submit`, `swap` and `validate`. These methods allow you to control the form programmatically.
+In addition, Formisch offers several functions (we call them "methods") that can be used to read and manipulate the form state. These include `focus`, `getDeepErrorEntries`, `getDeepErrors`, `getDirtyInput`, `getDirtyPaths`, `getErrors`, `getInput`, `handleSubmit`, `insert`, `isDirty`, `isEdited`, `isTouched`, `isValid`, `move`, `pickDirty`, `remove`, `replace`, `reset`, `setErrors`, `setInput`, `submit`, `swap` and `validate`. These methods allow you to control the form programmatically.
 
 ## Comparison
 

package/dist/core/index.svelte.d.ts

@@ -1,6 +1,177 @@
 import * as v from "valibot";
 import { untrack } from "svelte";
 
+//#region src/types/utils/utils.d.ts
+/**
+* Checks if a type is `any`.
+*/
+type IsAny<T> = 0 extends 1 & T ? true : false;
+/**
+* Checks if a type is `never`.
+*/
+type IsNever<T> = [T] extends [never] ? true : false;
+/**
+* Constructs a type that is maybe a promise.
+*/
+type MaybePromise<T> = T | Promise<T>;
+/**
+* Makes all properties deeply optional.
+*/
+type DeepPartial<TValue> = TValue extends Record<PropertyKey, unknown> | readonly unknown[] ? { [TKey in keyof TValue]?: DeepPartial<TValue[TKey]> | undefined } : TValue | undefined;
+/**
+* Makes all value properties optional.
+*
+* Hint: For dynamic arrays, only plain objects and nested arrays have their
+* values made optional. Primitives and class instances are kept as-is to avoid
+* types like `(string | undefined)[]`.
+*/
+type PartialValues<TValue> = TValue extends readonly (infer TItem)[] ? number extends TValue["length"] ? (TItem extends Record<PropertyKey, unknown> | readonly unknown[] ? { [TKey in keyof TItem]: PartialValues<TItem[TKey]> } : TItem)[] : { [TKey in keyof TValue]: PartialValues<TValue[TKey]> } : TValue extends Record<PropertyKey, unknown> ? { [TKey in keyof TValue]: PartialValues<TValue[TKey]> } : TValue | undefined;
+//#endregion
+//#region src/types/path/path.d.ts
+/**
+* Path key type.
+*/
+type PathKey = string | number;
+/**
+* Path type.
+*/
+type Path = readonly PathKey[];
+/**
+* Required path type.
+*/
+type RequiredPath = readonly [PathKey, ...Path];
+/**
+* Extracts the exact keys of a tuple, array or object. Tuples return their
+* literal numeric indices, dynamic arrays return `number`, objects return
+* their `keyof` keys, and any other input returns `never`.
+*/
+type ExactKeysOf<TValue> = IsAny<TValue> extends true ? never : TValue extends readonly unknown[] ? number extends TValue["length"] ? number : { [TKey in keyof TValue]: TKey extends `${infer TIndex extends number}` ? TIndex : never }[number] : TValue extends Record<PropertyKey, unknown> ? keyof TValue & PathKey : never;
+/**
+* Returns the flat object of all indexable properties of `TValue`. For object
+* unions, properties from every member are merged so that any single property
+* is accessible. For primitives and other non-indexable types, the result is
+* `{}`.
+*
+* Hint: This is necessary to make properties accessible across union members.
+* By default, properties that do not exist in all union options are not
+* accessible and result in "any" when accessed.
+*/
+type PropertiesOf<TValue> = { [TKey in ExactKeysOf<TValue>]: TValue extends Record<TKey, infer TItem> ? TItem : never };
+/**
+* Lazily evaluates only the first valid path segment based on the given value.
+*/
+type LazyPath<TValue, TPathToCheck extends Path, TValidPath extends Path = readonly []> = TPathToCheck extends readonly [] ? TValidPath : TPathToCheck extends readonly [infer TFirstKey extends ExactKeysOf<TValue>, ...infer TPathRest extends Path] ? LazyPath<Required<PropertiesOf<TValue>[TFirstKey]>, TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<ExactKeysOf<TValue>> extends false ? readonly [...TValidPath, ExactKeysOf<TValue>] : TValidPath;
+/**
+* Returns the path if valid, otherwise the first possible valid path based on
+* the given value.
+*/
+type ValidPath<TValue, TPath extends RequiredPath> = TPath extends LazyPath<Required<TValue>, TPath> ? TPath : LazyPath<Required<TValue>, TPath>;
+/**
+* Detects whether the consuming project is configured with
+* `exactOptionalPropertyTypes: true`.
+*
+* Hint: If `false` the built-in `Required<T>` strips `| undefined` from
+* optional properties, so `Required<{ key?: undefined }>['key']` collapses
+* to `never` — under strict mode the same expression yields `undefined`.
+*/
+type IsExactOptionalProps = Required<{
+  key?: undefined;
+}>["key"] extends never ? false : true;
+/**
+* Like the built-in `Required<T>`, but preserves `| undefined` in two
+* places where `Required<T>` strips it:
+*
+* 1. Optional property values under `exactOptionalPropertyTypes: false`
+*    — without this, input typings for `v.optional`/`v.nullish` schemas
+*    narrow incorrectly (issue #15).
+* 2. Array/tuple element types — e.g. `(string | undefined)[]` stays
+*    `(string | undefined)[]` instead of becoming `string[]`. Arrays
+*    fall through unchanged because they only have a numeric index
+*    signature and don't structurally extend `Record<PropertyKey,
+*    unknown>` (which requires string keys).
+*/
+type ExactRequired<TValue> = TValue extends Record<PropertyKey, unknown> ? IsExactOptionalProps extends true ? Required<TValue> : { [TKey in keyof Required<TValue>]: TValue[TKey] } : TValue;
+/**
+* Extracts the value type at the given path.
+*/
+type PathValue<TValue, TPath extends Path> = TPath extends readonly [infer TKey, ...infer TRest extends Path] ? TKey extends ExactKeysOf<ExactRequired<TValue>> ? PathValue<PropertiesOf<ExactRequired<TValue>>[TKey], TRest> : unknown : TValue;
+/**
+* Checks whether a value is a dynamic array or contains one anywhere in its
+* shape. A fixed-length tuple is not itself a dynamic array, but it counts when
+* it contains one, so paths can still navigate through tuples to reach nested
+* arrays.
+*
+* Hint: The inner conditionals (`TValue extends readonly unknown[]` and
+* `TValue extends Record<PropertyKey, unknown>`) distribute over union members,
+* so the inner expression returns the union of each member's result (e.g.
+* `true | false` when some members contain arrays and others don't).
+* Downstream code uses `IsOrHasArray<T> extends true`, but
+* `boolean extends true` is `false` — so we collapse the result via
+* `true extends ...`, which is `true` whenever at least one union member
+* contributed `true`.
+*/
+type IsOrHasArray<TValue> = true extends (IsAny<TValue> extends true ? false : TValue extends readonly unknown[] ? number extends TValue["length"] ? true : IsOrHasArray<TValue[number]> : TValue extends Record<PropertyKey, unknown> ? { [TKey in keyof TValue]: IsOrHasArray<TValue[TKey]> }[keyof TValue] : false) ? true : false;
+/**
+* Extracts the exact keys of a tuple, array or object that contain arrays.
+*/
+type ExactKeysOfArrayPath<TValue> = IsAny<TValue> extends true ? never : TValue extends readonly (infer TItem)[] ? number extends TValue["length"] ? IsOrHasArray<TItem> extends true ? number : never : { [TKey in keyof TValue]: TKey extends `${infer TIndex extends number}` ? IsOrHasArray<NonNullable<TValue[TKey]>> extends true ? TIndex : never : never }[number] : TValue extends Record<PropertyKey, unknown> ? { [TKey in keyof TValue]: IsOrHasArray<NonNullable<TValue[TKey]>> extends true ? TKey : never }[keyof TValue] & PathKey : never;
+/**
+* Returns the flat object of indexable properties of `TValue` whose values
+* are or contain arrays. Mirrors `PropertiesOf` but keyed by
+* `ExactKeysOfArrayPath` so the lookup is provably valid for array-path
+* navigation in `LazyArrayPath`.
+*/
+type PropertiesOfArrayPath<TValue> = { [TKey in ExactKeysOfArrayPath<TValue>]: TValue extends Record<TKey, infer TItem> ? TItem : never };
+/**
+* Lazily evaluates only the first valid array path segment based on the given value.
+*/
+type LazyArrayPath<TValue, TPathToCheck extends Path, TValidPath extends Path = readonly []> = TPathToCheck extends readonly [] ? TValue extends readonly unknown[] ? number extends TValue["length"] ? TValidPath : IsNever<ExactKeysOfArrayPath<TValue>> extends false ? readonly [...TValidPath, ExactKeysOfArrayPath<TValue>] : never : readonly [...TValidPath, ExactKeysOfArrayPath<TValue>] : TPathToCheck extends readonly [infer TFirstKey extends ExactKeysOfArrayPath<TValue>, ...infer TPathRest extends Path] ? LazyArrayPath<Required<PropertiesOfArrayPath<TValue>[TFirstKey]>, TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<ExactKeysOfArrayPath<TValue>> extends false ? readonly [...TValidPath, ExactKeysOfArrayPath<TValue>] : never;
+/**
+* Returns the path if valid, otherwise the first possible valid array path
+* based on the given value.
+*/
+type ValidArrayPath<TValue, TPath extends RequiredPath> = TPath extends LazyArrayPath<Required<TValue>, TPath> ? TPath : LazyArrayPath<Required<TValue>, TPath>;
+/**
+* Recursive helper for `DirtyPath` that prepends `TKey` to each deeper path,
+* or falls through to `never` when the child is not an object.
+*/
+type DeepDirtyPath<TChild, TKey$1 extends PathKey, TDepth extends 0[]> = TChild extends Record<PropertyKey, unknown> ? readonly [TKey$1, ...DirtyPath<TChild, [...TDepth, 0]>] : never;
+/**
+* Returns the union of all `RequiredPath`s that `getDirtyPaths` can emit
+* for a given input type. Object fields contribute their own path and the
+* paths of their descendants; arrays and tuples are atomic and contribute
+* only their own path, because dirty arrays are returned as complete units.
+*
+* Narrowing is exact for the first 5 levels of nesting; deeper paths fall
+* back to `RequiredPath` to keep the result a complete superset of any
+* path the runtime can address.
+*
+* Hint: Arrays and tuples are atomic because they don't structurally
+* extend `Record<PropertyKey, unknown>` and so fall through to `never`
+* via `DeepDirtyPath` — no explicit array check is needed. `TDepth` is
+* a tuple-length counter capped at 5 to bound TypeScript instantiation
+* cost.
+*/
+type DirtyPath<TValue, TDepth extends 0[] = []> = TDepth["length"] extends 5 ? RequiredPath : TValue extends Record<PropertyKey, unknown> ? { [TKey in ExactKeysOf<TValue>]: readonly [TKey] | DeepDirtyPath<NonNullable<PropertiesOf<TValue>[TKey]>, TKey, TDepth> }[ExactKeysOf<TValue>] : never;
+/**
+* Recursive helper for `FieldPath` that prepends `TKey` to each deeper field
+* path, or falls through to `never` when the child is a leaf value.
+*/
+type DeepFieldPath<TChild, TKey$1 extends PathKey, TDepth extends 0[]> = TChild extends readonly unknown[] | Record<PropertyKey, unknown> ? readonly [TKey$1, ...FieldPath<TChild, [...TDepth, 0]>] : never;
+/**
+* Returns the union of all `RequiredPath`s that address a field within the
+* given input type. Object and array fields contribute their own path and the
+* paths of their descendants; unlike `DirtyPath`, arrays are recursed into so
+* that fields at any depth, including array items, can be addressed. Leaf
+* values contribute only their own path (emitted by their parent).
+*
+* Narrowing is exact for the first 5 levels of nesting; deeper paths fall
+* back to `RequiredPath` to keep the result a complete superset of any path
+* the runtime can address. `TDepth` is a tuple-length counter capped at 5 to
+* bound TypeScript instantiation cost.
+*/
+type FieldPath<TValue, TDepth extends 0[] = []> = TDepth["length"] extends 5 ? RequiredPath : TValue extends readonly unknown[] | Record<PropertyKey, unknown> ? { [TKey in ExactKeysOf<TValue>]: readonly [TKey] | DeepFieldPath<NonNullable<PropertiesOf<TValue>[TKey]>, TKey, TDepth> }[ExactKeysOf<TValue>] : never;
+//#endregion
 //#region src/types/schema/schema.d.ts
 /**
 * Schema type.
@@ -73,11 +244,22 @@ interface InternalBaseStore {
   */
   name: string;
   /**
+  * The path to the field.
+  */
+  path: Path;
+  /**
   * The schema of the field.
   */
   schema: Schema;
   /**
   * The initial elements of the field.
+  *
+  * Hint: This may look unused, but do not remove it. `copyItemState` and
+  * `swapItemState` move the `elements` reference between field stores when
+  * array items are inserted, moved, removed or swapped, and `reset` restores
+  * each field's original element via `elements = initialElements`. Without it,
+  * focus and file reset target the wrong element after a reorder followed by a
+  * reset.
   */
   initialElements: FieldElement[];
   /**
@@ -93,6 +275,15 @@ interface InternalBaseStore {
   */
   isTouched: Signal<boolean>;
   /**
+  * The edited state of the field.
+  *
+  * Hint: Unlike `isTouched`, which is also set when a field is focused, this
+  * is only set when the field's value is changed. Unlike `isDirty`, it stays
+  * `true` even if the value is changed back to its initial value. It is only
+  * reset when the field is reset.
+  */
+  isEdited: Signal<boolean>;
+  /**
   * The dirty state of the field.
   */
   isDirty: Signal<boolean>;
@@ -106,6 +297,14 @@ interface InternalArrayStore extends InternalBaseStore {
   */
   kind: "array";
   /**
+  * Whether the array schema is wrapped in a nullish schema.
+  *
+  * Hint: This indicates whether a missing input should be represented as the
+  * nullish value (`null`/`undefined`) or as a present but empty array
+  * (`true`). It keeps resetting consistent with the initial state.
+  */
+  isNullish: boolean;
+  /**
   * The children of the array field.
   */
   children: InternalFieldStore[];
@@ -158,6 +357,14 @@ interface InternalObjectStore extends InternalBaseStore {
   */
   kind: "object";
   /**
+  * Whether the object schema is wrapped in a nullish schema.
+  *
+  * Hint: This indicates whether a missing input should be represented as the
+  * nullish value (`null`/`undefined`) or as a present but empty object
+  * (`true`). It keeps resetting consistent with the initial state.
+  */
+  isNullish: boolean;
+  /**
   * The children of the object field.
   */
   children: Record<string, InternalFieldStore>;
@@ -221,32 +428,6 @@ type InternalFieldStore = InternalArrayStore | InternalObjectStore | InternalVal
 */
 declare const INTERNAL: "~internal";
 //#endregion
-//#region src/types/utils/utils.d.ts
-/**
-* Checks if a type is `any`.
-*/
-type IsAny<T> = 0 extends 1 & T ? true : false;
-/**
-* Checks if a type is `never`.
-*/
-type IsNever<T> = [T] extends [never] ? true : false;
-/**
-* Constructs a type that is maybe a promise.
-*/
-type MaybePromise<T> = T | Promise<T>;
-/**
-* Makes all properties deeply optional.
-*/
-type DeepPartial<TValue> = TValue extends Record<PropertyKey, unknown> | readonly unknown[] ? { [TKey in keyof TValue]?: DeepPartial<TValue[TKey]> | undefined } : TValue | undefined;
-/**
-* Makes all value properties optional.
-*
-* Hint: For dynamic arrays, only plain objects and nested arrays have their
-* values made optional. Primitives and class instances are kept as-is to avoid
-* types like `(string | undefined)[]`.
-*/
-type PartialValues<TValue> = TValue extends readonly (infer TItem)[] ? number extends TValue["length"] ? (TItem extends Record<PropertyKey, unknown> | readonly unknown[] ? { [TKey in keyof TItem]: PartialValues<TItem[TKey]> } : TItem)[] : { [TKey in keyof TValue]: PartialValues<TValue[TKey]> } : TValue extends Record<PropertyKey, unknown> ? { [TKey in keyof TValue]: PartialValues<TValue[TKey]> } : TValue | undefined;
-//#endregion
 //#region src/types/form/form.d.ts
 /**
 * Validation mode type.
@@ -330,136 +511,13 @@ type SubmitHandler<TSchema extends FormSchema> = (output: v.InferOutput<TSchema>
 */
 type SubmitEventHandler<TSchema extends FormSchema> = (output: v.InferOutput<TSchema>, event: SubmitEvent) => MaybePromise<unknown>;
 //#endregion
-//#region src/types/path/path.d.ts
-/**
-* Path key type.
-*/
-type PathKey = string | number;
-/**
-* Path type.
-*/
-type Path = readonly PathKey[];
-/**
-* Required path type.
-*/
-type RequiredPath = readonly [PathKey, ...Path];
-/**
-* Extracts the exact keys of a tuple, array or object. Tuples return their
-* literal numeric indices, dynamic arrays return `number`, objects return
-* their `keyof` keys, and any other input returns `never`.
-*/
-type ExactKeysOf<TValue> = IsAny<TValue> extends true ? never : TValue extends readonly unknown[] ? number extends TValue["length"] ? number : { [TKey in keyof TValue]: TKey extends `${infer TIndex extends number}` ? TIndex : never }[number] : TValue extends Record<PropertyKey, unknown> ? keyof TValue & PathKey : never;
-/**
-* Returns the flat object of all indexable properties of `TValue`. For object
-* unions, properties from every member are merged so that any single property
-* is accessible. For primitives and other non-indexable types, the result is
-* `{}`.
-*
-* Hint: This is necessary to make properties accessible across union members.
-* By default, properties that do not exist in all union options are not
-* accessible and result in "any" when accessed.
-*/
-type PropertiesOf<TValue> = { [TKey in ExactKeysOf<TValue>]: TValue extends Record<TKey, infer TItem> ? TItem : never };
-/**
-* Lazily evaluates only the first valid path segment based on the given value.
-*/
-type LazyPath<TValue, TPathToCheck extends Path, TValidPath extends Path = readonly []> = TPathToCheck extends readonly [] ? TValidPath : TPathToCheck extends readonly [infer TFirstKey extends ExactKeysOf<TValue>, ...infer TPathRest extends Path] ? LazyPath<Required<PropertiesOf<TValue>[TFirstKey]>, TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<ExactKeysOf<TValue>> extends false ? readonly [...TValidPath, ExactKeysOf<TValue>] : TValidPath;
-/**
-* Returns the path if valid, otherwise the first possible valid path based on
-* the given value.
-*/
-type ValidPath<TValue, TPath extends RequiredPath> = TPath extends LazyPath<Required<TValue>, TPath> ? TPath : LazyPath<Required<TValue>, TPath>;
-/**
-* Detects whether the consuming project is configured with
-* `exactOptionalPropertyTypes: true`.
-*
-* Hint: If `false` the built-in `Required<T>` strips `| undefined` from
-* optional properties, so `Required<{ key?: undefined }>['key']` collapses
-* to `never` — under strict mode the same expression yields `undefined`.
-*/
-type IsExactOptionalProps = Required<{
-  key?: undefined;
-}>["key"] extends never ? false : true;
-/**
-* Like the built-in `Required<T>`, but preserves `| undefined` in two
-* places where `Required<T>` strips it:
-*
-* 1. Optional property values under `exactOptionalPropertyTypes: false`
-*    — without this, input typings for `v.optional`/`v.nullish` schemas
-*    narrow incorrectly (issue #15).
-* 2. Array/tuple element types — e.g. `(string | undefined)[]` stays
-*    `(string | undefined)[]` instead of becoming `string[]`. Arrays
-*    fall through unchanged because they only have a numeric index
-*    signature and don't structurally extend `Record<PropertyKey,
-*    unknown>` (which requires string keys).
-*/
-type ExactRequired<TValue> = TValue extends Record<PropertyKey, unknown> ? IsExactOptionalProps extends true ? Required<TValue> : { [TKey in keyof Required<TValue>]: TValue[TKey] } : TValue;
-/**
-* Extracts the value type at the given path.
-*/
-type PathValue<TValue, TPath extends Path> = TPath extends readonly [infer TKey, ...infer TRest extends Path] ? TKey extends ExactKeysOf<ExactRequired<TValue>> ? PathValue<PropertiesOf<ExactRequired<TValue>>[TKey], TRest> : unknown : TValue;
-/**
-* Checks whether a value is an array or contains one anywhere in its shape.
-*
-* Hint: The inner conditionals (`TValue extends readonly unknown[]` and
-* `TValue extends Record<PropertyKey, unknown>`) distribute over union members,
-* so the inner expression returns the union of each member's result (e.g.
-* `true | false` when some members contain arrays and others don't).
-* Downstream code uses `IsOrHasArray<T> extends true`, but
-* `boolean extends true` is `false` — so we collapse the result via
-* `true extends ...`, which is `true` whenever at least one union member
-* contributed `true`.
-*/
-type IsOrHasArray<TValue> = true extends (IsAny<TValue> extends true ? false : TValue extends readonly unknown[] ? true : TValue extends Record<PropertyKey, unknown> ? { [TKey in keyof TValue]: IsOrHasArray<TValue[TKey]> }[keyof TValue] : false) ? true : false;
-/**
-* Extracts the exact keys of a tuple, array or object that contain arrays.
-*/
-type ExactKeysOfArrayPath<TValue> = IsAny<TValue> extends true ? never : TValue extends readonly (infer TItem)[] ? number extends TValue["length"] ? IsOrHasArray<TItem> extends true ? number : never : { [TKey in keyof TValue]: TKey extends `${infer TIndex extends number}` ? IsOrHasArray<NonNullable<TValue[TKey]>> extends true ? TIndex : never : never }[number] : TValue extends Record<PropertyKey, unknown> ? { [TKey in keyof TValue]: IsOrHasArray<NonNullable<TValue[TKey]>> extends true ? TKey : never }[keyof TValue] & PathKey : never;
-/**
-* Returns the flat object of indexable properties of `TValue` whose values
-* are or contain arrays. Mirrors `PropertiesOf` but keyed by
-* `ExactKeysOfArrayPath` so the lookup is provably valid for array-path
-* navigation in `LazyArrayPath`.
-*/
-type PropertiesOfArrayPath<TValue> = { [TKey in ExactKeysOfArrayPath<TValue>]: TValue extends Record<TKey, infer TItem> ? TItem : never };
-/**
-* Lazily evaluates only the first valid array path segment based on the given value.
-*/
-type LazyArrayPath<TValue, TPathToCheck extends Path, TValidPath extends Path = readonly []> = TPathToCheck extends readonly [] ? TValue extends readonly unknown[] ? TValidPath : readonly [...TValidPath, ExactKeysOfArrayPath<TValue>] : TPathToCheck extends readonly [infer TFirstKey extends ExactKeysOfArrayPath<TValue>, ...infer TPathRest extends Path] ? LazyArrayPath<Required<PropertiesOfArrayPath<TValue>[TFirstKey]>, TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<ExactKeysOfArrayPath<TValue>> extends false ? readonly [...TValidPath, ExactKeysOfArrayPath<TValue>] : never;
-/**
-* Returns the path if valid, otherwise the first possible valid array path
-* based on the given value.
-*/
-type ValidArrayPath<TValue, TPath extends RequiredPath> = TPath extends LazyArrayPath<Required<TValue>, TPath> ? TPath : LazyArrayPath<Required<TValue>, TPath>;
-/**
-* Recursive helper for `DirtyPath` that prepends `TKey` to each deeper path,
-* or falls through to `never` when the child is not an object.
-*/
-type DeepDirtyPath<TChild, TKey$1 extends PathKey, TDepth extends 0[]> = TChild extends Record<PropertyKey, unknown> ? readonly [TKey$1, ...DirtyPath<TChild, [...TDepth, 0]>] : never;
-/**
-* Returns the union of all `RequiredPath`s that `getDirtyPaths` can emit
-* for a given input type. Object fields contribute their own path and the
-* paths of their descendants; arrays and tuples are atomic and contribute
-* only their own path, because dirty arrays are returned as complete units.
-*
-* Narrowing is exact for the first 5 levels of nesting; deeper paths fall
-* back to `RequiredPath` to keep the result a complete superset of any
-* path the runtime can address.
-*
-* Hint: Arrays and tuples are atomic because they don't structurally
-* extend `Record<PropertyKey, unknown>` and so fall through to `never`
-* via `DeepDirtyPath` — no explicit array check is needed. `TDepth` is
-* a tuple-length counter capped at 5 to bound TypeScript instantiation
-* cost.
-*/
-type DirtyPath<TValue, TDepth extends 0[] = []> = TDepth["length"] extends 5 ? RequiredPath : TValue extends Record<PropertyKey, unknown> ? { [TKey in ExactKeysOf<TValue>]: readonly [TKey] | DeepDirtyPath<NonNullable<PropertiesOf<TValue>[TKey]>, TKey, TDepth> }[ExactKeysOf<TValue>] : never;
-//#endregion
 //#region src/array/copyItemState/copyItemState.d.ts
 /**
 * Copies the deeply nested state (signal values) from one field store to
 * another. This includes the `elements`, `errors`, `startInput`, `input`,
-* `isTouched`, `isDirty`, and for arrays `startItems` and `items` properties.
-* Recursively walks through the field stores and copies all signal values.
+* `isTouched`, `isEdited`, `isDirty`, and for arrays `startItems` and `items`
+* properties. Recursively walks through the field stores and copies all signal
+* values.
 *
 * @param fromInternalFieldStore The source field store to copy from.
 * @param toInternalFieldStore The destination field store to copy to.
@@ -469,28 +527,49 @@ declare function copyItemState(fromInternalFieldStore: InternalFieldStore, toInt
 //#region src/array/resetItemState/resetItemState.d.ts
 /**
 * Resets the state of a field store (signal values) deeply nested. Sets
-* `elements` to empty array, `errors` to `null`, `isTouched` and `isDirty` to
-* `false`, and `startInput`, `input`, `startItems`, and `items` to the new
-* input value. Keeps the `initialInput` and `initialItems` state unchanged for
-* form reset functionality.
+* `elements` to empty array, `errors` to `null`, `isTouched`, `isEdited` and
+* `isDirty` to `false`, and `startInput`, `input`, `startItems`, and `items` to
+* the new input value. Keeps the `initialInput` and `initialItems` state
+* unchanged for form reset functionality.
 *
 * @param internalFieldStore The field store to reset.
-* @param initialInput The new input value (can be any type including array or object).
+* @param input The new input value (can be any type including array or object).
+* @param keepStart Whether to keep `startInput` and `startItems` as the dirty
+* baseline instead of resetting them to the new input. Used when a field store
+* is reused for an in-place edit so its dirty state is detected correctly.
 */
-declare function resetItemState(internalFieldStore: InternalFieldStore, initialInput: unknown): void;
+declare function resetItemState(internalFieldStore: InternalFieldStore, input: unknown, keepStart?: boolean): void;
 //#endregion
 //#region src/array/swapItemState/swapItemState.d.ts
 /**
 * Swaps the deeply nested state (signal values) between two field stores. This
 * includes the `elements`, `errors`, `startInput`, `input`, `isTouched`,
-* `isDirty`, and for arrays `startItems` and `items` properties. Recursively
-* walks through the field stores and swaps all signal values.
+* `isEdited`, `isDirty`, and for arrays `startItems` and `items` properties.
+* Recursively walks through the field stores and swaps all signal values.
 *
 * @param firstInternalFieldStore The first field store to swap.
 * @param secondInternalFieldStore The second field store to swap.
 */
 declare function swapItemState(firstInternalFieldStore: InternalFieldStore, secondInternalFieldStore: InternalFieldStore): void;
 //#endregion
+//#region src/field/focusFieldElement/focusFieldElement.d.ts
+/**
+* Focuses the first focusable element of a field store. The elements are tried
+* in order and the first one that actually receives focus wins, so detached,
+* disabled or hidden elements are skipped. The browser decides focusability,
+* which is read back via the element's root `activeElement` so elements in a
+* shadow root or another document are handled correctly.
+*
+* Hint: A `display: none` or `hidden` element is correctly skipped in real
+* browsers, but jsdom has no layout and focuses it anyway, so that case cannot
+* be covered by unit tests.
+*
+* @param internalFieldStore The field store to focus.
+*
+* @returns Whether an element was focused.
+*/
+declare function focusFieldElement(internalFieldStore: InternalFieldStore): boolean;
+//#endregion
 //#region src/field/getDirtyFieldInput/getDirtyFieldInput.d.ts
 /**
 * Returns only the dirty input of the field store. Arrays are treated as
@@ -527,7 +606,7 @@ declare function getElementInput(element: FieldElement, internalFieldStore: Inte
 *
 * @returns Whether the property is true.
 */
-declare function getFieldBool(internalFieldStore: InternalFieldStore, type: "errors" | "isTouched" | "isDirty"): boolean;
+declare function getFieldBool(internalFieldStore: InternalFieldStore, type: "errors" | "isTouched" | "isEdited" | "isDirty"): boolean;
 //#endregion
 //#region src/field/getFieldInput/getFieldInput.d.ts
 /**
@@ -566,7 +645,7 @@ type FieldSchema = v.ArraySchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unkn
 * @param path The path to the field in the form.
 * @param nullish Whether the schema is wrapped in a nullish schema.
 */
-declare function initializeFieldStore(internalFieldStore: Partial<InternalFieldStore>, schema: FieldSchema, initialInput: unknown, path: PathKey[], nullish?: boolean): void;
+declare function initializeFieldStore(internalFieldStore: Partial<InternalFieldStore>, schema: FieldSchema, initialInput: unknown, path: Path, nullish?: boolean): void;
 //#endregion
 //#region src/field/setFieldBool/setFieldBool.d.ts
 /**
@@ -604,12 +683,19 @@ declare function setInitialFieldInput(internalFieldStore: InternalFieldStore, in
 //#region src/field/walkFieldStore/walkFieldStore.d.ts
 /**
 * Walks through the field store and all nested children, calling the callback
-* for each field store in depth-first order.
+* for each field store in depth-first order. The callback may return `true` to
+* stop the walk early, in which case `walkFieldStore` returns `true` as well.
+*
+* The walk reads array `items` reactively, so a reactive caller subscribes to
+* structural changes naturally. Imperative callers that must not subscribe
+* (e.g. when invoked inside an effect) should wrap the call in `untrack`.
 *
 * @param internalFieldStore The field store to walk.
-* @param callback The callback to invoke for each field store.
+* @param callback The callback to invoke for each field store. Return `true` to stop the walk early.
+*
+* @returns Whether the walk was stopped early by the callback.
 */
-declare function walkFieldStore(internalFieldStore: InternalFieldStore, callback: (internalFieldStore: InternalFieldStore) => void): void;
+declare function walkFieldStore(internalFieldStore: InternalFieldStore, callback: (internalFieldStore: InternalFieldStore) => boolean | void): boolean;
 //#endregion
 //#region src/form/createFormStore/createFormStore.d.ts
 /**
@@ -624,6 +710,23 @@ declare function walkFieldStore(internalFieldStore: InternalFieldStore, callback
 */
 declare function createFormStore(config: FormConfig, parse: (input: unknown) => Promise<v.SafeParseResult<FormSchema>>): InternalFormStore;
 //#endregion
+//#region src/form/decodeFormData/decodeFormData.d.ts
+/**
+* Decodes the entries of a form data object into nested form values using the
+* Valibot schema as the source of truth. Information that is lost during the
+* transfer via HTTP, like numbers, booleans, dates and unchecked checkboxes,
+* is restored based on the schema.
+*
+* The keys of the form data are expected to be the stringified field paths that
+* Formisch assigns to its field elements (for example `["todos",0,"label"]`).
+*
+* @param schema The form schema.
+* @param formData The form data object.
+*
+* @returns The decoded form values.
+*/
+declare function decodeFormData<TSchema extends FormSchema>(schema: TSchema, formData: FormData): unknown;
+//#endregion
 //#region src/form/validateFormInput/validateFormInput.d.ts
 /**
 * Validate form input config interface.
@@ -693,4 +796,4 @@ declare function createSignal<T>(initialValue: T): Signal<T>;
 */
 declare function batch<T>(fn: () => T): T;
 //#endregion
-export { BaseFormStore, Batch, DeepPartial, DirtyPath, FieldElement, FieldSchema, FormConfig, FormSchema, INTERNAL, InternalArrayStore, InternalBaseStore, InternalFieldStore, InternalFormStore, InternalObjectStore, InternalValueStore, IsAny, IsNever, MaybePromise, PartialValues, Path, PathKey, PathValue, RequiredPath, Schema, Signal, SubmitEventHandler, SubmitHandler, Untrack, ValidArrayPath, ValidPath, ValidateFormInputConfig, ValidationMode, batch, copyItemState, createFormStore, createId, createSignal, framework, getDirtyFieldInput, getElementInput, getFieldBool, getFieldInput, getFieldStore, initializeFieldStore, resetItemState, setFieldBool, setFieldInput, setInitialFieldInput, swapItemState, untrack, validateFormInput, validateIfRequired, walkFieldStore };
+export { BaseFormStore, Batch, DeepPartial, DirtyPath, FieldElement, FieldPath, FieldSchema, FormConfig, FormSchema, INTERNAL, InternalArrayStore, InternalBaseStore, InternalFieldStore, InternalFormStore, InternalObjectStore, InternalValueStore, IsAny, IsNever, MaybePromise, PartialValues, Path, PathKey, PathValue, RequiredPath, Schema, Signal, SubmitEventHandler, SubmitHandler, Untrack, ValidArrayPath, ValidPath, ValidateFormInputConfig, ValidationMode, batch, copyItemState, createFormStore, createId, createSignal, decodeFormData, focusFieldElement, framework, getDirtyFieldInput, getElementInput, getFieldBool, getFieldInput, getFieldStore, initializeFieldStore, resetItemState, setFieldBool, setFieldInput, setInitialFieldInput, swapItemState, untrack, validateFormInput, validateIfRequired, walkFieldStore };