@formisch/svelte 0.7.6 → 0.9.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
@@ -59,7 +60,13 @@ In addition, Formisch offers several functions (we call them "methods") that can
 
 ## Comparison
 
-What makes Formisch unique is its framework-agnostic core, which is fully native to the framework you are using. It works by inserting framework-specific reactivity blocks when the core package is built. The result is a small bundle size and native performance for any UI update. This feature, along with a few others, distinguishes Formisch from other form libraries. My vision for Formisch is to create a framework-agnostic platform similar to [Vite](https://vite.dev/), but for forms.
+What makes Formisch unique is its framework-agnostic core, which is fully native to the framework you are using. It works by inserting framework-specific reactivity blocks when the core package is built, giving you native performance for any UI update. A modular methods API keeps bundles starting at just ~2.5 kB by only including the methods you import, and end-to-end type safety covers deeply nested paths and field arrays with TypeScript inference that stays fast even as forms grow.
+
+For a side-by-side look at how Formisch compares to Superforms and TanStack Form, see the [comparison guide](https://formisch.dev/svelte/guides/comparison/).
+
+## Vision
+
+My vision for Formisch is to create a framework-agnostic platform similar to [Vite](https://vite.dev/), but for forms — a shared core that lets the same mental model and codebase work natively across every modern UI framework.
 
 ## Partners
 

package/dist/components/Field/Field.svelte

@@ -1,8 +1,12 @@
 <script
   lang="ts"
-  generics="TSchema extends Schema, TFieldPath extends RequiredPath"
+  generics="TSchema extends FormSchema, TFieldPath extends RequiredPath"
 >
-  import type { RequiredPath, Schema, ValidPath } from '../../core/index.svelte';
+  import type {
+    RequiredPath,
+    FormSchema,
+    ValidPath,
+  } from '../../core/index.svelte';
   import type * as v from 'valibot';
   import { useField } from '../../runes/index';
   import type { FieldStore, FormStore } from '../../types/index';
@@ -12,7 +16,7 @@
    * Field component props interface.
    */
   export interface FieldProps<
-    TSchema extends Schema = Schema,
+    TSchema extends FormSchema = FormSchema,
     TFieldPath extends RequiredPath = RequiredPath,
   > {
     /**

package/dist/components/Field/Field.svelte.d.ts

@@ -1,11 +1,11 @@
-import type { RequiredPath, Schema, ValidPath } from '../../core/index.svelte';
+import type { RequiredPath, FormSchema, ValidPath } from '../../core/index.svelte';
 import type * as v from 'valibot';
 import type { FieldStore, FormStore } from '../../types/index';
 import type { Snippet } from 'svelte';
 /**
  * Field component props interface.
  */
-export interface FieldProps<TSchema extends Schema = Schema, TFieldPath extends RequiredPath = RequiredPath> {
+export interface FieldProps<TSchema extends FormSchema = FormSchema, TFieldPath extends RequiredPath = RequiredPath> {
     /**
      * The form store to which the field belongs.
      */
@@ -19,14 +19,14 @@ export interface FieldProps<TSchema extends Schema = Schema, TFieldPath extends
      */
     readonly children: Snippet<[FieldStore<TSchema, TFieldPath>]>;
 }
-declare function $$render<TSchema extends Schema, TFieldPath extends RequiredPath>(): {
+declare function $$render<TSchema extends FormSchema, TFieldPath extends RequiredPath>(): {
     props: FieldProps<TSchema, TFieldPath>;
     exports: {};
     bindings: "";
     slots: {};
     events: {};
 };
-declare class __sveltets_Render<TSchema extends Schema, TFieldPath extends RequiredPath> {
+declare class __sveltets_Render<TSchema extends FormSchema, TFieldPath extends RequiredPath> {
     props(): ReturnType<typeof $$render<TSchema, TFieldPath>>['props'];
     events(): ReturnType<typeof $$render<TSchema, TFieldPath>>['events'];
     slots(): ReturnType<typeof $$render<TSchema, TFieldPath>>['slots'];
@@ -34,12 +34,12 @@ declare class __sveltets_Render<TSchema extends Schema, TFieldPath extends Requi
     exports(): {};
 }
 interface $$IsomorphicComponent {
-    new <TSchema extends Schema, TFieldPath extends RequiredPath>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TSchema, TFieldPath>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TSchema, TFieldPath>['props']>, ReturnType<__sveltets_Render<TSchema, TFieldPath>['events']>, ReturnType<__sveltets_Render<TSchema, TFieldPath>['slots']>> & {
+    new <TSchema extends FormSchema, TFieldPath extends RequiredPath>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TSchema, TFieldPath>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TSchema, TFieldPath>['props']>, ReturnType<__sveltets_Render<TSchema, TFieldPath>['events']>, ReturnType<__sveltets_Render<TSchema, TFieldPath>['slots']>> & {
         $$bindings?: ReturnType<__sveltets_Render<TSchema, TFieldPath>['bindings']>;
     } & ReturnType<__sveltets_Render<TSchema, TFieldPath>['exports']>;
-    <TSchema extends Schema, TFieldPath extends RequiredPath>(internal: unknown, props: ReturnType<__sveltets_Render<TSchema, TFieldPath>['props']> & {}): ReturnType<__sveltets_Render<TSchema, TFieldPath>['exports']>;
+    <TSchema extends FormSchema, TFieldPath extends RequiredPath>(internal: unknown, props: ReturnType<__sveltets_Render<TSchema, TFieldPath>['props']> & {}): ReturnType<__sveltets_Render<TSchema, TFieldPath>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
 }
 declare const Field: $$IsomorphicComponent;
-type Field<TSchema extends Schema, TFieldPath extends RequiredPath> = InstanceType<typeof Field<TSchema, TFieldPath>>;
+type Field<TSchema extends FormSchema, TFieldPath extends RequiredPath> = InstanceType<typeof Field<TSchema, TFieldPath>>;
 export default Field;

package/dist/components/FieldArray/FieldArray.svelte

@@ -1,10 +1,10 @@
 <script
   lang="ts"
-  generics="TSchema extends Schema, TFieldArrayPath extends RequiredPath"
+  generics="TSchema extends FormSchema, TFieldArrayPath extends RequiredPath"
 >
   import type {
     RequiredPath,
-    Schema,
+    FormSchema,
     ValidArrayPath,
   } from '../../core/index.svelte';
   import type * as v from 'valibot';
@@ -16,7 +16,7 @@
    * Field array component props interface.
    */
   export interface FieldArrayProps<
-    TSchema extends Schema = Schema,
+    TSchema extends FormSchema = FormSchema,
     TFieldArrayPath extends RequiredPath = RequiredPath,
   > {
     /**

package/dist/components/FieldArray/FieldArray.svelte.d.ts

@@ -1,11 +1,11 @@
-import type { RequiredPath, Schema, ValidArrayPath } from '../../core/index.svelte';
+import type { RequiredPath, FormSchema, ValidArrayPath } from '../../core/index.svelte';
 import type * as v from 'valibot';
 import type { FieldArrayStore, FormStore } from '../../types/index';
 import type { Snippet } from 'svelte';
 /**
  * Field array component props interface.
  */
-export interface FieldArrayProps<TSchema extends Schema = Schema, TFieldArrayPath extends RequiredPath = RequiredPath> {
+export interface FieldArrayProps<TSchema extends FormSchema = FormSchema, TFieldArrayPath extends RequiredPath = RequiredPath> {
     /**
      * The form store to which the field array belongs.
      */
@@ -19,14 +19,14 @@ export interface FieldArrayProps<TSchema extends Schema = Schema, TFieldArrayPat
      */
     readonly children: Snippet<[FieldArrayStore<TSchema, TFieldArrayPath>]>;
 }
-declare function $$render<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(): {
+declare function $$render<TSchema extends FormSchema, TFieldArrayPath extends RequiredPath>(): {
     props: FieldArrayProps<TSchema, TFieldArrayPath>;
     exports: {};
     bindings: "";
     slots: {};
     events: {};
 };
-declare class __sveltets_Render<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+declare class __sveltets_Render<TSchema extends FormSchema, TFieldArrayPath extends RequiredPath> {
     props(): ReturnType<typeof $$render<TSchema, TFieldArrayPath>>['props'];
     events(): ReturnType<typeof $$render<TSchema, TFieldArrayPath>>['events'];
     slots(): ReturnType<typeof $$render<TSchema, TFieldArrayPath>>['slots'];
@@ -34,12 +34,12 @@ declare class __sveltets_Render<TSchema extends Schema, TFieldArrayPath extends
     exports(): {};
 }
 interface $$IsomorphicComponent {
-    new <TSchema extends Schema, TFieldArrayPath extends RequiredPath>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TSchema, TFieldArrayPath>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TSchema, TFieldArrayPath>['props']>, ReturnType<__sveltets_Render<TSchema, TFieldArrayPath>['events']>, ReturnType<__sveltets_Render<TSchema, TFieldArrayPath>['slots']>> & {
+    new <TSchema extends FormSchema, TFieldArrayPath extends RequiredPath>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TSchema, TFieldArrayPath>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TSchema, TFieldArrayPath>['props']>, ReturnType<__sveltets_Render<TSchema, TFieldArrayPath>['events']>, ReturnType<__sveltets_Render<TSchema, TFieldArrayPath>['slots']>> & {
         $$bindings?: ReturnType<__sveltets_Render<TSchema, TFieldArrayPath>['bindings']>;
     } & ReturnType<__sveltets_Render<TSchema, TFieldArrayPath>['exports']>;
-    <TSchema extends Schema, TFieldArrayPath extends RequiredPath>(internal: unknown, props: ReturnType<__sveltets_Render<TSchema, TFieldArrayPath>['props']> & {}): ReturnType<__sveltets_Render<TSchema, TFieldArrayPath>['exports']>;
+    <TSchema extends FormSchema, TFieldArrayPath extends RequiredPath>(internal: unknown, props: ReturnType<__sveltets_Render<TSchema, TFieldArrayPath>['props']> & {}): ReturnType<__sveltets_Render<TSchema, TFieldArrayPath>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
 }
 declare const FieldArray: $$IsomorphicComponent;
-type FieldArray<TSchema extends Schema, TFieldArrayPath extends RequiredPath> = InstanceType<typeof FieldArray<TSchema, TFieldArrayPath>>;
+type FieldArray<TSchema extends FormSchema, TFieldArrayPath extends RequiredPath> = InstanceType<typeof FieldArray<TSchema, TFieldArrayPath>>;
 export default FieldArray;

package/dist/components/Form/Form.svelte

@@ -1,7 +1,7 @@
-<script lang="ts" generics="TSchema extends Schema = Schema">
+<script lang="ts" generics="TSchema extends FormSchema = FormSchema">
   import {
     INTERNAL,
-    type Schema,
+    type FormSchema,
     type SubmitEventHandler,
   } from '../../core/index.svelte';
   import { handleSubmit } from '../../methods/index.svelte';
@@ -12,7 +12,7 @@
   /**
    * Form component props type.
    */
-  export type FormProps<TSchema extends Schema = Schema> = Omit<
+  export type FormProps<TSchema extends FormSchema = FormSchema> = Omit<
     HTMLFormAttributes,
     'on:submit' | 'onsubmit' | 'novalidate'
   > & {

package/dist/components/Form/Form.svelte.d.ts

@@ -1,11 +1,11 @@
-import { type Schema, type SubmitEventHandler } from '../../core/index.svelte';
+import { type FormSchema, type SubmitEventHandler } from '../../core/index.svelte';
 import type { FormStore } from '../../types/index';
 import type { Snippet } from 'svelte';
 import type { HTMLFormAttributes } from 'svelte/elements';
 /**
  * Form component props type.
  */
-export type FormProps<TSchema extends Schema = Schema> = Omit<HTMLFormAttributes, 'on:submit' | 'onsubmit' | 'novalidate'> & {
+export type FormProps<TSchema extends FormSchema = FormSchema> = Omit<HTMLFormAttributes, 'on:submit' | 'onsubmit' | 'novalidate'> & {
     /**
      * The form store instance.
      */
@@ -19,14 +19,14 @@ export type FormProps<TSchema extends Schema = Schema> = Omit<HTMLFormAttributes
      */
     children: Snippet;
 };
-declare function $$render<TSchema extends Schema = Schema>(): {
+declare function $$render<TSchema extends FormSchema = FormSchema>(): {
     props: FormProps<TSchema>;
     exports: {};
     bindings: "";
     slots: {};
     events: {};
 };
-declare class __sveltets_Render<TSchema extends Schema = Schema> {
+declare class __sveltets_Render<TSchema extends FormSchema = FormSchema> {
     props(): ReturnType<typeof $$render<TSchema>>['props'];
     events(): ReturnType<typeof $$render<TSchema>>['events'];
     slots(): ReturnType<typeof $$render<TSchema>>['slots'];
@@ -34,12 +34,12 @@ declare class __sveltets_Render<TSchema extends Schema = Schema> {
     exports(): {};
 }
 interface $$IsomorphicComponent {
-    new <TSchema extends Schema = Schema>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TSchema>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TSchema>['props']>, ReturnType<__sveltets_Render<TSchema>['events']>, ReturnType<__sveltets_Render<TSchema>['slots']>> & {
+    new <TSchema extends FormSchema = FormSchema>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TSchema>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TSchema>['props']>, ReturnType<__sveltets_Render<TSchema>['events']>, ReturnType<__sveltets_Render<TSchema>['slots']>> & {
         $$bindings?: ReturnType<__sveltets_Render<TSchema>['bindings']>;
     } & ReturnType<__sveltets_Render<TSchema>['exports']>;
-    <TSchema extends Schema = Schema>(internal: unknown, props: ReturnType<__sveltets_Render<TSchema>['props']> & {}): ReturnType<__sveltets_Render<TSchema>['exports']>;
+    <TSchema extends FormSchema = FormSchema>(internal: unknown, props: ReturnType<__sveltets_Render<TSchema>['props']> & {}): ReturnType<__sveltets_Render<TSchema>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
 declare const Form: $$IsomorphicComponent;
-type Form<TSchema extends Schema = Schema> = InstanceType<typeof Form<TSchema>>;
+type Form<TSchema extends FormSchema = FormSchema> = InstanceType<typeof Form<TSchema>>;
 export default Form;

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

@@ -6,6 +6,31 @@ import { untrack } from "svelte";
 * Schema type.
 */
 type Schema = v.GenericSchema | v.GenericSchemaAsync;
+/**
+* Object schema type.
+*/
+type ObjectSchema = v.LooseObjectSchema<v.ObjectEntries, v.ErrorMessage<v.LooseObjectIssue> | undefined> | v.ObjectSchema<v.ObjectEntries, v.ErrorMessage<v.ObjectIssue> | undefined> | v.StrictObjectSchema<v.ObjectEntries, v.ErrorMessage<v.StrictObjectIssue> | undefined> | v.VariantSchema<string, v.VariantOptions<string>, v.ErrorMessage<v.VariantIssue> | undefined>;
+/**
+* Object schema async type.
+*/
+type ObjectSchemaAsync = v.LooseObjectSchemaAsync<v.ObjectEntriesAsync, v.ErrorMessage<v.LooseObjectIssue> | undefined> | v.ObjectSchemaAsync<v.ObjectEntriesAsync, v.ErrorMessage<v.ObjectIssue> | undefined> | v.StrictObjectSchemaAsync<v.ObjectEntriesAsync, v.ErrorMessage<v.StrictObjectIssue> | undefined> | v.VariantSchemaAsync<string, v.VariantOptionsAsync<string>, v.ErrorMessage<v.VariantIssue> | undefined>;
+/**
+* Object root schema type.
+*/
+type ObjectRootSchema = ObjectSchema | v.IntersectSchema<ObjectSchema[], v.ErrorMessage<v.IntersectIssue> | undefined> | v.UnionSchema<ObjectSchema[], v.ErrorMessage<v.UnionIssue<v.BaseIssue<unknown>>> | undefined>;
+/**
+* Object root schema async type.
+*/
+type ObjectRootSchemaAsync = ObjectSchemaAsync | v.IntersectSchemaAsync<(ObjectSchema | ObjectSchemaAsync)[], v.ErrorMessage<v.IntersectIssue> | undefined> | v.UnionSchemaAsync<(ObjectSchema | ObjectSchemaAsync)[], v.ErrorMessage<v.UnionIssue<v.BaseIssue<unknown>>> | undefined>;
+/**
+* Form schema type.
+*
+* Hint: Forms must have an object root, so only object schemas (sync or async),
+* combinators (intersect, union, variant) whose options resolve to objects, and
+* `lazy` schemas wrapping any of these are allowed at the top level. Use
+* {@link Schema} for nested field schemas.
+*/
+type FormSchema = ObjectRootSchema | ObjectRootSchemaAsync | v.LazySchema<ObjectRootSchema> | v.LazySchemaAsync<ObjectRootSchema | ObjectRootSchemaAsync>;
 //#endregion
 //#region src/types/signal/signal.d.ts
 /**
@@ -53,6 +78,13 @@ interface InternalBaseStore {
   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[];
   /**
@@ -230,7 +262,7 @@ type ValidationMode = "initial" | "touch" | "input" | "change" | "blur" | "submi
 /**
 * Form config interface.
 */
-interface FormConfig<TSchema extends Schema = Schema> {
+interface FormConfig<TSchema extends FormSchema = FormSchema> {
   /**
   * The schema of the form.
   */
@@ -251,7 +283,7 @@ interface FormConfig<TSchema extends Schema = Schema> {
 /**
 * Internal form store interface.
 */
-interface InternalFormStore<TSchema extends Schema = Schema> extends InternalObjectStore {
+interface InternalFormStore<TSchema extends FormSchema = FormSchema> extends InternalObjectStore {
   /**
   * The element of the form.
   */
@@ -288,7 +320,7 @@ interface InternalFormStore<TSchema extends Schema = Schema> extends InternalObj
 /**
 * Base form store interface.
 */
-interface BaseFormStore<TSchema extends Schema = Schema> {
+interface BaseFormStore<TSchema extends FormSchema = FormSchema> {
   /**
   * The internal form store.
   *
@@ -299,11 +331,11 @@ interface BaseFormStore<TSchema extends Schema = Schema> {
 /**
 * Submit handler type.
 */
-type SubmitHandler<TSchema extends Schema> = (output: v.InferOutput<TSchema>) => MaybePromise<unknown>;
+type SubmitHandler<TSchema extends FormSchema> = (output: v.InferOutput<TSchema>) => MaybePromise<unknown>;
 /**
 * Submit event handler type.
 */
-type SubmitEventHandler<TSchema extends Schema> = (output: v.InferOutput<TSchema>, event: SubmitEvent) => MaybePromise<unknown>;
+type SubmitEventHandler<TSchema extends FormSchema> = (output: v.InferOutput<TSchema>, event: SubmitEvent) => MaybePromise<unknown>;
 //#endregion
 //#region src/types/path/path.d.ts
 /**
@@ -374,7 +406,10 @@ type ExactRequired<TValue> = TValue extends Record<PropertyKey, unknown> ? IsExa
 */
 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.
+* 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,
@@ -385,7 +420,7 @@ type PathValue<TValue, TPath extends Path> = TPath extends readonly [infer TKey,
 * `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;
+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.
 */
@@ -400,12 +435,34 @@ type PropertiesOfArrayPath<TValue> = { [TKey in ExactKeysOfArrayPath<TValue>]: T
 /**
 * 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;
+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;
 //#endregion
 //#region src/array/copyItemState/copyItemState.d.ts
 /**
@@ -428,9 +485,12 @@ declare function copyItemState(fromInternalFieldStore: InternalFieldStore, toInt
 * 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
 /**
@@ -444,6 +504,38 @@ declare function resetItemState(internalFieldStore: InternalFieldStore, initialI
 */
 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
+* atomic and returned in full if any item is dirty, while object keys without
+* a dirty descendant are omitted. Returns `undefined` if no descendant is
+* dirty.
+*
+* @param internalFieldStore The field store to get dirty input from.
+* @param dirtyOnly Whether to only include dirty fields. Defaults to `true`.
+*
+* @returns The dirty input, or `undefined` if no descendant is dirty.
+*/
+declare function getDirtyFieldInput(internalFieldStore: InternalFieldStore, dirtyOnly?: boolean): unknown;
+//#endregion
 //#region src/field/getElementInput/getElementInput.d.ts
 /**
 * Returns the current input of the element. Handles special cases for select
@@ -561,7 +653,24 @@ declare function walkFieldStore(internalFieldStore: InternalFieldStore, callback
 *
 * @returns The internal form store.
 */
-declare function createFormStore(config: FormConfig, parse: (input: unknown) => Promise<v.SafeParseResult<Schema>>): InternalFormStore;
+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
 /**
@@ -601,7 +710,7 @@ declare function validateIfRequired(internalFormStore: InternalFormStore, intern
 /**
 * Framework type.
 */
-type Framework = "preact" | "qwik" | "react" | "solid" | "svelte" | "vue";
+type Framework = "angular" | "preact" | "qwik" | "react" | "solid" | "svelte" | "vue";
 //#endregion
 //#region src/framework/index.svelte.d.ts
 /**
@@ -632,4 +741,4 @@ declare function createSignal<T>(initialValue: T): Signal<T>;
 */
 declare function batch<T>(fn: () => T): T;
 //#endregion
-export { BaseFormStore, Batch, DeepPartial, FieldElement, FieldSchema, FormConfig, 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, getElementInput, getFieldBool, getFieldInput, getFieldStore, initializeFieldStore, resetItemState, setFieldBool, setFieldInput, setInitialFieldInput, swapItemState, untrack, validateFormInput, validateIfRequired, walkFieldStore };
+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, decodeFormData, focusFieldElement, framework, getDirtyFieldInput, getElementInput, getFieldBool, getFieldInput, getFieldStore, initializeFieldStore, resetItemState, setFieldBool, setFieldInput, setInitialFieldInput, swapItemState, untrack, validateFormInput, validateIfRequired, walkFieldStore };