@lucas-barake/effect-form 0.19.0 → 0.21.0

package/src/FormAtoms.ts

@@ -1,88 +1,107 @@
-import * as Atom from "@effect-atom/atom/Atom";
-import * as Effect from "effect/Effect";
-import { pipe } from "effect/Function";
-import * as Option from "effect/Option";
-import type * as ParseResult from "effect/ParseResult";
-import * as Schema from "effect/Schema";
-import * as Field from "./Field.js";
-import * as FormBuilder from "./FormBuilder.js";
-import { recalculateDirtyFieldsForArray, recalculateDirtySubtree } from "./internal/dirty.js";
-import { createWeakRegistry, type WeakRegistry } from "./internal/weak-registry.js";
-import { getNestedValue, isPathOrParentDirty, setNestedValue } from "./Path.js";
-import * as Validation from "./Validation.js";
+import * as Atom from "@effect-atom/atom/Atom"
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
+import * as Option from "effect/Option"
+import * as ParseResult from "effect/ParseResult"
+import * as Schema from "effect/Schema"
+import * as Field from "./Field.ts"
+import * as FormBuilder from "./FormBuilder.ts"
+import { recalculateDirtyFieldsForArray, recalculateDirtySubtree } from "./internal/dirty.ts"
+import { createWeakRegistry, type WeakRegistry } from "./internal/weak-registry.ts"
+import * as Mode from "./Mode.ts"
+import { getNestedValue, isPathOrParentDirty, setNestedValue } from "./Path.ts"
+import * as Validation from "./Validation.ts"
 
 export interface FieldAtoms {
-  readonly valueAtom: Atom.Writable<unknown, unknown>;
-  readonly initialValueAtom: Atom.Atom<unknown>;
-  readonly touchedAtom: Atom.Writable<boolean, boolean>;
-  readonly errorAtom: Atom.Atom<Option.Option<Validation.ErrorEntry>>;
-  readonly isDirtyAtom: Atom.Atom<boolean>;
+  readonly valueAtom: Atom.Writable<unknown, unknown>
+  readonly initialValueAtom: Atom.Atom<unknown>
+  readonly touchedAtom: Atom.Writable<boolean, boolean>
+  readonly errorAtom: Atom.Atom<Option.Option<Validation.ErrorEntry>>
+  readonly isDirtyAtom: Atom.Atom<boolean>
+  readonly validationAtom: Atom.AtomResultFn<unknown, void, ParseResult.ParseError>
+  readonly displayErrorAtom: Atom.Atom<Option.Option<string>>
+  readonly shouldValidateAtom: Atom.Atom<boolean>
+  readonly triggerValidationAtom: Atom.Atom<void>
 }
 
-export interface FormAtomsConfig<TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = void> {
-  readonly runtime: Atom.AtomRuntime<R, any>;
-  readonly formBuilder: FormBuilder.FormBuilder<TFields, R>;
-  readonly reactivityKeys?: ReadonlyArray<unknown> | Readonly<Record<string, ReadonlyArray<unknown>>> | undefined;
+export interface PublicFieldAtoms<E,> {
+  readonly value: Atom.Atom<Option.Option<E>>
+  readonly error: Atom.Atom<Option.Option<string>>
+  readonly isDirty: Atom.Atom<boolean>
+  readonly isTouched: Atom.Atom<boolean>
+  readonly isValidating: Atom.Atom<boolean>
+  readonly setValue: Atom.Writable<void, E | ((prev: E) => E)>
+  readonly setTouched: Atom.Writable<void, boolean>
+}
+
+export type SetValuesArg<TFields extends Field.FieldsRecord,> =
+  | Field.EncodedFromFields<TFields>
+  | ((prev: Field.EncodedFromFields<TFields>) => Field.EncodedFromFields<TFields>)
+
+export interface FormAtomsConfig<TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = void,> {
+  readonly runtime: Atom.AtomRuntime<R, any>
+  readonly formBuilder: FormBuilder.FormBuilder<TFields, R>
+  readonly mode?: Mode.FormMode
+  readonly reactivityKeys?: ReadonlyArray<unknown> | Readonly<Record<string, ReadonlyArray<unknown>>> | undefined
   readonly onSubmit: (
     args: SubmitArgs,
     ctx: {
-      readonly decoded: Field.DecodedFromFields<TFields>;
-      readonly encoded: Field.EncodedFromFields<TFields>;
-      readonly get: Atom.FnContext;
-    },
-  ) => A | Effect.Effect<A, E, R>;
+      readonly decoded: Field.DecodedFromFields<TFields>
+      readonly encoded: Field.EncodedFromFields<TFields>
+      readonly get: Atom.FnContext
+    }
+  ) => A | Effect.Effect<A, E, R>
 }
 
-export type FieldRefs<TFields extends Field.FieldsRecord> = {
+export type FieldRefs<TFields extends Field.FieldsRecord,> = {
   readonly [K in keyof TFields]: TFields[K] extends Field.FieldDef<any, infer S>
     ? FormBuilder.FieldRef<Schema.Schema.Encoded<S>>
     : TFields[K] extends Field.ArrayFieldDef<any, infer S>
       ? FormBuilder.FieldRef<ReadonlyArray<Schema.Schema.Encoded<S>>>
-    : never;
-};
+    : never
+}
 
