@formisch/svelte 0.7.6 → 0.8.0

package/README.md

@@ -59,7 +59,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
 /**
@@ -230,7 +255,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 +276,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 +313,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 +324,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
 /**
@@ -406,6 +431,28 @@ type LazyArrayPath<TValue, TPathToCheck extends Path, TValidPath extends 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
 /**
@@ -444,6 +491,20 @@ declare function resetItemState(internalFieldStore: InternalFieldStore, initialI
 */
 declare function swapItemState(firstInternalFieldStore: InternalFieldStore, secondInternalFieldStore: InternalFieldStore): void;
 //#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 +622,7 @@ 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/validateFormInput/validateFormInput.d.ts
 /**
@@ -601,7 +662,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 +693,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, framework, getDirtyFieldInput, getElementInput, getFieldBool, getFieldInput, getFieldStore, initializeFieldStore, resetItemState, setFieldBool, setFieldInput, setInitialFieldInput, swapItemState, untrack, validateFormInput, validateIfRequired, walkFieldStore };

package/dist/core/index.svelte.js

@@ -273,6 +273,69 @@ function swapItemState(firstInternalFieldStore, secondInternalFieldStore) {
 	});
 }
 
+//#endregion
+//#region src/field/getFieldBool/getFieldBool.ts
+/**
+* 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;
+}
+
+//#endregion
+//#region src/field/getDirtyFieldInput/getDirtyFieldInput.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.
+*/
+/* @__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;
+}
+
 //#endregion
 //#region src/field/getFieldInput/getFieldInput.ts
 /**
@@ -335,31 +398,6 @@ function getElementInput(element, internalFieldStore) {
 	return element.value;
 }
 
-//#endregion
-//#region src/field/getFieldBool/getFieldBool.ts
-/**
-* 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;
-}
-
 //#endregion
 //#region src/field/getFieldStore/getFieldStore.ts
 /**
@@ -610,4 +648,4 @@ function validateIfRequired(internalFormStore, internalFieldStore, validationMod
 const INTERNAL = "~internal";
 
 //#endregion
-export { INTERNAL, batch, copyItemState, createFormStore, createId, createSignal, framework, getElementInput, getFieldBool, getFieldInput, getFieldStore, initializeFieldStore, resetItemState, setFieldBool, setFieldInput, setInitialFieldInput, swapItemState, untrack, validateFormInput, validateIfRequired, walkFieldStore };
+export { INTERNAL, batch, copyItemState, createFormStore, createId, createSignal, framework, getDirtyFieldInput, getElementInput, getFieldBool, getFieldInput, getFieldStore, initializeFieldStore, resetItemState, setFieldBool, setFieldInput, setInitialFieldInput, swapItemState, untrack, validateFormInput, validateIfRequired, walkFieldStore };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type { DeepPartial, FieldElement, FormConfig, PartialValues, PathValue, RequiredPath, Schema, SubmitEventHandler, SubmitHandler, ValidArrayPath, ValidationMode, ValidPath, } from './core/index.svelte';
+export type { DeepPartial, FieldElement, FormConfig, PartialValues, PathValue, RequiredPath, FormSchema, Schema, SubmitEventHandler, SubmitHandler, ValidArrayPath, ValidationMode, ValidPath, } from './core/index.svelte';
 export * from './methods/index.svelte';
 export * from './components/index';
 export * from './runes/index';

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

@@ -1,4 +1,4 @@
-import { BaseFormStore, DeepPartial, PartialValues, PathValue, RequiredPath, Schema, SubmitEventHandler, SubmitHandler, ValidArrayPath, ValidPath } from "../core/index.svelte";
+import { BaseFormStore, DeepPartial, DirtyPath, FormSchema, PartialValues, PathValue, RequiredPath, SubmitEventHandler, SubmitHandler, ValidArrayPath, ValidPath } from "../core/index.svelte";
 import * as v from "valibot";
 
 //#region src/focus/focus.d.ts
@@ -6,7 +6,7 @@ import * as v from "valibot";
 /**
 * 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.
   */
