@formisch/svelte 0.7.5 → 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

@@ -1,13 +1,38 @@
 import * as v from "valibot";
 import { untrack } from "svelte";
 
-//#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
 /**
 * Signal interface.
 */
@@ -30,7 +55,7 @@ interface Untrack {
   <T>(fn: () => T): T;
 }
 //#endregion
-//#region src/types/field.d.ts
+//#region src/types/field/field.d.ts
 /**
 * Field element type.
 */
@@ -196,7 +221,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`.
 */
@@ -222,7 +247,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.
 */
@@ -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,13 +324,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.
 */
@@ -319,47 +344,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
 /**
@@ -398,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
@@ -515,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
 /**
@@ -555,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
 /**
@@ -586,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

@@ -107,7 +107,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();
@@ -118,6 +118,7 @@ function initializeFieldStore(internalFieldStore, schema, initialInput, path, nu
 				internalFieldStore.input = /* @__PURE__ */ 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 = /* @__PURE__ */ createSignal(initialInput);
@@ -272,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
 /**
@@ -334,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
 /**
@@ -609,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 };