-export interface FormAtoms<TFields extends Field.FieldsRecord, R, A = void, E = never, SubmitArgs = void> {
+export interface FormAtoms<TFields extends Field.FieldsRecord, R, A = void, E = never, SubmitArgs = void,> {
   readonly stateAtom: Atom.Writable<
     Option.Option<FormBuilder.FormState<TFields>>,
     Option.Option<FormBuilder.FormState<TFields>>
-  >;
-  readonly errorsAtom: Atom.Writable<Map<string, Validation.ErrorEntry>, Map<string, Validation.ErrorEntry>>;
-  readonly rootErrorAtom: Atom.Atom<Option.Option<string>>;
-  readonly valuesAtom: Atom.Atom<Option.Option<Field.EncodedFromFields<TFields>>>;
-  readonly dirtyFieldsAtom: Atom.Atom<ReadonlySet<string>>;
-  readonly isDirtyAtom: Atom.Atom<boolean>;
-  readonly submitCountAtom: Atom.Atom<number>;
-  readonly lastSubmittedValuesAtom: Atom.Atom<Option.Option<FormBuilder.SubmittedValues<TFields>>>;
-  readonly changedSinceSubmitFieldsAtom: Atom.Atom<ReadonlySet<string>>;
-  readonly hasChangedSinceSubmitAtom: Atom.Atom<boolean>;
+  >
+  readonly errorsAtom: Atom.Writable<Map<string, Validation.ErrorEntry>, Map<string, Validation.ErrorEntry>>
+  readonly rootErrorAtom: Atom.Atom<Option.Option<string>>
+  readonly valuesAtom: Atom.Atom<Option.Option<Field.EncodedFromFields<TFields>>>
+  readonly dirtyFieldsAtom: Atom.Atom<ReadonlySet<string>>
+  readonly isDirtyAtom: Atom.Atom<boolean>
+  readonly submitCountAtom: Atom.Atom<number>
+  readonly lastSubmittedValuesAtom: Atom.Atom<Option.Option<FormBuilder.SubmittedValues<TFields>>>
+  readonly changedSinceSubmitFieldsAtom: Atom.Atom<ReadonlySet<string>>
+  readonly hasChangedSinceSubmitAtom: Atom.Atom<boolean>
 
-  readonly submitAtom: Atom.AtomResultFn<SubmitArgs, A, E | ParseResult.ParseError>;
+  readonly submitAtom: Atom.AtomResultFn<SubmitArgs, A, E | ParseResult.ParseError>
 
-  readonly combinedSchema: Schema.Schema<Field.DecodedFromFields<TFields>, Field.EncodedFromFields<TFields>, R>;
+  readonly combinedSchema: Schema.Schema<Field.DecodedFromFields<TFields>, Field.EncodedFromFields<TFields>, R>
 
-  readonly fieldRefs: FieldRefs<TFields>;
+  readonly fieldRefs: FieldRefs<TFields>
 
-  readonly validationAtomsRegistry: WeakRegistry<Atom.AtomResultFn<unknown, void, ParseResult.ParseError>>;
-  readonly fieldAtomsRegistry: WeakRegistry<FieldAtoms>;
+  readonly validationAtomsRegistry: WeakRegistry<Atom.AtomResultFn<unknown, void, ParseResult.ParseError>>
+  readonly fieldAtomsRegistry: WeakRegistry<FieldAtoms>
 
   readonly getOrCreateValidationAtom: (
     fieldPath: string,
-    schema: Schema.Schema.Any,
-  ) => Atom.AtomResultFn<unknown, void, ParseResult.ParseError>;
+    schema: Schema.Schema.Any
+  ) => Atom.AtomResultFn<unknown, void, ParseResult.ParseError>
 
-  readonly getOrCreateFieldAtoms: (fieldPath: string) => FieldAtoms;
+  readonly getOrCreateFieldAtoms: (fieldPath: string, schema: Schema.Schema.Any) => FieldAtoms
 
-  readonly resetValidationAtoms: (ctx: { set: <R, W>(atom: Atom.Writable<R, W>, value: W) => void; }) => void;
+  readonly resetValidationAtoms: (ctx: { set: <R, W,>(atom: Atom.Writable<R, W>, value: W) => void }) => void
 
-  readonly operations: FormOperations<TFields>;
+  readonly operations: FormOperations<TFields>
 
-  readonly resetAtom: Atom.Writable<void, void>;
-  readonly revertToLastSubmitAtom: Atom.Writable<void, void>;
-  readonly setValuesAtom: Atom.Writable<void, Field.EncodedFromFields<TFields>>;
-  readonly setValue: <S>(field: FormBuilder.FieldRef<S>) => Atom.Writable<void, S | ((prev: S) => S)>;
+  readonly resetAtom: Atom.Writable<void, void>
+  readonly revertToLastSubmitAtom: Atom.Writable<void, void>
+  readonly setValuesAtom: Atom.Writable<void, SetValuesArg<TFields>>
 
-  readonly getFieldValue: <S>(field: FormBuilder.FieldRef<S>) => Atom.Atom<Option.Option<S>>;
-  readonly getFieldIsDirty: (field: FormBuilder.FieldRef<any>) => Atom.Atom<boolean>;
+  readonly getFieldAtoms: <S,>(field: FormBuilder.FieldRef<S>) => PublicFieldAtoms<S>
 
   /**
    * Root anchor atom for the form's dependency graph.
@@ -102,110 +121,114 @@ export interface FormAtoms<TFields extends Field.FieldsRecord, R, A = void, E =
    * }
    * ```
    */
-  readonly mountAtom: Atom.Atom<void>;
+  readonly autoSubmitAtom: Atom.Atom<void>
+  readonly onBlurSubmitAtom: Atom.Writable<void, void>
 
-  readonly keepAliveActiveAtom: Atom.Writable<boolean, boolean>;
+  readonly mountAtom: Atom.Atom<void>
+
+  readonly keepAliveActiveAtom: Atom.Writable<boolean, boolean>
 }
 
-export interface FormOperations<TFields extends Field.FieldsRecord> {
-  readonly createInitialState: (defaultValues: Field.EncodedFromFields<TFields>) => FormBuilder.FormState<TFields>;
+export interface FormOperations<TFields extends Field.FieldsRecord,> {
+  readonly createInitialState: (defaultValues: Field.EncodedFromFields<TFields>) => FormBuilder.FormState<TFields>
 
-  readonly createResetState: (state: FormBuilder.FormState<TFields>) => FormBuilder.FormState<TFields>;
+  readonly createResetState: (state: FormBuilder.FormState<TFields>) => FormBuilder.FormState<TFields>
 
-  readonly createSubmitState: (state: FormBuilder.FormState<TFields>) => FormBuilder.FormState<TFields>;
+  readonly createSubmitState: (state: FormBuilder.FormState<TFields>) => FormBuilder.FormState<TFields>
 
   readonly setFieldValue: (
     state: FormBuilder.FormState<TFields>,
     fieldPath: string,
-    value: unknown,
-  ) => FormBuilder.FormState<TFields>;
+    value: unknown
+  ) => FormBuilder.FormState<TFields>
 
   readonly setFormValues: (
     state: FormBuilder.FormState<TFields>,
-    values: Field.EncodedFromFields<TFields>,
-  ) => FormBuilder.FormState<TFields>;
+    values: Field.EncodedFromFields<TFields>
+  ) => FormBuilder.FormState<TFields>
 
   readonly setFieldTouched: (
     state: FormBuilder.FormState<TFields>,
     fieldPath: string,
-    touched: boolean,
-  ) => FormBuilder.FormState<TFields>;
+    touched: boolean
+  ) => FormBuilder.FormState<TFields>
 
   readonly appendArrayItem: (
     state: FormBuilder.FormState<TFields>,
     arrayPath: string,
     itemSchema: Schema.Schema.Any,
-    value?: unknown,
-  ) => FormBuilder.FormState<TFields>;
+    value?: unknown
+  ) => FormBuilder.FormState<TFields>
 
   readonly removeArrayItem: (
     state: FormBuilder.FormState<TFields>,
     arrayPath: string,
-    index: number,
-  ) => FormBuilder.FormState<TFields>;
+    index: number
+  ) => FormBuilder.FormState<TFields>
 
   readonly swapArrayItems: (
     state: FormBuilder.FormState<TFields>,
     arrayPath: string,
     indexA: number,
-    indexB: number,
-  ) => FormBuilder.FormState<TFields>;
+    indexB: number
+  ) => FormBuilder.FormState<TFields>
 
   readonly moveArrayItem: (
     state: FormBuilder.FormState<TFields>,
     arrayPath: string,
     fromIndex: number,
-    toIndex: number,
-  ) => FormBuilder.FormState<TFields>;
+    toIndex: number
+  ) => FormBuilder.FormState<TFields>
 