@@ -20,7 +20,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
 /**
@@ -34,6 +34,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.
@@ -47,7 +134,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.
   */
@@ -62,7 +149,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
@@ -73,7 +160,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
 /**
@@ -88,7 +175,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.
   */
@@ -102,7 +189,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.
@@ -112,7 +199,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
 /**
@@ -125,7 +212,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
@@ -136,13 +223,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.
   */
@@ -163,13 +250,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.
   */
@@ -190,13 +277,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.
   */
@@ -213,13 +325,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.
   */
@@ -239,7 +351,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
 /**
@@ -262,7 +374,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.
   */
@@ -280,7 +392,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.
   */
@@ -307,7 +419,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
 /**
@@ -326,7 +438,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.
   */
@@ -344,13 +456,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.
   */
@@ -363,7 +475,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.
   */
@@ -381,7 +493,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
@@ -390,7 +502,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
 /**
@@ -405,7 +517,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.
   */
@@ -425,7 +537,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
 /**
@@ -447,6 +559,6 @@ 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
-export { FocusFieldConfig, GetFieldErrorsConfig, GetFieldInputConfig, GetFormErrorsConfig, GetFormInputConfig, InsertConfig, MoveConfig, RemoveConfig, ReplaceConfig, ResetFieldConfig, ResetFormConfig, SetFieldErrorsConfig, SetFieldInputConfig, SetFormErrorsConfig, SetFormInputConfig, SwapConfig, ValidateFormConfig, focus, getAllErrors, getErrors, getInput, handleSubmit, insert, move, remove, replace, reset, setErrors, setInput, submit, swap, validate };
+export { FocusFieldConfig, GetFieldDirtyInputConfig, GetFieldDirtyPathsConfig, GetFieldErrorsConfig, GetFieldInputConfig, GetFormDirtyInputConfig, GetFormDirtyPathsConfig, GetFormErrorsConfig, GetFormInputConfig, InsertConfig, MoveConfig, PickDirtyConfig, RemoveConfig, ReplaceConfig, ResetFieldConfig, ResetFormConfig, SetFieldErrorsConfig, SetFieldInputConfig, SetFormErrorsConfig, SetFormInputConfig, SwapConfig, ValidateFormConfig, focus, getAllErrors, getDirtyInput, getDirtyPaths, getErrors, getInput, handleSubmit, insert, move, pickDirty, remove, replace, reset, setErrors, setInput, submit, swap, validate };

package/dist/methods/index.svelte.js

@@ -1,4 +1,4 @@
-import { INTERNAL, batch, copyItemState, createId, getFieldInput, getFieldStore, initializeFieldStore, resetItemState, setFieldInput, setInitialFieldInput, swapItemState, untrack, validateFormInput, validateIfRequired, walkFieldStore } from "../core/index.svelte";
+import { INTERNAL, batch, copyItemState, createId, getDirtyFieldInput, getFieldBool, getFieldInput, getFieldStore, initializeFieldStore, resetItemState, setFieldInput, setInitialFieldInput, swapItemState, untrack, validateFormInput, validateIfRequired, walkFieldStore } from "../core/index.svelte";
 
 //#region src/focus/focus.ts
 /**
@@ -36,6 +36,23 @@ function getAllErrors(form) {
 	return allErrors;
 }
 
+//#endregion
+//#region src/getDirtyInput/getDirtyInput.ts
+/* @__NO_SIDE_EFFECTS__ */
+function getDirtyInput(form, config) {
+	return getDirtyFieldInput(config?.path ? getFieldStore(form[INTERNAL], config.path) : form[INTERNAL]);
+}
+
+//#endregion
+//#region src/getDirtyPaths/getDirtyPaths.ts
+/* @__NO_SIDE_EFFECTS__ */
+function getDirtyPaths(form, config) {
+	config?.path ? getFieldStore(form[INTERNAL], config.path) : form[INTERNAL];
+	const paths = [];
+	config?.path && [...config.path];
+	return paths;
+}
+
 //#endregion
 //#region src/getErrors/getErrors.ts
 /* @__NO_SIDE_EFFECTS__ */
