@formisch/preact 0.9.5 → 0.10.0

package/README.md

@@ -59,7 +59,11 @@ 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.
+
+## 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/index.d.ts

@@ -1,23 +1,47 @@
 import * as v from "valibot";
 import { ReadonlySignal, Signal } from "@preact/signals";
-import { JSX } from "preact";
+import { FocusEventHandler, FormHTMLAttributes, GenericEventHandler, InputEventHandler, JSX } from "preact";
 
 //#region ../../packages/core/dist/index.preact.d.ts
 
-//#region src/types/schema.d.ts
+//#region src/types/schema/schema.d.ts
 /**
 * 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.d.ts
-
+//#region src/types/signal/signal.d.ts
 /**
 * Batch interface.
 */
 
 //#endregion
-//#region src/types/field.d.ts
+//#region src/types/field/field.d.ts
 /**
 * Field element type.
 */
@@ -183,7 +207,7 @@ type InternalFieldStore = InternalArrayStore | InternalObjectStore | InternalVal
 */
 declare const INTERNAL: "~internal";
 //#endregion
-//#region src/types/utils.d.ts
+//#region src/types/utils/utils.d.ts
 /**
 * Checks if a type is `any`.
 */
@@ -209,7 +233,7 @@ type DeepPartial<TValue> = TValue extends Record<PropertyKey, unknown> | readonl
 */
 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.d.ts
+//#region src/types/form/form.d.ts
 /**
 * Validation mode type.
 */
@@ -217,7 +241,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.
   */
@@ -238,7 +262,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.
   */
@@ -275,7 +299,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.
   *
@@ -286,13 +310,13 @@ 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.d.ts
+//#region src/types/path/path.d.ts
 /**
 * Path key type.
 */
@@ -306,47 +330,115 @@ type Path = readonly PathKey[];
 */
 type RequiredPath = readonly [PathKey, ...Path];
 /**
-* Extracts the exact keys of a tuple, array or object.
+* 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 KeyOf<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<string, unknown> ? keyof TValue & PathKey : 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;
 /**
-* Merges array and object unions into a single object.
+* 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 any property accessible. By default,
-* properties that do not exist in all union options are not accessible
-* and result in "any" when accessed.
+* 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 MergeUnion<TValue> = { [TKey in KeyOf<TValue>]: TValue extends Record<TKey, infer TItem> ? TItem : never };
+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 KeyOf<TValue>, ...infer TPathRest extends Path] ? LazyPath<Required<MergeUnion<TValue>[TFirstKey]>, TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<KeyOf<TValue>> extends false ? readonly [...TValidPath, KeyOf<TValue>] : TValidPath;
+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 KeyOf<Required<TValue>> ? PathValue<MergeUnion<Required<TValue>>[TKey], TRest> : unknown : TValue;
+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 if a value is an array or contains one.
+* 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> = IsAny<TValue> extends true ? false : TValue extends readonly unknown[] ? true : TValue extends Record<string, unknown> ? true extends { [TKey in keyof TValue]: IsOrHasArray<TValue[TKey]> }[keyof TValue] ? true : false : false;
+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 KeyOfArrayPath<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<string, unknown> ? { [TKey in keyof TValue]: IsOrHasArray<NonNullable<TValue[TKey]>> extends true ? TKey : never }[keyof TValue] & PathKey : never;
+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, KeyOfArrayPath<TValue>] : TPathToCheck extends readonly [infer TFirstKey extends KeyOfArrayPath<TValue>, ...infer TPathRest extends Path] ? LazyArrayPath<Required<MergeUnion<TValue>[TFirstKey]>, TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<KeyOfArrayPath<TValue>> extends false ? readonly [...TValidPath, KeyOfArrayPath<TValue>] : never;
+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
 /**
@@ -365,7 +457,7 @@ type ValidArrayPath<TValue, TPath extends RequiredPath> = TPath extends LazyArra
 /**
 * Focus field config interface.
 */
-interface FocusFieldConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+interface FocusFieldConfig<TSchema extends FormSchema, TFieldPath extends RequiredPath> {
   /**
   * The path to the field to focus.
   */
@@ -379,7 +471,7 @@ interface FocusFieldConfig<TSchema extends Schema, TFieldPath extends RequiredPa
 * @param form The form store containing the field.
 * @param config The focus field configuration.
 */
-declare function focus<TSchema extends Schema, TFieldPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: FocusFieldConfig<TSchema, TFieldPath>): void;
+declare function focus<TSchema extends FormSchema, TFieldPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: FocusFieldConfig<TSchema, TFieldPath>): void;
 //#endregion
 //#region src/getAllErrors/getAllErrors.d.ts
 /**
@@ -393,6 +485,93 @@ declare function focus<TSchema extends Schema, TFieldPath extends RequiredPath>(
 */
 declare function getAllErrors(form: BaseFormStore): [string, ...string[]] | null;
 //#endregion