-  readonly revertToLastSubmit: (state: FormBuilder.FormState<TFields>) => FormBuilder.FormState<TFields>;
+  readonly revertToLastSubmit: (state: FormBuilder.FormState<TFields>) => FormBuilder.FormState<TFields>
 }
 
-export const make = <TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = void>(
-  config: FormAtomsConfig<TFields, R, A, E, SubmitArgs>,
+export const make = <TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = void,>(
+  config: FormAtomsConfig<TFields, R, A, E, SubmitArgs>
 ): FormAtoms<TFields, R, A, E, SubmitArgs> => {
-  const { formBuilder, runtime } = config;
-  const { fields } = formBuilder;
+  const { formBuilder, runtime } = config
+  const { fields } = formBuilder
+  const parsedMode = Mode.parse(config.mode)
 
-  const combinedSchema = FormBuilder.buildSchema(formBuilder);
+  const combinedSchema = FormBuilder.buildSchema(formBuilder)
 
-  const stateAtom = Atom.make(Option.none<FormBuilder.FormState<TFields>>()).pipe(Atom.setIdleTTL(0));
-  const errorsAtom = Atom.make<Map<string, Validation.ErrorEntry>>(new Map()).pipe(Atom.setIdleTTL(0));
+  const stateAtom = Atom.make(Option.none<FormBuilder.FormState<TFields>>()).pipe(Atom.setIdleTTL(0))
+  const errorsAtom = Atom.make<Map<string, Validation.ErrorEntry>>(new Map()).pipe(Atom.setIdleTTL(0))
 
   const rootErrorAtom = Atom.readable((get) => {
-    const errors = get(errorsAtom);
-    const entry = errors.get("");
-    return entry ? Option.some(entry.message) : Option.none<string>();
-  }).pipe(Atom.setIdleTTL(0));
+    const errors = get(errorsAtom)
+    const entry = errors.get("")
+    return entry ? Option.some(entry.message) : Option.none<string>()
+  }).pipe(Atom.setIdleTTL(0))
 
   const valuesAtom = Atom.readable((get) => Option.map(get(stateAtom), (state) => state.values)).pipe(
-    Atom.setIdleTTL(0),
-  );
+    Atom.setIdleTTL(0)
+  )
 
   const dirtyFieldsAtom = Atom.readable((get) =>
     Option.match(get(stateAtom), {
       onNone: () => new Set<string>(),
-      onSome: (state) => state.dirtyFields,
+      onSome: (state) => state.dirtyFields
     })
-  ).pipe(Atom.setIdleTTL(0));
+  ).pipe(Atom.setIdleTTL(0))
 
   const isDirtyAtom = Atom.readable((get) =>
     Option.match(get(stateAtom), {
       onNone: () => false,
-      onSome: (state) => state.dirtyFields.size > 0,
+      onSome: (state) => state.dirtyFields.size > 0
     })
-  ).pipe(Atom.setIdleTTL(0));
+  ).pipe(Atom.setIdleTTL(0))
 
   const submitCountAtom = Atom.readable((get) =>
     Option.match(get(stateAtom), {
       onNone: () => 0,
-      onSome: (state) => state.submitCount,
+      onSome: (state) => state.submitCount
     })
-  ).pipe(Atom.setIdleTTL(0));
+  ).pipe(Atom.setIdleTTL(0))
 
   const lastSubmittedValuesAtom = Atom.readable((get) =>
     Option.flatMap(get(stateAtom), (state) => state.lastSubmittedValues)
-  ).pipe(Atom.setIdleTTL(0));
+  ).pipe(Atom.setIdleTTL(0))
 
   const changedSinceSubmitFieldsAtom = Atom.readable((get) =>
     Option.match(get(stateAtom), {
@@ -213,110 +236,229 @@ export const make = <TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = v
       onSome: (state) =>
         Option.match(state.lastSubmittedValues, {
           onNone: () => new Set<string>(),
-          onSome: (lastSubmitted) => recalculateDirtySubtree(new Set(), lastSubmitted.encoded, state.values, ""),
-        }),
+          onSome: (lastSubmitted) => recalculateDirtySubtree(new Set(), lastSubmitted.encoded, state.values, "")
+        })
     })
-  ).pipe(Atom.setIdleTTL(0));
+  ).pipe(Atom.setIdleTTL(0))
 
   const hasChangedSinceSubmitAtom = Atom.readable((get) =>
     Option.match(get(stateAtom), {
       onNone: () => false,
       onSome: (state) => {
-        if (Option.isNone(state.lastSubmittedValues)) return false;
-        if (state.values === state.lastSubmittedValues.value.encoded) return false;
-        return get(changedSinceSubmitFieldsAtom).size > 0;
-      },
+        if (Option.isNone(state.lastSubmittedValues)) return false
+        if (state.values === state.lastSubmittedValues.value.encoded) return false
+        return get(changedSinceSubmitFieldsAtom).size > 0
+      }
     })