@@ -144,6 +161,51 @@ function move(form, config) {
 	});
 }
 
+//#endregion
+//#region src/pickDirty/pickDirty.ts
+/**
+* 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;
+}
+
 //#endregion
 //#region src/remove/remove.ts
 /**
@@ -295,4 +357,4 @@ function validate(form, config) {
 }
 
 //#endregion
-export { focus, getAllErrors, getErrors, getInput, handleSubmit, insert, move, remove, replace, reset, setErrors, setInput, submit, swap, validate };
+export { focus, getAllErrors, getDirtyInput, getDirtyPaths, getErrors, getInput, handleSubmit, insert, move, pickDirty, remove, replace, reset, setErrors, setInput, submit, swap, validate };

package/dist/runes/createForm/createForm.svelte.d.ts

@@ -1,4 +1,4 @@
-import { type FormConfig, type Schema } from '../../core/index.svelte';
+import { type FormConfig, type FormSchema } from '../../core/index.svelte';
 import type { FormStore } from '../../types/index';
 /**
  * Creates a reactive form store from a form configuration. The form store
@@ -8,4 +8,4 @@ import type { FormStore } from '../../types/index';
  *
  * @returns The form store with reactive properties.
  */
-export declare function createForm<TSchema extends Schema>(config: FormConfig<TSchema>): FormStore<TSchema>;
+export declare function createForm<TSchema extends FormSchema>(config: FormConfig<TSchema>): FormStore<TSchema>;

package/dist/runes/useField/useField.svelte.d.ts

@@ -1,10 +1,10 @@
-import { type RequiredPath, type Schema, type ValidPath } from '../../core/index.svelte';
+import { type FormSchema, type RequiredPath, type ValidPath } from '../../core/index.svelte';
 import type * as v from 'valibot';
 import type { FieldStore, FormStore, MaybeGetter } from '../../types/index';
 /**
  * Use field config interface.
  */