+//#region src/getDirtyInput/getDirtyInput.d.ts
+/**
+* Get form dirty input config interface.
+*/
+interface GetFormDirtyInputConfig {
+  /**
+  * The path to a field. Leave undefined to get the dirty input of the entire
+  * form.
+  */
+  readonly path?: undefined;
+}
+/**
+* Get field dirty input config interface.
+*/
+interface GetFieldDirtyInputConfig<TSchema extends FormSchema, TFieldPath extends RequiredPath> {
+  /**
+  * The path to the field to retrieve the dirty input from.
+  */
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+}
+/**
+* Retrieves only the dirty input values of a specific field or the entire
+* form. 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 field in the inspected subtree is dirty.
+*
+* @param form The form store to retrieve dirty input from.
+*
+* @returns The dirty input of the form or specified field, or `undefined`.
+*/
+declare function getDirtyInput<TSchema extends FormSchema>(form: BaseFormStore<TSchema>): DeepPartial<v.InferInput<TSchema>> | undefined;
+/**
+* Retrieves only the dirty input values of a specific field or the entire
+* form. 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 field in the inspected subtree is dirty.
+*
+* @param form The form store to retrieve dirty input from.
+* @param config The get dirty input configuration.
+*
+* @returns The dirty input of the form or specified field, or `undefined`.
+*/
+declare function getDirtyInput<TSchema extends FormSchema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? GetFieldDirtyInputConfig<TSchema, TFieldPath> : GetFormDirtyInputConfig): DeepPartial<TFieldPath extends RequiredPath ? PathValue<v.InferInput<TSchema>, TFieldPath> : v.InferInput<TSchema>> | undefined;
+//#endregion
+//#region src/getDirtyPaths/getDirtyPaths.d.ts
+/**
+* Get form dirty paths config interface.
+*/
+interface GetFormDirtyPathsConfig {
+  /**
+  * The path to a field. Leave undefined to inspect the entire form.
+  */
+  readonly path?: undefined;
+}
+/**
+* Get field dirty paths config interface.
+*/
+interface GetFieldDirtyPathsConfig<TSchema extends FormSchema, TFieldPath extends RequiredPath> {
+  /**
+  * The path to the field to inspect.
+  */
+  readonly path: ValidPath<v.InferInput<TSchema>, TFieldPath>;
+}
+/**
+* Returns a list of paths to the dirty fields of a specific field or the
+* entire form. Arrays are treated as atomic and contribute only their own
+* path if any item is dirty, while object branches are recursed into. Returns
+* an empty list if no field in the inspected subtree is dirty.
+*
+* @param form The form store to inspect.
+*
+* @returns The list of paths to the dirty fields.
+*/
+declare function getDirtyPaths<TSchema extends FormSchema>(form: BaseFormStore<TSchema>): DirtyPath<v.InferInput<TSchema>>[];
+/**
+* Returns a list of paths to the dirty fields of a specific field or the
+* entire form. Arrays are treated as atomic and contribute only their own
+* path if any item is dirty, while object branches are recursed into. Returns
+* an empty list if no field in the inspected subtree is dirty.
+*
+* @param form The form store to inspect.
+* @param config The get dirty paths configuration.
+*
+* @returns The list of paths to the dirty fields.
+*/
+declare function getDirtyPaths<TSchema extends FormSchema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? GetFieldDirtyPathsConfig<TSchema, TFieldPath> : GetFormDirtyPathsConfig): DirtyPath<v.InferInput<TSchema>>[];
+//#endregion
 //#region src/getErrors/getErrors.d.ts
 /**
 * Get form errors config interface.
@@ -406,7 +585,7 @@ interface GetFormErrorsConfig {
 /**
 * Get field errors config interface.
 */
-interface GetFieldErrorsConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+interface GetFieldErrorsConfig<TSchema extends FormSchema, TFieldPath extends RequiredPath> {
   /**
   * The path to the field to retrieve errors from.
   */
@@ -421,7 +600,7 @@ interface GetFieldErrorsConfig<TSchema extends Schema, TFieldPath extends Requir
 *
 * @returns A non-empty array of error messages, or null if no errors exist.
 */
-declare function getErrors<TSchema extends Schema>(form: BaseFormStore<TSchema>): [string, ...string[]] | null;
+declare function getErrors<TSchema extends FormSchema>(form: BaseFormStore<TSchema>): [string, ...string[]] | null;
 /**
 * Retrieves error messages from the form. When called without a config,
 * returns form-level errors. When called with a path, returns errors for
@@ -432,7 +611,7 @@ declare function getErrors<TSchema extends Schema>(form: BaseFormStore<TSchema>)
 *
 * @returns A non-empty array of error messages, or null if no errors exist.
 */
-declare function getErrors<TSchema extends Schema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? GetFieldErrorsConfig<TSchema, TFieldPath> : GetFormErrorsConfig): [string, ...string[]] | null;
+declare function getErrors<TSchema extends FormSchema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? GetFieldErrorsConfig<TSchema, TFieldPath> : GetFormErrorsConfig): [string, ...string[]] | null;
 //#endregion
 //#region src/getInput/getInput.d.ts
 /**
@@ -447,7 +626,7 @@ interface GetFormInputConfig {
 /**
 * Get field input config interface.
 */