-  ).pipe(Atom.setIdleTTL(0));
-
-  const validationAtomsRegistry = createWeakRegistry<Atom.AtomResultFn<unknown, void, ParseResult.ParseError>>();
-  const fieldAtomsRegistry = createWeakRegistry<FieldAtoms>();
-  const publicFieldValueRegistry = createWeakRegistry<Atom.Atom<Option.Option<unknown>>>();
+  ).pipe(Atom.setIdleTTL(0))
+
+  const validationAtomsRegistry = createWeakRegistry<Atom.AtomResultFn<unknown, void, ParseResult.ParseError>>()
+  const fieldAtomsRegistry = createWeakRegistry<FieldAtoms>()
+  const publicFieldAtomsRegistry = createWeakRegistry<PublicFieldAtoms<unknown>>()
+  const validationSchemaRegistry = new Map<string, Schema.Schema.Any>()
+  const fieldSchemaRegistry = new Map<string, Schema.Schema.Any>()
+  const isDirtyAtomsRegistry = createWeakRegistry<Atom.Atom<boolean>>()
+
+  const fieldSchemasByKey = new Map<string, Schema.Schema.Any>()
+  for (const [key, def] of Object.entries(fields)) {
+    if (Field.isArrayFieldDef(def)) {
+      fieldSchemasByKey.set(key, Schema.Array(def.itemSchema))
+    } else if (Field.isFieldDef(def)) {
+      fieldSchemasByKey.set(key, def.schema)
+    }
+  }
 
   const getOrCreateValidationAtom = (
     fieldPath: string,
-    schema: Schema.Schema.Any,
+    schema: Schema.Schema.Any
   ): Atom.AtomResultFn<unknown, void, ParseResult.ParseError> => {
-    const existing = validationAtomsRegistry.get(fieldPath);
-    if (existing) return existing;
+    const existing = validationAtomsRegistry.get(fieldPath)
+    const existingSchema = validationSchemaRegistry.get(fieldPath)
+    if (existing && existingSchema === schema) return existing
 
     const validationAtom = runtime
       .fn<unknown>()((value: unknown) =>
         pipe(Schema.decodeUnknown(schema)(value) as Effect.Effect<unknown, ParseResult.ParseError, R>, Effect.asVoid)
       )
-      .pipe(Atom.setIdleTTL(0)) as Atom.AtomResultFn<unknown, void, ParseResult.ParseError>;
+      .pipe(Atom.setIdleTTL(0)) as Atom.AtomResultFn<unknown, void, ParseResult.ParseError>
 
-    validationAtomsRegistry.set(fieldPath, validationAtom);
-    return validationAtom;
-  };
+    validationAtomsRegistry.set(fieldPath, validationAtom)
+    validationSchemaRegistry.set(fieldPath, schema)
+    return validationAtom
+  }
 
-  const getOrCreateFieldAtoms = (fieldPath: string): FieldAtoms => {
-    const existing = fieldAtomsRegistry.get(fieldPath);
-    if (existing) return existing;
+  const getOrCreateFieldAtoms = (fieldPath: string, schema: Schema.Schema.Any): FieldAtoms => {
+    const existing = fieldAtomsRegistry.get(fieldPath)
+    const existingSchema = fieldSchemaRegistry.get(fieldPath)
+    if (existing && existingSchema === schema) return existing
 
     const valueAtom = Atom.writable(
       (get) => getNestedValue(Option.getOrThrow(get(stateAtom)).values, fieldPath),
       (ctx, value) => {
-        const currentState = Option.getOrThrow(ctx.get(stateAtom));
-        ctx.set(stateAtom, Option.some(operations.setFieldValue(currentState, fieldPath, value)));
-      },
-    ).pipe(Atom.setIdleTTL(0));
+        const currentState = Option.getOrThrow(ctx.get(stateAtom))
+        ctx.set(stateAtom, Option.some(operations.setFieldValue(currentState, fieldPath, value)))
+      }
+    ).pipe(Atom.setIdleTTL(0))
 
     const initialValueAtom = Atom.readable((get) =>
       getNestedValue(Option.getOrThrow(get(stateAtom)).initialValues, fieldPath)
-    ).pipe(Atom.setIdleTTL(0));
+    ).pipe(Atom.setIdleTTL(0))
 
     const touchedAtom = Atom.writable(
       (get) => (getNestedValue(Option.getOrThrow(get(stateAtom)).touched, fieldPath) ?? false) as boolean,
       (ctx, value) => {
-        const currentState = Option.getOrThrow(ctx.get(stateAtom));
+        const currentState = Option.getOrThrow(ctx.get(stateAtom))
         ctx.set(
           stateAtom,
           Option.some({
             ...currentState,
-            touched: setNestedValue(currentState.touched, fieldPath, value),
-          }),
-        );
-      },
-    ).pipe(Atom.setIdleTTL(0));
+            touched: setNestedValue(currentState.touched, fieldPath, value)
+          })
+        )
+      }
+    ).pipe(Atom.setIdleTTL(0))
 
     const errorAtom = Atom.readable((get) => {
-      const errors = get(errorsAtom);
-      const entry = errors.get(fieldPath);
-      return entry ? Option.some(entry) : Option.none<Validation.ErrorEntry>();
-    }).pipe(Atom.setIdleTTL(0));
+      const errors = get(errorsAtom)
+      const entry = errors.get(fieldPath)
+      return entry ? Option.some(entry) : Option.none<Validation.ErrorEntry>()
+    }).pipe(Atom.setIdleTTL(0))
 