-export interface UseFieldConfig<TSchema extends Schema = Schema, TFieldPath extends RequiredPath = RequiredPath> {
+export interface UseFieldConfig<TSchema extends FormSchema = FormSchema, TFieldPath extends RequiredPath = RequiredPath> {
     /**
      * The path to the field within the form schema.
      */
@@ -18,4 +18,4 @@ export interface UseFieldConfig<TSchema extends Schema = Schema, TFieldPath exte
  *
  * @returns The field store with reactive properties and element props.
  */
-export declare function useField<TSchema extends Schema, TFieldPath extends RequiredPath>(form: MaybeGetter<FormStore<TSchema>>, config: MaybeGetter<UseFieldConfig<TSchema, TFieldPath>>): FieldStore<TSchema, TFieldPath>;
+export declare function useField<TSchema extends FormSchema, TFieldPath extends RequiredPath>(form: MaybeGetter<FormStore<TSchema>>, config: MaybeGetter<UseFieldConfig<TSchema, TFieldPath>>): FieldStore<TSchema, TFieldPath>;

package/dist/runes/useFieldArray/useFieldArray.svelte.d.ts

@@ -1,10 +1,10 @@
-import { type RequiredPath, type Schema, type ValidArrayPath } from '../../core/index.svelte';
+import { type FormSchema, type RequiredPath, type ValidArrayPath } from '../../core/index.svelte';
 import type * as v from 'valibot';
 import type { FieldArrayStore, FormStore, MaybeGetter } from '../../types/index';
 /**
  * Use field array config interface.
  */
-export interface UseFieldArrayConfig<TSchema extends Schema = Schema, TFieldArrayPath extends RequiredPath = RequiredPath> {
+export interface UseFieldArrayConfig<TSchema extends FormSchema = FormSchema, TFieldArrayPath extends RequiredPath = RequiredPath> {
     /**
      * The path to the field array within the form schema.
      */
@@ -18,4 +18,4 @@ export interface UseFieldArrayConfig<TSchema extends Schema = Schema, TFieldArra
  *
  * @returns The field array store with reactive properties for array management.
  */
-export declare function useFieldArray<TSchema extends Schema, TFieldArrayPath extends RequiredPath>(form: MaybeGetter<FormStore<TSchema>>, config: MaybeGetter<UseFieldArrayConfig<TSchema, TFieldArrayPath>>): FieldArrayStore<TSchema, TFieldArrayPath>;
+export declare function useFieldArray<TSchema extends FormSchema, TFieldArrayPath extends RequiredPath>(form: MaybeGetter<FormStore<TSchema>>, config: MaybeGetter<UseFieldArrayConfig<TSchema, TFieldArrayPath>>): FieldArrayStore<TSchema, TFieldArrayPath>;

package/dist/types/field.d.ts

@@ -1,4 +1,4 @@
-import type { FieldElement, PartialValues, PathValue, RequiredPath, Schema, ValidArrayPath, ValidPath } from '../core/index.svelte';
+import type { FieldElement, FormSchema, PartialValues, PathValue, RequiredPath, ValidArrayPath, ValidPath } from '../core/index.svelte';
 import type { FocusEventHandler, FormEventHandler } from 'svelte/elements';
 import type * as v from 'valibot';
 /**
@@ -37,7 +37,7 @@ export interface FieldElementProps {
 /**
  * Field store interface.
  */
-export interface FieldStore<TSchema extends Schema = Schema, TFieldPath extends RequiredPath = RequiredPath> {
+export interface FieldStore<TSchema extends FormSchema = FormSchema, TFieldPath extends RequiredPath = RequiredPath> {
     /**
      * The path to the field within the form.
      */
@@ -74,7 +74,7 @@ export interface FieldStore<TSchema extends Schema = Schema, TFieldPath extends
 /**
  * Field array store interface.
  */
-export interface FieldArrayStore<TSchema extends Schema = Schema, TFieldArrayPath extends RequiredPath = RequiredPath> {
+export interface FieldArrayStore<TSchema extends FormSchema = FormSchema, TFieldArrayPath extends RequiredPath = RequiredPath> {
     /**
      * The path to the array field within the form.
      */

package/dist/types/form.d.ts

@@ -1,8 +1,8 @@
-import type { BaseFormStore, Schema } from '../core/index.svelte';
+import type { BaseFormStore, FormSchema } from '../core/index.svelte';
 /**
  * Form store interface.
  */
-export interface FormStore<TSchema extends Schema = Schema> extends BaseFormStore<TSchema> {
+export interface FormStore<TSchema extends FormSchema = FormSchema> extends BaseFormStore<TSchema> {
     /**
      * Whether the form is currently submitting.
      */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formisch/svelte",
   "description": "The lightweight, schema-first, and fully type-safe form library for Svelte",
-  "version": "0.7.6",
+  "version": "0.8.0",
   "license": "MIT",
   "author": "Fabian Hiller",
   "homepage": "https://formisch.dev",
@@ -67,14 +67,14 @@
     "svelte": "^5.38.8",
     "svelte-check": "^4.3.1",
     "typescript": "^5.9.2",
-    "valibot": "^1.2.0",
+    "valibot": "^1.4.1",
     "vite": "^7.1.5",
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
     "svelte": "^5.29.0",
     "typescript": ">=5",
-    "valibot": "^1.0.0"
+    "valibot": "^1.4.1"
   },
   "peerDependenciesMeta": {
     "typescript": {