-interface GetFieldInputConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+interface GetFieldInputConfig<TSchema extends FormSchema, TFieldPath extends RequiredPath> {
   /**
   * The path to the field to retrieve input from.
   */
@@ -461,7 +640,7 @@ interface GetFieldInputConfig<TSchema extends Schema, TFieldPath extends Require
 *
 * @returns The partial input values of the form or the specified field.
 */
-declare function getInput<TSchema extends Schema>(form: BaseFormStore<TSchema>): PartialValues<v.InferInput<TSchema>>;
+declare function getInput<TSchema extends FormSchema>(form: BaseFormStore<TSchema>): PartialValues<v.InferInput<TSchema>>;
 /**
 * Retrieves the current input value of a specific field or the entire form.
 * Returns a partial object as not all fields may have been set.
@@ -471,7 +650,7 @@ declare function getInput<TSchema extends Schema>(form: BaseFormStore<TSchema>):
 *
 * @returns The partial input values of the form or the specified field.
 */
-declare function getInput<TSchema extends Schema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? GetFieldInputConfig<TSchema, TFieldPath> : GetFormInputConfig): PartialValues<TFieldPath extends RequiredPath ? PathValue<v.InferInput<TSchema>, TFieldPath> : v.InferInput<TSchema>>;
+declare function getInput<TSchema extends FormSchema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? GetFieldInputConfig<TSchema, TFieldPath> : GetFormInputConfig): PartialValues<TFieldPath extends RequiredPath ? PathValue<v.InferInput<TSchema>, TFieldPath> : v.InferInput<TSchema>>;
 //#endregion
 //#region src/handleSubmit/handleSubmit.d.ts
 /**
@@ -484,7 +663,7 @@ declare function getInput<TSchema extends Schema, TFieldPath extends RequiredPat
 *
 * @returns A submit event handler function to attach to the form element.
 */
-declare function handleSubmit<TSchema extends Schema>(form: BaseFormStore<TSchema>, handler: SubmitHandler<TSchema>): () => Promise<void>;
+declare function handleSubmit<TSchema extends FormSchema>(form: BaseFormStore<TSchema>, handler: SubmitHandler<TSchema>): () => Promise<void>;
 /**
 * Creates a submit event handler for the form that prevents default browser
 * submission, validates the form input, and calls the provided handler if
@@ -495,13 +674,13 @@ declare function handleSubmit<TSchema extends Schema>(form: BaseFormStore<TSchem
 *
 * @returns A submit event handler function to attach to the form element.
 */
-declare function handleSubmit<TSchema extends Schema>(form: BaseFormStore<TSchema>, handler: SubmitEventHandler<TSchema>): (event: SubmitEvent) => Promise<void>;
+declare function handleSubmit<TSchema extends FormSchema>(form: BaseFormStore<TSchema>, handler: SubmitEventHandler<TSchema>): (event: SubmitEvent) => Promise<void>;
 //#endregion
 //#region src/insert/insert.d.ts
 /**
 * Insert array field config interface.
 */
-interface InsertConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+interface InsertConfig<TSchema extends FormSchema, TFieldArrayPath extends RequiredPath> {
   /**
   * The path to the field array to insert into.
   */
@@ -522,13 +701,13 @@ interface InsertConfig<TSchema extends Schema, TFieldArrayPath extends RequiredP
 * @param form The form store containing the field array.
 * @param config The insert configuration specifying the path, index, and initial value.
 */
-declare function insert<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: InsertConfig<TSchema, TFieldArrayPath>): void;
+declare function insert<TSchema extends FormSchema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: InsertConfig<TSchema, TFieldArrayPath>): void;
 //#endregion
 //#region src/move/move.d.ts
 /**
 * Move array field config interface.
 */
-interface MoveConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+interface MoveConfig<TSchema extends FormSchema, TFieldArrayPath extends RequiredPath> {
   /**
   * The path to the field array to move an item within.
   */
@@ -549,13 +728,38 @@ interface MoveConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPat
 * @param form The form store containing the field array.
 * @param config The move configuration specifying the path and source/destination indices.
 */
-declare function move<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: MoveConfig<TSchema, TFieldArrayPath>): void;
+declare function move<TSchema extends FormSchema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: MoveConfig<TSchema, TFieldArrayPath>): void;
+//#endregion
+//#region src/pickDirty/pickDirty.d.ts
+/**
+* Pick dirty config interface.
+*/
+interface PickDirtyConfig<TValue extends object> {
+  /**
+  * The value to filter down to its dirty parts. Must be structurally
+  * compatible with the form's schema.
+  */
+  readonly from: TValue;
+}
+/**
+* Picks only the dirty parts of the given value, using the form's dirty fields
+* as a structural mask. Arrays are treated as atomic and object keys without a
+* dirty descendant are omitted. Returns `undefined` if no field is dirty.
+* Useful for filtering a validated output down to its changed parts before
+* submitting.
+*
+* @param form The form store providing the dirty mask.
+* @param config The pick dirty configuration.
+*
+* @returns The dirty parts of the value, or `undefined`.
+*/
+declare function pickDirty<TSchema extends FormSchema, TValue extends object>(form: BaseFormStore<TSchema>, config: PickDirtyConfig<TValue>): DeepPartial<TValue> | undefined;
 //#endregion
 //#region src/remove/remove.d.ts
 /**
 * Remove array field config interface.
 */
-interface RemoveConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+interface RemoveConfig<TSchema extends FormSchema, TFieldArrayPath extends RequiredPath> {
   /**
   * The path to the field array to remove an item from.
   */
@@ -572,13 +776,13 @@ interface RemoveConfig<TSchema extends Schema, TFieldArrayPath extends RequiredP
 * @param form The form store containing the field array.
 * @param config The remove configuration specifying the path and index.
 */
-declare function remove<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: RemoveConfig<TSchema, TFieldArrayPath>): void;
+declare function remove<TSchema extends FormSchema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: RemoveConfig<TSchema, TFieldArrayPath>): void;
 //#endregion
 //#region src/replace/replace.d.ts
 /**
 * Replace array field config interface.
 */