-    const isDirtyAtom = Atom.readable((get) =>
+    const existingIsDirtyAtom = isDirtyAtomsRegistry.get(fieldPath)
+    const isDirtyAtom = existingIsDirtyAtom ?? Atom.readable((get) =>
       isPathOrParentDirty(
         Option.match(get(stateAtom), {
           onNone: () => new Set<string>(),
-          onSome: (state) => state.dirtyFields,
+          onSome: (state) => state.dirtyFields
         }),
-        fieldPath,
+        fieldPath
       )
-    ).pipe(Atom.setIdleTTL(0));
+    ).pipe(Atom.setIdleTTL(0))
+    if (!existingIsDirtyAtom) {
+      isDirtyAtomsRegistry.set(fieldPath, isDirtyAtom)
+    }
+
+    const validationAtom = getOrCreateValidationAtom(fieldPath, schema)
+
+    const shouldValidateAtom = Atom.readable((get) => {
+      if (parsedMode.validation === "onChange") return true
+      if (parsedMode.validation === "onBlur") return get(touchedAtom)
+      return get(submitCountAtom) > 0
+    }).pipe(Atom.setIdleTTL(0))
+
+    const displayErrorAtom = Atom.readable((get) => {
+      const validationResult = get(validationAtom)
+      const storedError = get(errorAtom)
+      const isDirty = get(isDirtyAtom)
+      const isTouched = get(touchedAtom)
+      const submitCount = get(submitCountAtom)
+
+      let livePerFieldError: Option.Option<string> = Option.none()
+      if (validationResult._tag === "Failure") {
+        const parseError = Cause.failureOption(validationResult.cause)
+        if (Option.isSome(parseError) && ParseResult.isParseError(parseError.value)) {
+          livePerFieldError = Validation.extractFirstError(parseError.value)
+        }
+      }
+
+      let validationError: Option.Option<string> = Option.none()
+      if (Option.isSome(livePerFieldError)) {
+        validationError = livePerFieldError
+      } else if (Option.isSome(storedError)) {
+        const isValidating = validationResult.waiting
+        const shouldHideStoredError = storedError.value.source === "field" &&
+          (validationResult._tag === "Success" || isValidating)
+        if (!shouldHideStoredError) {
+          validationError = Option.some(storedError.value.message)
+        }
+      }
+
+      const shouldShowError = parsedMode.validation === "onChange"
+        ? isDirty || submitCount > 0
+        : parsedMode.validation === "onBlur"
+        ? isTouched || submitCount > 0
+        : submitCount > 0
+
+      return shouldShowError ? validationError : Option.none()
+    }).pipe(Atom.setIdleTTL(0))
+
+    const triggerValidationAtom = Atom.readable((get) => {
+      let lastValue = get.once(valueAtom)
+      let timeout: ReturnType<typeof setTimeout> | undefined
+
+      const shouldDebounce = parsedMode.validation === "onChange" &&
+        parsedMode.debounce !== null && !parsedMode.autoSubmit
+      const debounceMs = shouldDebounce ? parsedMode.debounce : null
+
+      const trigger = (value: unknown) => {
+        if (!get.once(shouldValidateAtom)) return
+        if (debounceMs !== null && debounceMs > 0) {
+          if (timeout !== undefined) clearTimeout(timeout)
+          timeout = setTimeout(() => {
+            timeout = undefined
+            get.set(validationAtom, value)
+          }, debounceMs)
+        } else {
+          get.set(validationAtom, value)
+        }
+      }
 
-    const atoms: FieldAtoms = { valueAtom, initialValueAtom, touchedAtom, errorAtom, isDirtyAtom };
-    fieldAtomsRegistry.set(fieldPath, atoms);
-    return atoms;
-  };
+      get.addFinalizer(() => {
+        if (timeout !== undefined) clearTimeout(timeout)
+      })
+
+      get.subscribe(valueAtom, (newValue) => {
+        if (newValue === lastValue) return
+        lastValue = newValue
+        trigger(newValue)
+      })
+
+      if (parsedMode.validation === "onBlur") {
+        get.subscribe(touchedAtom, (isTouched) => {
+          if (isTouched) {
+            const currentValue = get.once(valueAtom)
+            get.set(validationAtom, currentValue)
+          }
+        })
+      }
+    }).pipe(Atom.setIdleTTL(0))
+
+    const atoms: FieldAtoms = {
+      valueAtom,
+      initialValueAtom,
+      touchedAtom,
+      errorAtom,
+      isDirtyAtom,
+      validationAtom,
+      displayErrorAtom,
+      shouldValidateAtom,
+      triggerValidationAtom
+    }
+    fieldAtomsRegistry.set(fieldPath, atoms)
+    fieldSchemaRegistry.set(fieldPath, schema)
+    return atoms
+  }
 
-  const resetValidationAtoms = (ctx: { set: <R, W>(atom: Atom.Writable<R, W>, value: W) => void; }) => {
+  const resetValidationAtoms = (ctx: { set: <R, W,>(atom: Atom.Writable<R, W>, value: W) => void }) => {
     for (const validationAtom of validationAtomsRegistry.values()) {
-      ctx.set(validationAtom, Atom.Reset);
+      ctx.set(validationAtom, Atom.Reset)
     }
-    validationAtomsRegistry.clear();
-    fieldAtomsRegistry.clear();
-  };
+    validationAtomsRegistry.clear()
+    fieldAtomsRegistry.clear()
+    publicFieldAtomsRegistry.clear()
+    validationSchemaRegistry.clear()
+    fieldSchemaRegistry.clear()
+    isDirtyAtomsRegistry.clear()
+  }
 
   const submitAtom = runtime
     .fn<SubmitArgs>()(
       (args, get) =>
         Effect.gen(function*() {
-          const state = get(stateAtom);
-          if (Option.isNone(state)) return yield* Effect.die("Form not initialized");
-          const values = state.value.values;
-          get.set(errorsAtom, new Map());
+          const state = get(stateAtom)
+          if (Option.isNone(state)) return yield* Effect.die("Form not initialized")
+          const values = state.value.values
+          get.set(errorsAtom, new Map())
           const decoded = yield* pipe(
             Schema.decodeUnknown(combinedSchema, { errors: "all" })(values) as Effect.Effect<
               Field.DecodedFromFields<TFields>,
@@ -325,106 +467,106 @@ export const make = <TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = v
             >,
             Effect.tapError((parseError) =>
               Effect.sync(() => {
-                const routedErrors = Validation.routeErrorsWithSource(parseError);
-                get.set(errorsAtom, routedErrors);
-                get.set(stateAtom, Option.some(operations.createSubmitState(state.value)));
+                const routedErrors = Validation.routeErrorsWithSource(parseError)
+                get.set(errorsAtom, routedErrors)
+                get.set(stateAtom, Option.some(operations.createSubmitState(state.value)))
               })
-            ),
-          );
-          const submitState = operations.createSubmitState(state.value);
+            )
+          )
+          const submitState = operations.createSubmitState(state.value)
           get.set(
             stateAtom,
             Option.some({
               ...submitState,
-              lastSubmittedValues: Option.some({ encoded: values, decoded }),
-            }),
-          );
-          const result = config.onSubmit(args, { decoded, encoded: values, get });
+              lastSubmittedValues: Option.some({ encoded: values, decoded })
+            })
+          )
+          const result = config.onSubmit(args, { decoded, encoded: values, get })
           if (Effect.isEffect(result)) {
-            return yield* result as Effect.Effect<A, E, R>;
+            return yield* result as Effect.Effect<A, E, R>
           }
-          return result as A;
+          return result as A
         }),
-      config.reactivityKeys ? { reactivityKeys: config.reactivityKeys } : undefined,
+      config.reactivityKeys ? { reactivityKeys: config.reactivityKeys } : undefined
     )
-    .pipe(Atom.setIdleTTL(0)) as Atom.AtomResultFn<SubmitArgs, A, E | ParseResult.ParseError>;
+    .pipe(Atom.setIdleTTL(0)) as Atom.AtomResultFn<SubmitArgs, A, E | ParseResult.ParseError>
 
   const fieldRefs = Object.fromEntries(
-    Object.keys(fields).map((key) => [key, FormBuilder.makeFieldRef(key)]),
-  ) as FieldRefs<TFields>;
+    Object.keys(fields).map((key) => [key, FormBuilder.makeFieldRef(key)])
+  ) as FieldRefs<TFields>
 
   const operations: FormOperations<TFields> = {
     createInitialState: (defaultValues) => ({
       values: defaultValues,
       initialValues: defaultValues,
       lastSubmittedValues: Option.none(),
-      touched: Field.createTouchedRecord(fields, false) as { readonly [K in keyof TFields]: boolean; },
+      touched: Field.createTouchedRecord(fields, false) as { readonly [K in keyof TFields]: boolean },
       submitCount: 0,
-      dirtyFields: new Set(),
+      dirtyFields: new Set()
     }),
 
     createResetState: (state) => ({
       values: state.initialValues,
       initialValues: state.initialValues,
       lastSubmittedValues: Option.none(),
-      touched: Field.createTouchedRecord(fields, false) as { readonly [K in keyof TFields]: boolean; },
+      touched: Field.createTouchedRecord(fields, false) as { readonly [K in keyof TFields]: boolean },
       submitCount: 0,
-      dirtyFields: new Set(),
+      dirtyFields: new Set()
     }),
 
     createSubmitState: (state) => ({
       ...state,
-      touched: Field.createTouchedRecord(fields, true) as { readonly [K in keyof TFields]: boolean; },
-      submitCount: state.submitCount + 1,
+      touched: Field.createTouchedRecord(fields, true) as { readonly [K in keyof TFields]: boolean },
+      submitCount: state.submitCount + 1
     }),
 
     setFieldValue: (state, fieldPath, value) => {
-      const newValues = setNestedValue(state.values, fieldPath, value);
-      const newDirtyFields = recalculateDirtySubtree(state.dirtyFields, state.initialValues, newValues, fieldPath);
+      const newValues = setNestedValue(state.values, fieldPath, value)
+      const newDirtyFields = recalculateDirtySubtree(state.dirtyFields, state.initialValues, newValues, fieldPath)
       return {
         ...state,
         values: newValues as Field.EncodedFromFields<TFields>,
-        dirtyFields: newDirtyFields,
-      };
+        dirtyFields: newDirtyFields
+      }
     },
 
     setFormValues: (state, values) => {
-      const newDirtyFields = recalculateDirtySubtree(state.dirtyFields, state.initialValues, values, "");
+      const newDirtyFields = recalculateDirtySubtree(state.dirtyFields, state.initialValues, values, "")
       return {
         ...state,
         values,
-        dirtyFields: newDirtyFields,
-      };
+        dirtyFields: newDirtyFields
+      }
     },
 
     setFieldTouched: (state, fieldPath, touched) => ({
       ...state,
-      touched: setNestedValue(state.touched, fieldPath, touched) as { readonly [K in keyof TFields]: boolean; },
+      touched: setNestedValue(state.touched, fieldPath, touched) as { readonly [K in keyof TFields]: boolean }
     }),
 
     appendArrayItem: (state, arrayPath, itemSchema, value) => {
-      const newItem = value ?? Field.getDefaultFromSchema(itemSchema);
-      const currentItems = (getNestedValue(state.values, arrayPath) ?? []) as ReadonlyArray<unknown>;
-      const newItems = [...currentItems, newItem];
+      const newItem = value ?? Field.getDefaultFromSchema(itemSchema)
+      const currentItems = (getNestedValue(state.values, arrayPath) ?? []) as ReadonlyArray<unknown>
+      const newItems = [...currentItems, newItem]
       return {
         ...state,
         values: setNestedValue(state.values, arrayPath, newItems) as Field.EncodedFromFields<TFields>,
-        dirtyFields: recalculateDirtyFieldsForArray(state.dirtyFields, state.initialValues, arrayPath, newItems),
-      };
+        dirtyFields: recalculateDirtyFieldsForArray(state.dirtyFields, state.initialValues, arrayPath, newItems)
+      }
     },
 
     removeArrayItem: (state, arrayPath, index) => {
-      const currentItems = (getNestedValue(state.values, arrayPath) ?? []) as ReadonlyArray<unknown>;
-      const newItems = currentItems.filter((_, i) => i !== index);
+      const currentItems = (getNestedValue(state.values, arrayPath) ?? []) as ReadonlyArray<unknown>
+      const newItems = currentItems.filter((_, i) => i !== index)
       return {
         ...state,
         values: setNestedValue(state.values, arrayPath, newItems) as Field.EncodedFromFields<TFields>,
-        dirtyFields: recalculateDirtyFieldsForArray(state.dirtyFields, state.initialValues, arrayPath, newItems),
-      };
+        dirtyFields: recalculateDirtyFieldsForArray(state.dirtyFields, state.initialValues, arrayPath, newItems)
+      }
     },
 
     swapArrayItems: (state, arrayPath, indexA, indexB) => {
-      const currentItems = (getNestedValue(state.values, arrayPath) ?? []) as ReadonlyArray<unknown>;
+      const currentItems = (getNestedValue(state.values, arrayPath) ?? []) as ReadonlyArray<unknown>
       if (
         indexA < 0 ||
         indexA >= currentItems.length ||
@@ -432,21 +574,21 @@ export const make = <TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = v
         indexB >= currentItems.length ||
         indexA === indexB
       ) {
-        return state;
+        return state
       }
-      const newItems = [...currentItems];
-      const temp = newItems[indexA];
-      newItems[indexA] = newItems[indexB];
-      newItems[indexB] = temp;
+      const newItems = [...currentItems]
+      const temp = newItems[indexA]
+      newItems[indexA] = newItems[indexB]
+      newItems[indexB] = temp
       return {
         ...state,
         values: setNestedValue(state.values, arrayPath, newItems) as Field.EncodedFromFields<TFields>,
-        dirtyFields: recalculateDirtyFieldsForArray(state.dirtyFields, state.initialValues, arrayPath, newItems),
-      };
+        dirtyFields: recalculateDirtyFieldsForArray(state.dirtyFields, state.initialValues, arrayPath, newItems)
+      }
     },
 
     moveArrayItem: (state, arrayPath, fromIndex, toIndex) => {
-      const currentItems = (getNestedValue(state.values, arrayPath) ?? []) as ReadonlyArray<unknown>;
+      const currentItems = (getNestedValue(state.values, arrayPath) ?? []) as ReadonlyArray<unknown>
       if (
         fromIndex < 0 ||
         fromIndex >= currentItems.length ||
@@ -454,116 +596,257 @@ export const make = <TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = v
         toIndex > currentItems.length ||
         fromIndex === toIndex
       ) {
-        return state;
+        return state
       }
-      const newItems = [...currentItems];
-      const [item] = newItems.splice(fromIndex, 1);
-      newItems.splice(toIndex, 0, item);
+      const newItems = [...currentItems]
+      const [item] = newItems.splice(fromIndex, 1)
+      newItems.splice(toIndex, 0, item)
       return {
         ...state,
         values: setNestedValue(state.values, arrayPath, newItems) as Field.EncodedFromFields<TFields>,
-        dirtyFields: recalculateDirtyFieldsForArray(state.dirtyFields, state.initialValues, arrayPath, newItems),
-      };
+        dirtyFields: recalculateDirtyFieldsForArray(state.dirtyFields, state.initialValues, arrayPath, newItems)
+      }
     },
 
     revertToLastSubmit: (state) => {
       if (Option.isNone(state.lastSubmittedValues)) {
-        return state;
+        return state
       }
 
-      const lastEncoded = state.lastSubmittedValues.value.encoded;
+      const lastEncoded = state.lastSubmittedValues.value.encoded
       if (state.values === lastEncoded) {
-        return state;
+        return state
       }
 
-      const newDirtyFields = recalculateDirtySubtree(state.dirtyFields, state.initialValues, lastEncoded, "");
+      const newDirtyFields = recalculateDirtySubtree(state.dirtyFields, state.initialValues, lastEncoded, "")
 
       return {
         ...state,
         values: lastEncoded,
-        dirtyFields: newDirtyFields,
-      };
-    },
-  };
+        dirtyFields: newDirtyFields
+      }
+    }
+  }
 
   const resetAtom = Atom.fnSync<void>()(
     (_: void, get) => {
-      const state = get(stateAtom);
-      if (Option.isNone(state)) return;
-      get.set(stateAtom, Option.some(operations.createResetState(state.value)));
-      get.set(errorsAtom, new Map());
-      resetValidationAtoms(get);
-      get.set(submitAtom, Atom.Reset);
+      const state = get(stateAtom)
+      if (Option.isNone(state)) return
+      get.set(stateAtom, Option.some(operations.createResetState(state.value)))
+      get.set(errorsAtom, new Map())
+      resetValidationAtoms(get)
+      get.set(submitAtom, Atom.Reset)
     },
-    { initialValue: undefined as void },
-  ).pipe(Atom.setIdleTTL(0));
+    { initialValue: undefined as void }
+  ).pipe(Atom.setIdleTTL(0))
 
   const revertToLastSubmitAtom = Atom.fnSync<void>()(
     (_: void, get) => {
-      const state = get(stateAtom);
-      if (Option.isNone(state)) return;
-      get.set(stateAtom, Option.some(operations.revertToLastSubmit(state.value)));
-      get.set(errorsAtom, new Map());
+      const state = get(stateAtom)
+      if (Option.isNone(state)) return
+      get.set(stateAtom, Option.some(operations.revertToLastSubmit(state.value)))
+      get.set(errorsAtom, new Map())
     },
-    { initialValue: undefined as void },
-  ).pipe(Atom.setIdleTTL(0));
-
-  const setValuesAtom = Atom.fnSync<Field.EncodedFromFields<TFields>>()(
-    (_values, get) => {
-      const state = get(stateAtom);
-      if (Option.isNone(state)) return;
-      get.set(stateAtom, Option.some(operations.setFormValues(state.value, _values)));
-      get.set(errorsAtom, new Map());
+    { initialValue: undefined as void }
+  ).pipe(Atom.setIdleTTL(0))
+
+  const setValuesAtom = Atom.fnSync<SetValuesArg<TFields>>()(
+    (update, get) => {
+      const state = get(stateAtom)
+      if (Option.isNone(state)) return
+      const values = typeof update === "function"
+        ? (update as (prev: Field.EncodedFromFields<TFields>) => Field.EncodedFromFields<TFields>)(state.value.values)
+        : update
+      get.set(stateAtom, Option.some(operations.setFormValues(state.value, values)))
+      get.set(errorsAtom, new Map())
     },
-    { initialValue: undefined as void },
-  ).pipe(Atom.setIdleTTL(0));
+    { initialValue: undefined as void }
+  ).pipe(Atom.setIdleTTL(0))
 