-interface ReplaceConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+interface ReplaceConfig<TSchema extends FormSchema, TFieldArrayPath extends RequiredPath> {
   /**
   * The path to the field array to replace an item within.
   */
@@ -598,7 +802,7 @@ interface ReplaceConfig<TSchema extends Schema, TFieldArrayPath extends Required
 * @param form The form store containing the field array.
 * @param config The replace configuration specifying the path, index, and initial input.
 */
-declare function replace<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: ReplaceConfig<TSchema, TFieldArrayPath>): void;
+declare function replace<TSchema extends FormSchema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: ReplaceConfig<TSchema, TFieldArrayPath>): void;
 //#endregion
 //#region src/reset/reset.d.ts
 /**
@@ -621,7 +825,7 @@ interface ResetBaseConfig {
 /**
 * Reset form config interface.
 */
-interface ResetFormConfig<TSchema extends Schema> extends ResetBaseConfig {
+interface ResetFormConfig<TSchema extends FormSchema> extends ResetBaseConfig {
   /**
   * The path to a field. Leave undefined to reset the entire form.
   */
@@ -639,7 +843,7 @@ interface ResetFormConfig<TSchema extends Schema> extends ResetBaseConfig {
 /**
 * Reset field config interface.
 */
-interface ResetFieldConfig<TSchema extends Schema, TFieldPath extends RequiredPath> extends ResetBaseConfig {
+interface ResetFieldConfig<TSchema extends FormSchema, TFieldPath extends RequiredPath> extends ResetBaseConfig {
   /**
   * The path to the field to reset.
   */
@@ -666,7 +870,7 @@ declare function reset(form: BaseFormStore): void;
 * @param form The form store to reset.
 * @param config The reset configuration specifying what to reset and what to keep.
 */
-declare function reset<TSchema extends Schema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? ResetFieldConfig<TSchema, TFieldPath> : ResetFormConfig<TSchema>): void;
+declare function reset<TSchema extends FormSchema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? ResetFieldConfig<TSchema, TFieldPath> : ResetFormConfig<TSchema>): void;
 //#endregion
 //#region src/setErrors/setErrors.d.ts
 /**
@@ -685,7 +889,7 @@ interface SetFormErrorsConfig {
 /**
 * Set field errors config interface.
 */
-interface SetFieldErrorsConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+interface SetFieldErrorsConfig<TSchema extends FormSchema, TFieldPath extends RequiredPath> {
   /**
   * The path to the field to set errors on.
   */
@@ -703,13 +907,13 @@ interface SetFieldErrorsConfig<TSchema extends Schema, TFieldPath extends Requir
 * @param form The form store to set errors on.
 * @param config The set errors configuration specifying the path and error messages.
 */
-declare function setErrors<TSchema extends Schema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? SetFieldErrorsConfig<TSchema, TFieldPath> : SetFormErrorsConfig): void;
+declare function setErrors<TSchema extends FormSchema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? SetFieldErrorsConfig<TSchema, TFieldPath> : SetFormErrorsConfig): void;
 //#endregion
 //#region src/setInput/setInput.d.ts
 /**
 * Set form input config interface.
 */
-interface SetFormInputConfig<TSchema extends Schema> {
+interface SetFormInputConfig<TSchema extends FormSchema> {
   /**
   * The path to a field. Leave undefined to set the entire form input.
   */
@@ -722,7 +926,7 @@ interface SetFormInputConfig<TSchema extends Schema> {
 /**
 * Set field input config interface.
 */
-interface SetFieldInputConfig<TSchema extends Schema, TFieldPath extends RequiredPath> {
+interface SetFieldInputConfig<TSchema extends FormSchema, TFieldPath extends RequiredPath> {
   /**
   * The path to the field to set input on.
   */
@@ -740,7 +944,7 @@ interface SetFieldInputConfig<TSchema extends Schema, TFieldPath extends Require
 * @param form The form store to set input on.
 * @param config The set form input configuration specifying the new input values.
 */
-declare function setInput<TSchema extends Schema>(form: BaseFormStore<TSchema>, config: SetFormInputConfig<TSchema>): void;
+declare function setInput<TSchema extends FormSchema>(form: BaseFormStore<TSchema>, config: SetFormInputConfig<TSchema>): void;
 /**
 * Sets the input value of a specific field or the entire form. This updates
 * the field value(s) and triggers validation if required by the form's
@@ -749,7 +953,7 @@ declare function setInput<TSchema extends Schema>(form: BaseFormStore<TSchema>,
 * @param form The form store to set input on.
 * @param config The set input configuration specifying the path and new value.
 */
-declare function setInput<TSchema extends Schema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? SetFieldInputConfig<TSchema, TFieldPath> : SetFormInputConfig<TSchema>): void;
+declare function setInput<TSchema extends FormSchema, TFieldPath extends RequiredPath | undefined = undefined>(form: BaseFormStore<TSchema>, config: TFieldPath extends RequiredPath ? SetFieldInputConfig<TSchema, TFieldPath> : SetFormInputConfig<TSchema>): void;
 //#endregion
 //#region src/submit/submit.d.ts
 /**
@@ -764,7 +968,7 @@ declare function submit(form: BaseFormStore): void;
 /**
 * Swap array field config interface.
 */
-interface SwapConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPath> {
+interface SwapConfig<TSchema extends FormSchema, TFieldArrayPath extends RequiredPath> {
   /**
   * The path to the field array to swap items within.
   */
@@ -784,7 +988,7 @@ interface SwapConfig<TSchema extends Schema, TFieldArrayPath extends RequiredPat
 * @param form The form store containing the field array.
 * @param config The swap configuration specifying the path and indices to swap.
 */
-declare function swap<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: SwapConfig<TSchema, TFieldArrayPath>): void;
+declare function swap<TSchema extends FormSchema, TFieldArrayPath extends RequiredPath>(form: BaseFormStore<TSchema>, config: SwapConfig<TSchema, TFieldArrayPath>): void;
 //#endregion
 //#region src/validate/validate.d.ts
 /**
@@ -806,7 +1010,7 @@ interface ValidateFormConfig {
 *
 * @returns A promise resolving to the validation result.
 */
-declare function validate<TSchema extends Schema>(form: BaseFormStore<TSchema>, config?: ValidateFormConfig): Promise<v.SafeParseResult<TSchema>>;
+declare function validate<TSchema extends FormSchema>(form: BaseFormStore<TSchema>, config?: ValidateFormConfig): Promise<v.SafeParseResult<TSchema>>;
 //#endregion
 //#endregion
 //#region src/types/field.d.ts
@@ -825,28 +1029,28 @@ interface FieldElementProps {
   /**
   * The ref callback to register the field element.
   */
-  readonly ref: (element: FieldElement) => void;
+  readonly ref: (element: FieldElement | null) => void;
   /**
   * The focus event handler of the field element.
   */
-  readonly onFocus: JSX.FocusEventHandler<FieldElement>;
+  readonly onFocus: FocusEventHandler<FieldElement>;
   /**
   * The input event handler of the field element.
   */
-  readonly onInput: JSX.InputEventHandler<FieldElement>;
+  readonly onInput: InputEventHandler<FieldElement>;
   /**
   * The change event handler of the field element.
   */
-  readonly onChange: JSX.GenericEventHandler<FieldElement>;
+  readonly onChange: GenericEventHandler<FieldElement>;
   /**
   * The blur event handler of the field element.
   */
-  readonly onBlur: JSX.FocusEventHandler<FieldElement>;
+  readonly onBlur: FocusEventHandler<FieldElement>;
 }
 /**
 * Field store interface.
 */
-interface FieldStore<TSchema extends Schema = Schema, TFieldPath extends RequiredPath = RequiredPath> {
+interface FieldStore<TSchema extends FormSchema = FormSchema, TFieldPath extends RequiredPath = RequiredPath> {
   /**
   * The path to the field within the form.
   */
@@ -883,7 +1087,7 @@ interface FieldStore<TSchema extends Schema = Schema, TFieldPath extends Require
 /**
 * Field array store interface.
 */
-interface FieldArrayStore<TSchema extends Schema = Schema, TFieldArrayPath extends RequiredPath = RequiredPath> {
+interface FieldArrayStore<TSchema extends FormSchema = FormSchema, TFieldArrayPath extends RequiredPath = RequiredPath> {
   /**
   * The path to the array field within the form.
   */
@@ -914,7 +1118,7 @@ interface FieldArrayStore<TSchema extends Schema = Schema, TFieldArrayPath exten
 /**
 * Form store interface.
 */
-interface FormStore<TSchema extends Schema = Schema> extends BaseFormStore<TSchema> {
+interface FormStore<TSchema extends FormSchema = FormSchema> extends BaseFormStore<TSchema> {
   /**
   * Whether the form is currently submitting.
   */
@@ -952,7 +1156,7 @@ interface FormStore<TSchema extends Schema = Schema> extends BaseFormStore<TSche
 /**
 * Field component props interface.
 */
-interface FieldProps<TSchema extends Schema = Schema, TFieldPath extends RequiredPath = RequiredPath> {
+interface FieldProps<TSchema extends FormSchema = FormSchema, TFieldPath extends RequiredPath = RequiredPath> {
   /**
   * The form store to which the field belongs.
   */
@@ -975,7 +1179,7 @@ interface FieldProps<TSchema extends Schema = Schema, TFieldPath extends Require
 *
 * @returns The UI of the field to be rendered.
 */
-declare function Field<TSchema extends Schema, TFieldPath extends RequiredPath>({
+declare function Field<TSchema extends FormSchema, TFieldPath extends RequiredPath>({
   of,
   path,
   children
@@ -985,7 +1189,7 @@ declare function Field<TSchema extends Schema, TFieldPath extends RequiredPath>(
 /**
 * FieldArray component props interface.
 */
-interface FieldArrayProps<TSchema extends Schema = Schema, TFieldArrayPath extends RequiredPath = RequiredPath> {
+interface FieldArrayProps<TSchema extends FormSchema = FormSchema, TFieldArrayPath extends RequiredPath = RequiredPath> {
   /**
   * The form store to which the field array belongs.
   */
@@ -1009,7 +1213,7 @@ interface FieldArrayProps<TSchema extends Schema = Schema, TFieldArrayPath exten
 *
 * @returns The UI of the field array to be rendered.
 */
-declare function FieldArray<TSchema extends Schema, TFieldArrayPath extends RequiredPath>({
+declare function FieldArray<TSchema extends FormSchema, TFieldArrayPath extends RequiredPath>({
   of,
   path,
   children
@@ -1019,7 +1223,7 @@ declare function FieldArray<TSchema extends Schema, TFieldArrayPath extends Requ
 /**
 * Form component props type.
 */
-type FormProps<TSchema extends Schema = Schema> = Omit<JSX.FormHTMLAttributes<HTMLFormElement>, "onSubmit" | "novalidate" | "noValidate"> & {
+type FormProps<TSchema extends FormSchema = FormSchema> = Omit<FormHTMLAttributes<HTMLFormElement>, "onSubmit" | "novalidate" | "noValidate"> & {
   /**
   * The form store instance.
   */
@@ -1037,13 +1241,13 @@ type FormProps<TSchema extends Schema = Schema> = Omit<JSX.FormHTMLAttributes<HT
 *
 * @returns The a native form element.
 */
-declare function Form<TSchema extends Schema>(props: FormProps<TSchema>): JSX.Element;
+declare function Form<TSchema extends FormSchema>(props: FormProps<TSchema>): JSX.Element;
 //#endregion
 //#region src/hooks/useField/useField.d.ts
 /**
 * Use field config interface.
 */
-interface UseFieldConfig<TSchema extends Schema = Schema, TFieldPath extends RequiredPath = RequiredPath> {
+interface UseFieldConfig<TSchema extends FormSchema = FormSchema, TFieldPath extends RequiredPath = RequiredPath> {
   /**
   * The path to the field within the form schema.
   */
@@ -1057,13 +1261,13 @@ interface UseFieldConfig<TSchema extends Schema = Schema, TFieldPath extends Req
 *
 * @returns The field store with reactive properties and element props.
 */
-declare function useField<TSchema extends Schema, TFieldPath extends RequiredPath>(form: FormStore<TSchema>, config: UseFieldConfig<TSchema, TFieldPath>): FieldStore<TSchema, TFieldPath>;
+declare function useField<TSchema extends FormSchema, TFieldPath extends RequiredPath>(form: FormStore<TSchema>, config: UseFieldConfig<TSchema, TFieldPath>): FieldStore<TSchema, TFieldPath>;
 //#endregion
 //#region src/hooks/useFieldArray/useFieldArray.d.ts
 /**
 * Use field array config interface.
 */
-interface UseFieldArrayConfig<TSchema extends Schema = Schema, TFieldArrayPath extends RequiredPath = RequiredPath> {
+interface UseFieldArrayConfig<TSchema extends FormSchema = FormSchema, TFieldArrayPath extends RequiredPath = RequiredPath> {
   /**
   * The path to the array field within the form schema.
   */
@@ -1077,7 +1281,7 @@ interface UseFieldArrayConfig<TSchema extends Schema = Schema, TFieldArrayPath e
 *
 * @returns The field array store with reactive properties for array management.
 */
-declare function useFieldArray<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: FormStore<TSchema>, config: UseFieldArrayConfig<TSchema, TFieldArrayPath>): FieldArrayStore<TSchema, TFieldArrayPath>;
+declare function useFieldArray<TSchema extends FormSchema, TFieldArrayPath extends RequiredPath>(form: FormStore<TSchema>, config: UseFieldArrayConfig<TSchema, TFieldArrayPath>): FieldArrayStore<TSchema, TFieldArrayPath>;
 //#endregion
 //#region src/hooks/useForm/useForm.d.ts
 /**
@@ -1088,6 +1292,6 @@ declare function useFieldArray<TSchema extends Schema, TFieldArrayPath extends R
 *
 * @returns The form store with reactive properties.
 */
-declare function useForm<TSchema extends Schema>(config: FormConfig<TSchema>): FormStore<TSchema>;
+declare function useForm<TSchema extends FormSchema>(config: FormConfig<TSchema>): FormStore<TSchema>;
 //#endregion
-export { type DeepPartial, Field, FieldArray, FieldArrayProps, FieldArrayStore, type FieldElement, FieldElementProps, FieldProps, FieldStore, FocusFieldConfig, Form, type FormConfig, FormProps, FormStore, GetFieldErrorsConfig, GetFieldInputConfig, GetFormErrorsConfig, GetFormInputConfig, InsertConfig, MoveConfig, type PartialValues, type PathValue, RemoveConfig, ReplaceConfig, type RequiredPath, ResetFieldConfig, ResetFormConfig, type Schema, SetFieldErrorsConfig, SetFieldInputConfig, SetFormErrorsConfig, SetFormInputConfig, type SubmitEventHandler, type SubmitHandler, SwapConfig, UseFieldArrayConfig, UseFieldConfig, type ValidArrayPath, type ValidPath, ValidateFormConfig, type ValidationMode, focus, getAllErrors, getErrors, getInput, handleSubmit, insert, move, remove, replace, reset, setErrors, setInput, submit, swap, useField, useFieldArray, useForm, validate };
+export { type DeepPartial, Field, FieldArray, FieldArrayProps, FieldArrayStore, type FieldElement, FieldElementProps, FieldProps, FieldStore, FocusFieldConfig, Form, type FormConfig, FormProps, type FormSchema, FormStore, GetFieldDirtyInputConfig, GetFieldDirtyPathsConfig, GetFieldErrorsConfig, GetFieldInputConfig, GetFormDirtyInputConfig, GetFormDirtyPathsConfig, GetFormErrorsConfig, GetFormInputConfig, InsertConfig, MoveConfig, type PartialValues, type PathValue, PickDirtyConfig, RemoveConfig, ReplaceConfig, type RequiredPath, ResetFieldConfig, ResetFormConfig, type Schema, SetFieldErrorsConfig, SetFieldInputConfig, SetFormErrorsConfig, SetFormInputConfig, type SubmitEventHandler, type SubmitHandler, SwapConfig, UseFieldArrayConfig, UseFieldConfig, type ValidArrayPath, type ValidPath, ValidateFormConfig, type ValidationMode, focus, getAllErrors, getDirtyInput, getDirtyPaths, getErrors, getInput, handleSubmit, insert, move, pickDirty, remove, replace, reset, setErrors, setInput, submit, swap, useField, useFieldArray, useForm, validate };

package/dist/index.js

@@ -76,7 +76,7 @@ function initializeFieldStore(internalFieldStore, schema, initialInput, path, nu
 			if (internalFieldStore.kind === "object") {
 				internalFieldStore.children ??= {};
 				for (const key in schema.entries) {
-					internalFieldStore.children[key] = {};
+					internalFieldStore.children[key] ??= {};
 					path.push(key);
 					initializeFieldStore(internalFieldStore.children[key], schema.entries[key], initialInput?.[key], path);
 					path.pop();
@@ -87,6 +87,7 @@ function initializeFieldStore(internalFieldStore, schema, initialInput, path, nu
 				internalFieldStore.input = createSignal(objectInput);
 			}
 		} else {
+			if (internalFieldStore.kind && internalFieldStore.kind !== "value") throw new Error(`Store initialized as "${internalFieldStore.kind}" cannot be reinitialized as "value"`);
 			internalFieldStore.kind = "value";
 			if (internalFieldStore.kind === "value") {
 				internalFieldStore.initialInput = createSignal(initialInput);
@@ -232,6 +233,63 @@ function swapItemState(firstInternalFieldStore, secondInternalFieldStore) {
 	});
 }
 /**
+* Returns whether the specified boolean property is true for the field store
+* or any of its nested children. Recursively checks arrays and objects.
+*
+* @param internalFieldStore The field store to check.
+* @param type The boolean property type to check.
+*
+* @returns Whether the property is true.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getFieldBool(internalFieldStore, type) {
+	if (internalFieldStore[type].value) return true;
+	if (internalFieldStore.kind === "array") {
+		for (let index = 0; index < internalFieldStore.items.value.length; index++) if (/* @__PURE__ */ getFieldBool(internalFieldStore.children[index], type)) return true;
+		return false;
+	}
+	if (internalFieldStore.kind == "object") {
+		for (const key in internalFieldStore.children) if (/* @__PURE__ */ getFieldBool(internalFieldStore.children[key], type)) return true;
+		return false;
+	}
+	return false;
+}
+/**
+* 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.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getDirtyFieldInput(internalFieldStore, dirtyOnly = true) {
+	if (dirtyOnly && !/* @__PURE__ */ getFieldBool(internalFieldStore, "isDirty")) return;
+	if (internalFieldStore.kind === "array") {
+		if (internalFieldStore.input.value) {
+			const value = [];
+			for (let index = 0; index < internalFieldStore.items.value.length; index++) value[index] = /* @__PURE__ */ getDirtyFieldInput(internalFieldStore.children[index], false);
+			return value;
+		}
+		return internalFieldStore.input.value;
+	}
+	if (internalFieldStore.kind === "object") {
+		if (internalFieldStore.input.value) {
+			const value = {};
+			for (const key in internalFieldStore.children) {
+				const child = internalFieldStore.children[key];
+				if (!dirtyOnly || /* @__PURE__ */ getFieldBool(child, "isDirty")) value[key] = /* @__PURE__ */ getDirtyFieldInput(child, dirtyOnly);
+			}
+			return value;
+		}
+		return internalFieldStore.input.value;
+	}
+	return internalFieldStore.input.value;
+}
+/**
 * Returns the current input of the field store. For arrays and objects,
 * recursively collects input from all children. Returns `null` or `undefined`
 * for nullish array/object inputs, or the primitive value for value fields.
@@ -288,28 +346,6 @@ function getElementInput(element, internalFieldStore) {
 	return element.value;
 }
 /**
-* Returns whether the specified boolean property is true for the field store
-* or any of its nested children. Recursively checks arrays and objects.
-*
-* @param internalFieldStore The field store to check.
-* @param type The boolean property type to check.
-*
-* @returns Whether the property is true.
-*/
-/* @__NO_SIDE_EFFECTS__ */
-function getFieldBool(internalFieldStore, type) {
-	if (internalFieldStore[type].value) return true;
-	if (internalFieldStore.kind === "array") {
-		for (let index = 0; index < internalFieldStore.items.value.length; index++) if (/* @__PURE__ */ getFieldBool(internalFieldStore.children[index], type)) return true;
-		return false;
-	}
-	if (internalFieldStore.kind == "object") {
-		for (const key in internalFieldStore.children) if (/* @__PURE__ */ getFieldBool(internalFieldStore.children[key], type)) return true;
-		return false;
-	}
-	return false;
-}
-/**
 * Returns the field store at the specified path by traversing the form store's
 * children hierarchy.
 *
@@ -566,6 +602,17 @@ function getAllErrors(form) {
 	return allErrors;
 }
 /* @__NO_SIDE_EFFECTS__ */
+function getDirtyInput(form, config) {
+	return getDirtyFieldInput(config?.path ? getFieldStore(form[INTERNAL], config.path) : form[INTERNAL]);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function getDirtyPaths(form, config) {
+	config?.path ? getFieldStore(form[INTERNAL], config.path) : form[INTERNAL];
+	const paths = [];
+	config?.path && [...config.path];
+	return paths;
+}
+/* @__NO_SIDE_EFFECTS__ */
 function getErrors(form, config) {
 	return (config?.path ? getFieldStore(form[INTERNAL], config.path) : form[INTERNAL]).errors.value;
 }
@@ -659,6 +706,48 @@ function move(form, config) {
 	});
 }
 /**
+* Picks only the dirty parts of the given value, using the form's dirty fields
+* as a structural mask. Arrays are treated as atomic and object keys without a
+* dirty descendant are omitted. Returns `undefined` if no field is dirty.
+* Useful for filtering a validated output down to its changed parts before
+* submitting.
+*
+* @param form The form store providing the dirty mask.
+* @param config The pick dirty configuration.
+*
+* @returns The dirty parts of the value, or `undefined`.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function pickDirty(form, config) {
+	if (!getFieldBool(form[INTERNAL], "isDirty")) return;
+	const result = /* @__PURE__ */ pickFieldValue(form[INTERNAL], config.from);
+	return Object.keys(result).length ? result : void 0;
+}
+/**
+* Recursively picks the dirty parts of a value using the field store as a
+* structural mask, reading from the supplied value rather than the form's own
+* input. Objects with non-nullish input recurse into their dirty children that
+* are present in the value, while arrays, primitives, nullish-cleared fields
+* and shape-diverging values are returned as-is.
+*
+* @param internalFieldStore The field store used as the dirty mask.
+* @param value The value to pick the dirty parts from.
+*
+* @returns The dirty parts of the value.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function pickFieldValue(internalFieldStore, value) {
+	if (internalFieldStore.kind === "object" && internalFieldStore.input.value && value && typeof value === "object" && !Array.isArray(value)) {
+		const result = {};
+		for (const key in internalFieldStore.children) {
+			const child = internalFieldStore.children[key];
+			if (getFieldBool(child, "isDirty") && key in value) result[key] = /* @__PURE__ */ pickFieldValue(child, value[key]);
+		}
+		return result;
+	}
+	return value;
+}
+/**
 * Removes an item from a field array at the specified index. All items after
 * the removed item are shifted down by one index.
 *
@@ -704,7 +793,7 @@ function reset(form, config) {
 		untrack(() => {
 			const internalFormStore = form[INTERNAL];
 			const internalFieldStore = config?.path ? getFieldStore(internalFormStore, config.path) : internalFormStore;
-			if (config?.initialInput) setInitialFieldInput(internalFieldStore, config.initialInput);
+			if (config && "initialInput" in config) setInitialFieldInput(internalFieldStore, config.initialInput);
 			walkFieldStore(internalFieldStore, (internalFieldStore$1) => {
 				internalFieldStore$1.elements = internalFieldStore$1.initialElements;
 				if (!config?.keepErrors) internalFieldStore$1.errors.value = null;
@@ -951,4 +1040,4 @@ function Form({ of, onSubmit, ...other }) {
 }
 
 //#endregion
-export { Field, FieldArray, Form, focus, getAllErrors, getErrors, getInput, handleSubmit, insert, move, remove, replace, reset, setErrors, setInput, submit, swap, useField, useFieldArray, useForm, validate };
+export { Field, FieldArray, Form, focus, getAllErrors, getDirtyInput, getDirtyPaths, getErrors, getInput, handleSubmit, insert, move, pickDirty, remove, replace, reset, setErrors, setInput, submit, swap, useField, useFieldArray, useForm, validate };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formisch/preact",
-  "description": "The modular and type-safe form library for Preact",
-  "version": "0.9.5",
+  "description": "The lightweight, schema-first, and fully type-safe form library for Preact",
+  "version": "0.10.0",
   "license": "MIT",
   "author": "Fabian Hiller",
   "homepage": "https://formisch.dev",
@@ -34,6 +34,7 @@
   },
   "scripts": {
     "build": "tsdown",
+    "test": "vitest run --typecheck",
     "lint": "eslint \"src/**/*.ts*\" && tsc --noEmit",
     "lint.fix": "eslint \"src/**/*.ts*\" --fix",
     "format": "prettier --write ./src",
@@ -43,21 +44,26 @@
     "@formisch/core": "workspace:*",
     "@formisch/eslint-config": "workspace:*",
     "@formisch/methods": "workspace:*",
-    "@preact/preset-vite": "^2.9.3",
-    "@preact/signals": "^2.2.1",
+    "@preact/preset-vite": "^2.10.5",
+    "@preact/signals": "^2.9.0",
+    "@testing-library/jest-dom": "^6.6.0",
+    "@testing-library/preact": "^3.2.4",
+    "@vitest/coverage-v8": "^3.2.4",
     "eslint": "^9.31.0",
     "eslint-config-preact": "^2.0.0",
-    "preact": "^10.25.3",
+    "jsdom": "^26.1.0",
+    "preact": "^10.29.2",
     "tsdown": "^0.16.8",
     "typescript": "^5.8.3",
-    "valibot": "^1.2.0",
-    "vite": "^6.0.4"
+    "valibot": "^1.4.1",
+    "vite": "^6.0.4",
+    "vitest": "^3.2.4"
   },
   "peerDependencies": {
     "@preact/signals": "^2.0.0",
     "preact": "^10.0.0",
     "typescript": ">=5",
-    "valibot": "^1.0.0"
+    "valibot": "^1.4.1"
   },
   "peerDependenciesMeta": {
     "typescript": {