-  const setValueAtomsRegistry = createWeakRegistry<Atom.Writable<void, any>>();
+  const setValueAtomsRegistry = createWeakRegistry<Atom.Writable<void, any>>()
 
-  const setValue = <S>(field: FormBuilder.FieldRef<S>): Atom.Writable<void, S | ((prev: S) => S)> => {
-    const cached = setValueAtomsRegistry.get(field.key);
-    if (cached) return cached;
+  const setValue = <S,>(field: FormBuilder.FieldRef<S>): Atom.Writable<void, S | ((prev: S) => S)> => {
+    const cached = setValueAtomsRegistry.get(field.key)
+    if (cached) return cached
 
     const atom = Atom.fnSync<S | ((prev: S) => S)>()(
       (update, get) => {
-        const state = get(stateAtom);
-        if (Option.isNone(state)) return;
+        const state = get(stateAtom)
+        if (Option.isNone(state)) return
 
-        const currentValue = getNestedValue(state.value.values, field.key) as S;
-        const newValue = typeof update === "function" ? (update as (prev: S) => S)(currentValue) : update;
+        const currentValue = getNestedValue(state.value.values, field.key) as S
+        const newValue = typeof update === "function" ? (update as (prev: S) => S)(currentValue) : update
 
-        get.set(stateAtom, Option.some(operations.setFieldValue(state.value, field.key, newValue)));
+        get.set(stateAtom, Option.some(operations.setFieldValue(state.value, field.key, newValue)))
         // Don't clear errors - display logic handles showing/hiding based on source + validation state
       },
-      { initialValue: undefined as void },
-    ).pipe(Atom.setIdleTTL(0));
+      { initialValue: undefined as void }
+    ).pipe(Atom.setIdleTTL(0))
+
+    setValueAtomsRegistry.set(field.key, atom)
+    return atom
+  }
+
+  const getFieldIsDirty = (field: FormBuilder.FieldRef<any>): Atom.Atom<boolean> => {
+    const cached = fieldAtomsRegistry.get(field.key)
+    if (cached) return cached.isDirtyAtom
+
+    const existing = isDirtyAtomsRegistry.get(field.key)
+    if (existing) return existing
+
+    const atom = Atom.readable((get) =>
+      isPathOrParentDirty(
+        Option.match(get(stateAtom), {
+          onNone: () => new Set<string>(),
+          onSome: (state) => state.dirtyFields
+        }),
+        field.key
+      )
+    ).pipe(Atom.setIdleTTL(0))
+
+    isDirtyAtomsRegistry.set(field.key, atom)
+    return atom
+  }
 
-    setValueAtomsRegistry.set(field.key, atom);
-    return atom;
-  };
+  const getFieldAtoms = <S,>(field: FormBuilder.FieldRef<S>): PublicFieldAtoms<S> => {
+    const cached = publicFieldAtomsRegistry.get(field.key)
+    if (cached) return cached as PublicFieldAtoms<S>
 
-  const getFieldValue = <S>(field: FormBuilder.FieldRef<S>): Atom.Atom<Option.Option<S>> => {
-    const existing = publicFieldValueRegistry.get(field.key);
-    if (existing) return existing as Atom.Atom<Option.Option<S>>;
+    const schema = fieldSchemasByKey.get(field.key)
+    if (!schema) throw new Error(`No schema found for field "${field.key}"`)
 
-    const safeAtom = Atom.readable((get) =>
+    const internal = getOrCreateFieldAtoms(field.key, schema)
+
+    const value = Atom.readable((get) =>
       Option.map(get(stateAtom), (state) => getNestedValue(state.values, field.key) as S)
-    ).pipe(Atom.setIdleTTL(0));
+    ).pipe(Atom.setIdleTTL(0))
+
+    const error = Atom.readable((get) =>
+      Option.match(get(stateAtom), {
+        onNone: () => Option.none<string>(),
+        onSome: () => get(internal.displayErrorAtom)
+      })
+    ).pipe(Atom.setIdleTTL(0))
+
+    const isDirty = getFieldIsDirty(field)
+
+    const isTouched = Atom.readable((get) =>
+      Option.match(get(stateAtom), {
+        onNone: () => false,
+        onSome: (state) => (getNestedValue(state.touched, field.key) ?? false) as boolean
+      })
+    ).pipe(Atom.setIdleTTL(0))
+
+    const isValidating = Atom.readable((get) => get(internal.validationAtom).waiting).pipe(Atom.setIdleTTL(0))
 
-    publicFieldValueRegistry.set(field.key, safeAtom);
-    return safeAtom;
-  };
+    const setValueAtom = setValue(field)
 
-  const getFieldIsDirty = (field: FormBuilder.FieldRef<any>): Atom.Atom<boolean> =>
-    getOrCreateFieldAtoms(field.key).isDirtyAtom;
+    const setTouchedAtom = Atom.fnSync<boolean>()(
+      (touched, get) => {
+        const state = get(stateAtom)
+        if (Option.isNone(state)) return
+        get.set(stateAtom, Option.some(operations.setFieldTouched(state.value, field.key, touched)))
+      },
+      { initialValue: undefined as void }
+    ).pipe(Atom.setIdleTTL(0))
+
+    const bundle: PublicFieldAtoms<S> = {
+      value,
+      error,
+      isDirty,
+      isTouched,
+      isValidating,
+      setValue: setValueAtom,
+      setTouched: setTouchedAtom
+    }
+    publicFieldAtomsRegistry.set(field.key, bundle as PublicFieldAtoms<unknown>)
+    return bundle
+  }
 
   const mountAtom = Atom.readable((get) => {
-    get(stateAtom);
-    get(errorsAtom);
-    get(submitAtom);
-  }).pipe(Atom.setIdleTTL(0));
+    get(stateAtom)
+    get(errorsAtom)
+    get(submitAtom)
+  }).pipe(Atom.setIdleTTL(0))
+
+  const keepAliveActiveAtom = Atom.make(false).pipe(Atom.setIdleTTL(0))
+
+  const autoSubmitAtom: Atom.Atom<void> = parsedMode.autoSubmit && parsedMode.validation === "onChange"
+    ? Atom.readable((get) => {
+      const initialState = get.once(stateAtom)
+      let lastValues: unknown = Option.isSome(initialState)
+        ? initialState.value.values
+        : null
+      let pendingChanges = false
+      let wasSubmitting = false
+      let timeout: ReturnType<typeof setTimeout> | undefined
+
+      const debounceMs = parsedMode.debounce
+
+      const triggerSubmit = () => {
+        if (get.once(submitAtom).waiting) {
+          pendingChanges = true
+          return
+        }
+        get.set(submitAtom as Atom.Writable<any, any>, undefined)
+      }
 
-  const keepAliveActiveAtom = Atom.make(false).pipe(Atom.setIdleTTL(0));
+      const debouncedSubmit = () => {
+        if (debounceMs !== null && debounceMs > 0) {
+          if (timeout !== undefined) clearTimeout(timeout)
+          timeout = setTimeout(() => {
+            timeout = undefined
+            triggerSubmit()
+          }, debounceMs)
+        } else {
+          triggerSubmit()
+        }
+      }
+
+      get.addFinalizer(() => {
+        if (timeout !== undefined) clearTimeout(timeout)
+      })
+
+      get.subscribe(stateAtom, () => {
+        const state = get.once(stateAtom)
+        if (Option.isNone(state)) return
+        const currentValues = state.value.values
+        if (currentValues === lastValues) return
+        lastValues = currentValues
+
+        const submitResult = get.once(submitAtom)
+        if (submitResult.waiting) {
+          pendingChanges = true
+        } else {
+          debouncedSubmit()
+        }
+      })
+
+      get.subscribe(submitAtom, () => {
+        const result = get.once(submitAtom)
+        const isSubmitting = result.waiting
+        if (wasSubmitting && !isSubmitting) {
+          if (pendingChanges) {
+            pendingChanges = false
+            debouncedSubmit()
+          }
+        }
+        wasSubmitting = isSubmitting
+      })
+    }).pipe(Atom.setIdleTTL(0))
+    : Atom.readable(() => {}).pipe(Atom.setIdleTTL(0))
+
+  const onBlurSubmitAtom: Atom.Writable<void, void> = parsedMode.autoSubmit && parsedMode.validation === "onBlur"
+    ? Atom.fnSync<void>()((_: void, get) => {
+      if (get(submitAtom).waiting) return
+      const stateOption = get(stateAtom)
+      if (Option.isNone(stateOption)) return
+      const { lastSubmittedValues, values } = stateOption.value
+      if (Option.isSome(lastSubmittedValues) && values === lastSubmittedValues.value.encoded) return
+      get.set(submitAtom as Atom.Writable<any, any>, undefined)
+    }, { initialValue: undefined as void }).pipe(Atom.setIdleTTL(0))
+    : Atom.fnSync<void>()((_: void) => {}, { initialValue: undefined as void })
+      .pipe(Atom.setIdleTTL(0))
 
   return {
     stateAtom,
@@ -588,10 +871,10 @@ export const make = <TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = v
     resetAtom,
     revertToLastSubmitAtom,
     setValuesAtom,
-    setValue,
-    getFieldValue,
-    getFieldIsDirty,
+    getFieldAtoms,
+    autoSubmitAtom,
+    onBlurSubmitAtom,
     mountAtom,
-    keepAliveActiveAtom,
-  } as FormAtoms<TFields, R, A, E, SubmitArgs>;
-};
+    keepAliveActiveAtom
+  } as FormAtoms<TFields, R, A, E, SubmitArgs>
+}