@pyreon/form 0.10.0 → 0.11.0

package/src/tests/form.test.tsx

@@ -1,5 +1,5 @@
-import { mount } from '@pyreon/runtime-dom'
-import type { FormState } from '../index'
+import { mount } from "@pyreon/runtime-dom"
+import type { FormState } from "../index"
 import {
   FormProvider,
   useField,
@@ -8,7 +8,7 @@ import {
   useFormContext,
   useFormState,
   useWatch,
-} from '../index'
+} from "../index"
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -19,7 +19,7 @@ function Capture<T>({ fn }: { fn: () => T }) {
 
 function mountWith<T>(fn: () => T): { result: T; unmount: () => void } {
   let result: T | undefined
-  const el = document.createElement('div')
+  const el = document.createElement("div")
   document.body.appendChild(el)
   const unmount = mount(
     <Capture
@@ -45,19 +45,19 @@ type LoginForm = {
 
 // ─── useForm ─────────────────────────────────────────────────────────────────
 
-describe('useForm', () => {
-  it('initializes with correct values', () => {
+describe("useForm", () => {
+  it("initializes with correct values", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { email: 'test@test.com', password: '' },
+        initialValues: { email: "test@test.com", password: "" },
         onSubmit: () => {
           /* noop */
         },
       }),
     )
 
-    expect(form.fields.email.value()).toBe('test@test.com')
-    expect(form.fields.password.value()).toBe('')
+    expect(form.fields.email.value()).toBe("test@test.com")
+    expect(form.fields.password.value()).toBe("")
     expect(form.isValid()).toBe(true)
     expect(form.isDirty()).toBe(false)
     expect(form.isSubmitting()).toBe(false)
@@ -65,27 +65,27 @@ describe('useForm', () => {
     unmount()
   })
 
-  it('setValue updates field value and marks dirty', () => {
+  it("setValue updates field value and marks dirty", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         onSubmit: () => {
           /* noop */
         },
       }),
     )
 
-    form.fields.email.setValue('hello@world.com')
-    expect(form.fields.email.value()).toBe('hello@world.com')
+    form.fields.email.setValue("hello@world.com")
+    expect(form.fields.email.value()).toBe("hello@world.com")
     expect(form.fields.email.dirty()).toBe(true)
     expect(form.isDirty()).toBe(true)
     unmount()
   })
 
-  it('setTouched marks field as touched', () => {
+  it("setTouched marks field as touched", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         onSubmit: () => {
           /* noop */
         },
@@ -98,17 +98,17 @@ describe('useForm', () => {
     unmount()
   })
 
-  it('field-level validation on blur', async () => {
+  it("field-level validation on blur", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         validators: {
-          email: (v) => (!v ? 'Required' : undefined),
+          email: (v) => (!v ? "Required" : undefined),
         },
         onSubmit: () => {
           /* noop */
         },
-        validateOn: 'blur',
+        validateOn: "blur",
       }),
     )
 
@@ -119,11 +119,11 @@ describe('useForm', () => {
     form.fields.email.setTouched()
     await new Promise((r) => setTimeout(r, 0))
 
-    expect(form.fields.email.error()).toBe('Required')
+    expect(form.fields.email.error()).toBe("Required")
     expect(form.isValid()).toBe(false)
 
     // Fix the value
-    form.fields.email.setValue('test@test.com')
+    form.fields.email.setValue("test@test.com")
     form.fields.email.setTouched()
     await new Promise((r) => setTimeout(r, 0))
 
@@ -132,38 +132,38 @@ describe('useForm', () => {
     unmount()
   })
 
-  it('field-level validation on change', async () => {
+  it("field-level validation on change", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         validators: {
-          email: (v) => (!v ? 'Required' : undefined),
+          email: (v) => (!v ? "Required" : undefined),
         },
         onSubmit: () => {
           /* noop */
         },
-        validateOn: 'change',
+        validateOn: "change",
       }),
     )
 
     // Error should be set immediately via effect
     await new Promise((r) => setTimeout(r, 0))
-    expect(form.fields.email.error()).toBe('Required')
+    expect(form.fields.email.error()).toBe("Required")
 
-    form.fields.email.setValue('hello')
+    form.fields.email.setValue("hello")
     await new Promise((r) => setTimeout(r, 0))
     expect(form.fields.email.error()).toBeUndefined()
     unmount()
   })
 
-  it('handleSubmit validates and calls onSubmit when valid', async () => {
+  it("handleSubmit validates and calls onSubmit when valid", async () => {
     let submitted: LoginForm | undefined
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: 'a@b.com', password: '12345678' },
+        initialValues: { email: "a@b.com", password: "12345678" },
         validators: {
-          email: (v) => (!v ? 'Required' : undefined),
-          password: (v) => (v.length < 8 ? 'Too short' : undefined),
+          email: (v) => (!v ? "Required" : undefined),
+          password: (v) => (v.length < 8 ? "Too short" : undefined),
         },
         onSubmit: (values) => {
           submitted = values
@@ -172,18 +172,18 @@ describe('useForm', () => {
     )
 
     await form.handleSubmit()
-    expect(submitted).toEqual({ email: 'a@b.com', password: '12345678' })
+    expect(submitted).toEqual({ email: "a@b.com", password: "12345678" })
     expect(form.submitCount()).toBe(1)
     unmount()
   })
 
-  it('handleSubmit does not call onSubmit when invalid', async () => {
+  it("handleSubmit does not call onSubmit when invalid", async () => {
     let called = false
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         validators: {
-          email: (v) => (!v ? 'Required' : undefined),
+          email: (v) => (!v ? "Required" : undefined),
         },
         onSubmit: () => {
           called = true
@@ -194,16 +194,16 @@ describe('useForm', () => {
     await form.handleSubmit()
     expect(called).toBe(false)
     expect(form.submitCount()).toBe(1)
-    expect(form.fields.email.error()).toBe('Required')
+    expect(form.fields.email.error()).toBe("Required")
     expect(form.fields.email.touched()).toBe(true)
     unmount()
   })
 
-  it('handleSubmit sets isSubmitting during async onSubmit', async () => {
+  it("handleSubmit sets isSubmitting during async onSubmit", async () => {
     const states: boolean[] = []
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: 'a@b.com', password: '12345678' },
+        initialValues: { email: "a@b.com", password: "12345678" },
         onSubmit: async () => {
           states.push(form.isSubmitting())
           await new Promise((r) => setTimeout(r, 10))
@@ -219,17 +219,15 @@ describe('useForm', () => {
     unmount()
   })
 
-  it('schema validation runs after field validators', async () => {
+  it("schema validation runs after field validators", async () => {
     let submitted = false
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { password: '12345678', confirmPassword: '12345679' },
+        initialValues: { password: "12345678", confirmPassword: "12345679" },
         schema: (values) => {
-          const errors: Partial<
-            Record<'password' | 'confirmPassword', string>
-          > = {}
+          const errors: Partial<Record<"password" | "confirmPassword", string>> = {}
           if (values.password !== values.confirmPassword) {
-            errors.confirmPassword = 'Passwords must match'
+            errors.confirmPassword = "Passwords must match"
           }
           return errors
         },
@@ -241,41 +239,41 @@ describe('useForm', () => {
 
     await form.handleSubmit()
     expect(submitted).toBe(false)
-    expect(form.fields.confirmPassword.error()).toBe('Passwords must match')
+    expect(form.fields.confirmPassword.error()).toBe("Passwords must match")
 
     // Fix the value
-    form.fields.confirmPassword.setValue('12345678')
+    form.fields.confirmPassword.setValue("12345678")
     await form.handleSubmit()
     expect(submitted).toBe(true)
     unmount()
   })
 
-  it('values() returns all current values', () => {
+  it("values() returns all current values", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: 'a@b.com', password: 'secret' },
+        initialValues: { email: "a@b.com", password: "secret" },
         onSubmit: () => {
           /* noop */
         },
       }),
     )
 
-    expect(form.values()).toEqual({ email: 'a@b.com', password: 'secret' })
-    form.fields.email.setValue('new@email.com')
+    expect(form.values()).toEqual({ email: "a@b.com", password: "secret" })
+    form.fields.email.setValue("new@email.com")
     expect(form.values()).toEqual({
-      email: 'new@email.com',
-      password: 'secret',
+      email: "new@email.com",
+      password: "secret",
     })
     unmount()
   })
 
-  it('errors() returns all current errors', async () => {
+  it("errors() returns all current errors", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         validators: {
-          email: (v) => (!v ? 'Required' : undefined),
-          password: (v) => (!v ? 'Required' : undefined),
+          email: (v) => (!v ? "Required" : undefined),
+          password: (v) => (!v ? "Required" : undefined),
         },
         onSubmit: () => {
           /* noop */
@@ -285,18 +283,18 @@ describe('useForm', () => {
 
     await form.validate()
     expect(form.errors()).toEqual({
-      email: 'Required',
-      password: 'Required',
+      email: "Required",
+      password: "Required",
     })
     unmount()
   })
 
-  it('reset() restores initial values and clears state', async () => {
+  it("reset() restores initial values and clears state", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         validators: {
-          email: (v) => (!v ? 'Required' : undefined),
+          email: (v) => (!v ? "Required" : undefined),
         },
         onSubmit: () => {
           /* noop */
@@ -304,12 +302,12 @@ describe('useForm', () => {
       }),
     )
 
-    form.fields.email.setValue('changed')
+    form.fields.email.setValue("changed")
     form.fields.email.setTouched()
     await form.handleSubmit()
 
     form.reset()
-    expect(form.fields.email.value()).toBe('')
+    expect(form.fields.email.value()).toBe("")
     expect(form.fields.email.error()).toBeUndefined()
     expect(form.fields.email.touched()).toBe(false)
     expect(form.fields.email.dirty()).toBe(false)
@@ -317,12 +315,12 @@ describe('useForm', () => {
     unmount()
   })
 
-  it('validate() returns true when all valid', async () => {
+  it("validate() returns true when all valid", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: 'test@test.com', password: '12345678' },
+        initialValues: { email: "test@test.com", password: "12345678" },
         validators: {
-          email: (v) => (!v ? 'Required' : undefined),
+          email: (v) => (!v ? "Required" : undefined),
         },
         onSubmit: () => {
           /* noop */
@@ -335,14 +333,14 @@ describe('useForm', () => {
     unmount()
   })
 
-  it('async validators work', async () => {
+  it("async validators work", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { username: 'taken' },
+        initialValues: { username: "taken" },
         validators: {
           username: async (v) => {
             await new Promise((r) => setTimeout(r, 5))
-            return v === 'taken' ? 'Already taken' : undefined
+            return v === "taken" ? "Already taken" : undefined
           },
         },
         onSubmit: () => {
@@ -353,36 +351,36 @@ describe('useForm', () => {
 
     const valid = await form.validate()
     expect(valid).toBe(false)
-    expect(form.fields.username.error()).toBe('Already taken')
+    expect(form.fields.username.error()).toBe("Already taken")
     unmount()
   })
 
-  it('setting value back to initial clears dirty', () => {
+  it("setting value back to initial clears dirty", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: 'original', password: '' },
+        initialValues: { email: "original", password: "" },
         onSubmit: () => {
           /* noop */
         },
       }),
     )
 
-    form.fields.email.setValue('changed')
+    form.fields.email.setValue("changed")
     expect(form.fields.email.dirty()).toBe(true)
 
-    form.fields.email.setValue('original')
+    form.fields.email.setValue("original")
     expect(form.fields.email.dirty()).toBe(false)
     expect(form.isDirty()).toBe(false)
     unmount()
   })
 
-  it('cross-field validation — validators receive all form values', async () => {
+  it("cross-field validation — validators receive all form values", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { password: 'abc123', confirmPassword: 'different' },
+        initialValues: { password: "abc123", confirmPassword: "different" },
         validators: {
           confirmPassword: (value, allValues) =>
-            value !== allValues.password ? 'Passwords must match' : undefined,
+            value !== allValues.password ? "Passwords must match" : undefined,
         },
         onSubmit: () => {
           /* noop */
@@ -392,98 +390,98 @@ describe('useForm', () => {
 
     const valid = await form.validate()
     expect(valid).toBe(false)
-    expect(form.fields.confirmPassword.error()).toBe('Passwords must match')
+    expect(form.fields.confirmPassword.error()).toBe("Passwords must match")
 
-    form.fields.confirmPassword.setValue('abc123')
+    form.fields.confirmPassword.setValue("abc123")
     const valid2 = await form.validate()
     expect(valid2).toBe(true)
     expect(form.fields.confirmPassword.error()).toBeUndefined()
     unmount()
   })
 
-  it('register() returns value signal and event handlers', () => {
+  it("register() returns value signal and event handlers", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         onSubmit: () => {
           /* noop */
         },
       }),
     )
 
-    const props = form.register('email')
+    const props = form.register("email")
     expect(props.value).toBe(form.fields.email.value)
-    expect(typeof props.onInput).toBe('function')
-    expect(typeof props.onBlur).toBe('function')
+    expect(typeof props.onInput).toBe("function")
+    expect(typeof props.onBlur).toBe("function")
     unmount()
   })
 
-  it('register() onInput updates field value', () => {
+  it("register() onInput updates field value", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         onSubmit: () => {
           /* noop */
         },
       }),
     )
 
-    const props = form.register('email')
-    const fakeEvent = { target: { value: 'test@test.com' } } as unknown as Event
+    const props = form.register("email")
+    const fakeEvent = { target: { value: "test@test.com" } } as unknown as Event
     props.onInput(fakeEvent)
 
-    expect(form.fields.email.value()).toBe('test@test.com')
+    expect(form.fields.email.value()).toBe("test@test.com")
     expect(form.fields.email.dirty()).toBe(true)
     unmount()
   })
 
-  it('register() onBlur marks field as touched and validates', async () => {
+  it("register() onBlur marks field as touched and validates", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         validators: {
-          email: (v) => (!v ? 'Required' : undefined),
+          email: (v) => (!v ? "Required" : undefined),
         },
         onSubmit: () => {
           /* noop */
         },
-        validateOn: 'blur',
+        validateOn: "blur",
       }),
     )
 
-    const props = form.register('email')
+    const props = form.register("email")
     props.onBlur()
     await new Promise((r) => setTimeout(r, 0))
 
     expect(form.fields.email.touched()).toBe(true)
-    expect(form.fields.email.error()).toBe('Required')
+    expect(form.fields.email.error()).toBe("Required")
     unmount()
   })
 
-  it('setFieldError sets a single field error', () => {
+  it("setFieldError sets a single field error", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         onSubmit: () => {
           /* noop */
         },
       }),
     )
 
-    form.setFieldError('email', 'Server error: email taken')
-    expect(form.fields.email.error()).toBe('Server error: email taken')
+    form.setFieldError("email", "Server error: email taken")
+    expect(form.fields.email.error()).toBe("Server error: email taken")
     expect(form.isValid()).toBe(false)
 
-    form.setFieldError('email', undefined)
+    form.setFieldError("email", undefined)
     expect(form.fields.email.error()).toBeUndefined()
     expect(form.isValid()).toBe(true)
     unmount()
   })
 
-  it('setErrors sets multiple field errors at once', () => {
+  it("setErrors sets multiple field errors at once", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         onSubmit: () => {
           /* noop */
         },
@@ -491,30 +489,30 @@ describe('useForm', () => {
     )
 
     form.setErrors({
-      email: 'Invalid email',
-      password: 'Too weak',
+      email: "Invalid email",
+      password: "Too weak",
     })
-    expect(form.fields.email.error()).toBe('Invalid email')
-    expect(form.fields.password.error()).toBe('Too weak')
+    expect(form.fields.email.error()).toBe("Invalid email")
+    expect(form.fields.password.error()).toBe("Too weak")
     expect(form.isValid()).toBe(false)
     unmount()
   })
 
-  it('debounceMs delays validation', async () => {
+  it("debounceMs delays validation", async () => {
     let callCount = 0
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: '' },
+        initialValues: { name: "" },
         validators: {
           name: (v) => {
             callCount++
-            return !v ? 'Required' : undefined
+            return !v ? "Required" : undefined
           },
         },
         onSubmit: () => {
           /* noop */
         },
-        validateOn: 'blur',
+        validateOn: "blur",
         debounceMs: 50,
       }),
     )
@@ -531,19 +529,19 @@ describe('useForm', () => {
     // After debounce period, should have validated once
     await new Promise((r) => setTimeout(r, 60))
     expect(callCount).toBe(1)
-    expect(form.fields.name.error()).toBe('Required')
+    expect(form.fields.name.error()).toBe("Required")
     unmount()
   })
 
-  it('validate() bypasses debounce for immediate validation', async () => {
+  it("validate() bypasses debounce for immediate validation", async () => {
     let callCount = 0
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: '' },
+        initialValues: { name: "" },
         validators: {
           name: (v) => {
             callCount++
-            return !v ? 'Required' : undefined
+            return !v ? "Required" : undefined
           },
         },
         onSubmit: () => {
@@ -560,29 +558,29 @@ describe('useForm', () => {
     unmount()
   })
 
-  it('setFieldValue sets a field value from the form level', () => {
+  it("setFieldValue sets a field value from the form level", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         onSubmit: () => {
           /* noop */
         },
       }),
     )
 
-    form.setFieldValue('email', 'new@email.com')
-    expect(form.fields.email.value()).toBe('new@email.com')
+    form.setFieldValue("email", "new@email.com")
+    expect(form.fields.email.value()).toBe("new@email.com")
     expect(form.fields.email.dirty()).toBe(true)
     unmount()
   })
 
-  it('clearErrors clears all field errors', async () => {
+  it("clearErrors clears all field errors", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         validators: {
-          email: (v) => (!v ? 'Required' : undefined),
-          password: (v) => (!v ? 'Required' : undefined),
+          email: (v) => (!v ? "Required" : undefined),
+          password: (v) => (!v ? "Required" : undefined),
         },
         onSubmit: () => {
           /* noop */
@@ -600,38 +598,38 @@ describe('useForm', () => {
     unmount()
   })
 
-  it('resetField resets a single field without affecting others', () => {
+  it("resetField resets a single field without affecting others", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         onSubmit: () => {
           /* noop */
         },
       }),
     )
 
-    form.fields.email.setValue('changed')
-    form.fields.password.setValue('changed')
+    form.fields.email.setValue("changed")
+    form.fields.password.setValue("changed")
     form.fields.email.setTouched()
 
-    form.resetField('email')
-    expect(form.fields.email.value()).toBe('')
+    form.resetField("email")
+    expect(form.fields.email.value()).toBe("")
     expect(form.fields.email.dirty()).toBe(false)
     expect(form.fields.email.touched()).toBe(false)
     // Password should be unaffected
-    expect(form.fields.password.value()).toBe('changed')
+    expect(form.fields.password.value()).toBe("changed")
     expect(form.fields.password.dirty()).toBe(true)
     unmount()
   })
 
-  it('isValidating tracks async validation state', async () => {
+  it("isValidating tracks async validation state", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: '' },
+        initialValues: { name: "" },
         validators: {
           name: async (v) => {
             await new Promise((r) => setTimeout(r, 20))
-            return !v ? 'Required' : undefined
+            return !v ? "Required" : undefined
           },
         },
         onSubmit: () => {
@@ -648,10 +646,10 @@ describe('useForm', () => {
     unmount()
   })
 
-  it('handleSubmit calls preventDefault on event', async () => {
+  it("handleSubmit calls preventDefault on event", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: 'a@b.com', password: '12345678' },
+        initialValues: { email: "a@b.com", password: "12345678" },
         onSubmit: () => {
           /* noop */
         },
@@ -670,7 +668,7 @@ describe('useForm', () => {
     unmount()
   })
 
-  it('register() with checkbox type uses checked property', () => {
+  it("register() with checkbox type uses checked property", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
         initialValues: { remember: false },
@@ -680,13 +678,13 @@ describe('useForm', () => {
       }),
     )
 
-    const props = form.register('remember', { type: 'checkbox' })
+    const props = form.register("remember", { type: "checkbox" })
     expect(props.checked).toBeDefined()
     expect(props.checked!()).toBe(false)
 
     // Simulate checkbox change
     const fakeEvent = {
-      target: { checked: true, value: 'on' },
+      target: { checked: true, value: "on" },
     } as unknown as Event
     props.onInput(fakeEvent)
 
@@ -695,7 +693,7 @@ describe('useForm', () => {
     unmount()
   })
 
-  it('register() with number type uses valueAsNumber when valid', () => {
+  it("register() with number type uses valueAsNumber when valid", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
         initialValues: { age: 0 },
@@ -705,46 +703,46 @@ describe('useForm', () => {
       }),
     )
 
-    const props = form.register('age', { type: 'number' })
+    const props = form.register("age", { type: "number" })
 
     // Simulate input with a valid number
     const validEvent = {
-      target: { value: '25', valueAsNumber: 25 },
+      target: { value: "25", valueAsNumber: 25 },
     } as unknown as Event
     props.onInput(validEvent)
     expect(form.fields.age.value()).toBe(25)
 
     // Simulate input with NaN (e.g. empty string) — falls back to target.value
     const nanEvent = {
-      target: { value: '', valueAsNumber: NaN },
+      target: { value: "", valueAsNumber: NaN },
     } as unknown as Event
     props.onInput(nanEvent)
-    expect(form.fields.age.value()).toBe('')
+    expect(form.fields.age.value()).toBe("")
     unmount()
   })
 
-  it('register() returns same props for repeated calls (memoized)', () => {
+  it("register() returns same props for repeated calls (memoized)", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         onSubmit: () => {
           /* noop */
         },
       }),
     )
 
-    const first = form.register('email')
-    const second = form.register('email')
+    const first = form.register("email")
+    const second = form.register("email")
     expect(first).toBe(second)
     unmount()
   })
 
-  it('submitError captures onSubmit errors', async () => {
+  it("submitError captures onSubmit errors", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm<LoginForm>({
-        initialValues: { email: 'a@b.com', password: '12345678' },
+        initialValues: { email: "a@b.com", password: "12345678" },
         onSubmit: async () => {
-          throw new Error('Server error')
+          throw new Error("Server error")
         },
       }),
     )
@@ -754,7 +752,7 @@ describe('useForm', () => {
       /* expected */
     })
     expect(form.submitError()).toBeInstanceOf(Error)
-    expect((form.submitError() as Error).message).toBe('Server error')
+    expect((form.submitError() as Error).message).toBe("Server error")
 
     // Reset clears submitError
     form.reset()
@@ -762,10 +760,10 @@ describe('useForm', () => {
     unmount()
   })
 
-  it('dirty detection works for object field values', () => {
+  it("dirty detection works for object field values", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { address: { city: 'NYC', zip: '10001' } },
+        initialValues: { address: { city: "NYC", zip: "10001" } },
         onSubmit: () => {
           /* noop */
         },
@@ -773,19 +771,19 @@ describe('useForm', () => {
     )
 
     // Same structure = not dirty
-    form.fields.address.setValue({ city: 'NYC', zip: '10001' })
+    form.fields.address.setValue({ city: "NYC", zip: "10001" })
     expect(form.fields.address.dirty()).toBe(false)
 
     // Different structure = dirty
-    form.fields.address.setValue({ city: 'LA', zip: '90001' })
+    form.fields.address.setValue({ city: "LA", zip: "90001" })
     expect(form.fields.address.dirty()).toBe(true)
     unmount()
   })
 
-  it('dirty detection works for array field values', () => {
+  it("dirty detection works for array field values", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { tags: ['a', 'b'] },
+        initialValues: { tags: ["a", "b"] },
         onSubmit: () => {
           /* noop */
         },
@@ -793,11 +791,11 @@ describe('useForm', () => {
     )
 
     // Same array = not dirty
-    form.fields.tags.setValue(['a', 'b'])
+    form.fields.tags.setValue(["a", "b"])
     expect(form.fields.tags.dirty()).toBe(false)
 
     // Different array = dirty
-    form.fields.tags.setValue(['a', 'b', 'c'])
+    form.fields.tags.setValue(["a", "b", "c"])
     expect(form.fields.tags.dirty()).toBe(true)
     unmount()
   })
@@ -805,18 +803,16 @@ describe('useForm', () => {
 
 // ─── useFieldArray ───────────────────────────────────────────────────────────
 
-describe('useFieldArray', () => {
-  it('initializes with provided values', () => {
-    const { result: arr, unmount } = mountWith(() =>
-      useFieldArray(['a', 'b', 'c']),
-    )
+describe("useFieldArray", () => {
+  it("initializes with provided values", () => {
+    const { result: arr, unmount } = mountWith(() => useFieldArray(["a", "b", "c"]))
 
     expect(arr.length()).toBe(3)
-    expect(arr.values()).toEqual(['a', 'b', 'c'])
+    expect(arr.values()).toEqual(["a", "b", "c"])
     unmount()
   })
 
-  it('initializes empty by default', () => {
+  it("initializes empty by default", () => {
     const { result: arr, unmount } = mountWith(() => useFieldArray<string>())
 
     expect(arr.length()).toBe(0)
@@ -824,75 +820,69 @@ describe('useFieldArray', () => {
     unmount()
   })
 
-  it('append adds to end', () => {
-    const { result: arr, unmount } = mountWith(() => useFieldArray(['a']))
+  it("append adds to end", () => {
+    const { result: arr, unmount } = mountWith(() => useFieldArray(["a"]))
 
-    arr.append('b')
-    expect(arr.values()).toEqual(['a', 'b'])
+    arr.append("b")
+    expect(arr.values()).toEqual(["a", "b"])
     expect(arr.length()).toBe(2)
     unmount()
   })
 
-  it('prepend adds to start', () => {
-    const { result: arr, unmount } = mountWith(() => useFieldArray(['b']))
+  it("prepend adds to start", () => {
+    const { result: arr, unmount } = mountWith(() => useFieldArray(["b"]))
 
-    arr.prepend('a')
-    expect(arr.values()).toEqual(['a', 'b'])
+    arr.prepend("a")
+    expect(arr.values()).toEqual(["a", "b"])
     unmount()
   })
 
-  it('insert at index', () => {
-    const { result: arr, unmount } = mountWith(() => useFieldArray(['a', 'c']))
+  it("insert at index", () => {
+    const { result: arr, unmount } = mountWith(() => useFieldArray(["a", "c"]))
 
-    arr.insert(1, 'b')
-    expect(arr.values()).toEqual(['a', 'b', 'c'])
+    arr.insert(1, "b")
+    expect(arr.values()).toEqual(["a", "b", "c"])
     unmount()
   })
 
-  it('remove by index', () => {
-    const { result: arr, unmount } = mountWith(() =>
-      useFieldArray(['a', 'b', 'c']),
-    )
+  it("remove by index", () => {
+    const { result: arr, unmount } = mountWith(() => useFieldArray(["a", "b", "c"]))
 
     arr.remove(1)
-    expect(arr.values()).toEqual(['a', 'c'])
+    expect(arr.values()).toEqual(["a", "c"])
     unmount()
   })
 
-  it('move reorders items', () => {
-    const { result: arr, unmount } = mountWith(() =>
-      useFieldArray(['a', 'b', 'c']),
-    )
+  it("move reorders items", () => {
+    const { result: arr, unmount } = mountWith(() => useFieldArray(["a", "b", "c"]))
 
     arr.move(0, 2)
-    expect(arr.values()).toEqual(['b', 'c', 'a'])
+    expect(arr.values()).toEqual(["b", "c", "a"])
     unmount()
   })
 
-  it('swap exchanges items', () => {
-    const { result: arr, unmount } = mountWith(() =>
-      useFieldArray(['a', 'b', 'c']),
-    )
+  it("swap exchanges items", () => {
+    const { result: arr, unmount } = mountWith(() => useFieldArray(["a", "b", "c"]))
 
     arr.swap(0, 2)
-    expect(arr.values()).toEqual(['c', 'b', 'a'])
+    expect(arr.values()).toEqual(["c", "b", "a"])
     unmount()
   })
 
-  it('replace replaces all items', () => {
-    const { result: arr, unmount } = mountWith(() => useFieldArray(['a', 'b']))
+  it("replace replaces all items", () => {
+    const { result: arr, unmount } = mountWith(() => useFieldArray(["a", "b"]))
 
-    arr.replace(['x', 'y', 'z'])
-    expect(arr.values()).toEqual(['x', 'y', 'z'])
+    arr.replace(["x", "y", "z"])
+    expect(arr.values()).toEqual(["x", "y", "z"])
     expect(arr.length()).toBe(3)
     unmount()
   })
 
-  it('items have stable keys', () => {
-    const { result: arr, unmount } = mountWith(() => useFieldArray(['a', 'b']))
+  it("items have stable keys", () => {
+    const { result: arr, unmount } = mountWith(() => useFieldArray(["a", "b"]))
 
     const keysBefore = arr.items().map((i: any) => i.key)
-    arr.append('c')
+    arr.append("c")
     const keysAfter = arr.items().map((i: any) => i.key)
 
     // First two keys should be preserved
@@ -904,81 +894,75 @@ describe('useFieldArray', () => {
     unmount()
   })
 
-  it('individual item values are reactive signals', () => {
-    const { result: arr, unmount } = mountWith(() => useFieldArray(['a', 'b']))
+  it("individual item values are reactive signals", () => {
+    const { result: arr, unmount } = mountWith(() => useFieldArray(["a", "b"]))
 
     const item = arr.items()[0]!
-    expect(item.value()).toBe('a')
-    item.value.set('updated')
-    expect(item.value()).toBe('updated')
+    expect(item.value()).toBe("a")
+    item.value.set("updated")
+    expect(item.value()).toBe("updated")
     unmount()
   })
 
-  it('update modifies value at index', () => {
-    const { result: arr, unmount } = mountWith(() =>
-      useFieldArray(['a', 'b', 'c']),
-    )
+  it("update modifies value at index", () => {
+    const { result: arr, unmount } = mountWith(() => useFieldArray(["a", "b", "c"]))
 
-    arr.update(1, 'updated')
-    expect(arr.values()).toEqual(['a', 'updated', 'c'])
+    arr.update(1, "updated")
+    expect(arr.values()).toEqual(["a", "updated", "c"])
 
     // Key should be preserved
     const item = arr.items()[1]!
-    expect(item.value()).toBe('updated')
+    expect(item.value()).toBe("updated")
     unmount()
   })
 
-  it('update with invalid (out-of-bounds) index is a no-op', () => {
-    const { result: arr, unmount } = mountWith(() => useFieldArray(['a', 'b']))
+  it("update with invalid (out-of-bounds) index is a no-op", () => {
+    const { result: arr, unmount } = mountWith(() => useFieldArray(["a", "b"]))
 
-    arr.update(99, 'nope')
-    expect(arr.values()).toEqual(['a', 'b'])
+    arr.update(99, "nope")
+    expect(arr.values()).toEqual(["a", "b"])
 
-    arr.update(-1, 'nope')
-    expect(arr.values()).toEqual(['a', 'b'])
+    arr.update(-1, "nope")
+    expect(arr.values()).toEqual(["a", "b"])
     unmount()
   })
 
-  it('move with invalid from index does not insert undefined', () => {
-    const { result: arr, unmount } = mountWith(() =>
-      useFieldArray(['a', 'b', 'c']),
-    )
+  it("move with invalid from index does not insert undefined", () => {
+    const { result: arr, unmount } = mountWith(() => useFieldArray(["a", "b", "c"]))
 
     // splice(99,1) returns [] so item is undefined → splice(to,0) is a no-op
     arr.move(99, 0)
     // The array should still have 3 items (the splice removed nothing, guard prevented insert)
     // Actually splice removes nothing and returns [], item is undefined so nothing inserted
-    expect(arr.values()).toEqual(['a', 'b', 'c'])
+    expect(arr.values()).toEqual(["a", "b", "c"])
     unmount()
   })
 
-  it('swap with one invalid index is a no-op', () => {
-    const { result: arr, unmount } = mountWith(() =>
-      useFieldArray(['a', 'b', 'c']),
-    )
+  it("swap with one invalid index is a no-op", () => {
+    const { result: arr, unmount } = mountWith(() => useFieldArray(["a", "b", "c"]))
 
     // indexA out of bounds
     arr.swap(99, 0)
-    expect(arr.values()).toEqual(['a', 'b', 'c'])
+    expect(arr.values()).toEqual(["a", "b", "c"])
 
     // indexB out of bounds
     arr.swap(0, 99)
-    expect(arr.values()).toEqual(['a', 'b', 'c'])
+    expect(arr.values()).toEqual(["a", "b", "c"])
 
     // Both out of bounds
     arr.swap(99, 100)
-    expect(arr.values()).toEqual(['a', 'b', 'c'])
+    expect(arr.values()).toEqual(["a", "b", "c"])
     unmount()
   })
 })
 
 // ─── structuredEqual (via dirty tracking) ────────────────────────────────────
 
-describe('structuredEqual coverage via dirty tracking', () => {
-  it('arrays with different lengths are detected as dirty', () => {
+describe("structuredEqual coverage via dirty tracking", () => {
+  it("arrays with different lengths are detected as dirty", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { items: ['a', 'b'] as string[] },
+        initialValues: { items: ["a", "b"] as string[] },
         onSubmit: () => {
           /* noop */
         },
@@ -986,42 +970,42 @@ describe('structuredEqual coverage via dirty tracking', () => {
     )
 
     // Longer array
-    form.fields.items.setValue(['a', 'b', 'c'])
+    form.fields.items.setValue(["a", "b", "c"])
     expect(form.fields.items.dirty()).toBe(true)
 
     // Shorter array
-    form.fields.items.setValue(['a'])
+    form.fields.items.setValue(["a"])
     expect(form.fields.items.dirty()).toBe(true)
 
     // Same length same elements — not dirty
-    form.fields.items.setValue(['a', 'b'])
+    form.fields.items.setValue(["a", "b"])
     expect(form.fields.items.dirty()).toBe(false)
     unmount()
   })
 
-  it('arrays with same length but different elements are detected as dirty', () => {
+  it("arrays with same length but different elements are detected as dirty", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { items: ['a', 'b', 'c'] as string[] },
+        initialValues: { items: ["a", "b", "c"] as string[] },
         onSubmit: () => {
           /* noop */
         },
       }),
     )
 
-    form.fields.items.setValue(['a', 'b', 'x'])
+    form.fields.items.setValue(["a", "b", "x"])
     expect(form.fields.items.dirty()).toBe(true)
 
-    form.fields.items.setValue(['x', 'b', 'c'])
+    form.fields.items.setValue(["x", "b", "c"])
     expect(form.fields.items.dirty()).toBe(true)
 
     // Restoring original clears dirty
-    form.fields.items.setValue(['a', 'b', 'c'])
+    form.fields.items.setValue(["a", "b", "c"])
     expect(form.fields.items.dirty()).toBe(false)
     unmount()
   })
 
-  it('objects with different number of keys are detected as dirty', () => {
+  it("objects with different number of keys are detected as dirty", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
         initialValues: { meta: { x: 1, y: 2 } as Record<string, number> },
@@ -1045,7 +1029,7 @@ describe('structuredEqual coverage via dirty tracking', () => {
     unmount()
   })
 
-  it('objects with same key count but different values are detected as dirty', () => {
+  it("objects with same key count but different values are detected as dirty", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
         initialValues: { meta: { x: 1, y: 2 } as Record<string, number> },
@@ -1060,7 +1044,7 @@ describe('structuredEqual coverage via dirty tracking', () => {
     unmount()
   })
 
-  it('null vs object is detected as dirty', () => {
+  it("null vs object is detected as dirty", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
         initialValues: { data: { a: 1 } as Record<string, number> | null },
@@ -1078,22 +1062,22 @@ describe('structuredEqual coverage via dirty tracking', () => {
 
 // ─── validateOn: 'submit' ───────────────────────────────────────────────────
 
-describe('validateOn: submit', () => {
-  it('does not validate on blur', async () => {
+describe("validateOn: submit", () => {
+  it("does not validate on blur", async () => {
     let validatorCalls = 0
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: '' },
+        initialValues: { name: "" },
         validators: {
           name: (v) => {
             validatorCalls++
-            return !v ? 'Required' : undefined
+            return !v ? "Required" : undefined
           },
         },
         onSubmit: () => {
           /* noop */
         },
-        validateOn: 'submit',
+        validateOn: "submit",
       }),
     )
 
@@ -1104,25 +1088,25 @@ describe('validateOn: submit', () => {
     expect(form.fields.name.error()).toBeUndefined()
 
     // setValue should NOT trigger validation
-    form.fields.name.setValue('hello')
+    form.fields.name.setValue("hello")
     await new Promise((r) => setTimeout(r, 10))
     expect(validatorCalls).toBe(0)
     expect(form.fields.name.error()).toBeUndefined()
     unmount()
   })
 
-  it('validates only when handleSubmit is called', async () => {
+  it("validates only when handleSubmit is called", async () => {
     let submitted = false
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: '' },
+        initialValues: { name: "" },
         validators: {
-          name: (v) => (!v ? 'Required' : undefined),
+          name: (v) => (!v ? "Required" : undefined),
         },
         onSubmit: () => {
           submitted = true
         },
-        validateOn: 'submit',
+        validateOn: "submit",
       }),
     )
 
@@ -1134,10 +1118,10 @@ describe('validateOn: submit', () => {
     // Submit triggers validation
     await form.handleSubmit()
     expect(submitted).toBe(false)
-    expect(form.fields.name.error()).toBe('Required')
+    expect(form.fields.name.error()).toBe("Required")
 
     // Fix and resubmit
-    form.fields.name.setValue('hello')
+    form.fields.name.setValue("hello")
     await form.handleSubmit()
     expect(submitted).toBe(true)
     unmount()
@@ -1146,30 +1130,30 @@ describe('validateOn: submit', () => {
 
 // ─── debounceMs for field validation ─────────────────────────────────────────
 
-describe('debounceMs field validation', () => {
-  it('debounced validation on change mode', async () => {
+describe("debounceMs field validation", () => {
+  it("debounced validation on change mode", async () => {
     let callCount = 0
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: '' },
+        initialValues: { name: "" },
         validators: {
           name: (v) => {
             callCount++
-            return !v ? 'Required' : undefined
+            return !v ? "Required" : undefined
           },
         },
         onSubmit: () => {
           /* noop */
         },
-        validateOn: 'change',
+        validateOn: "change",
         debounceMs: 50,
       }),
     )
 
     // Change should trigger debounced validation
-    form.fields.name.setValue('a')
-    form.fields.name.setValue('ab')
-    form.fields.name.setValue('abc')
+    form.fields.name.setValue("a")
+    form.fields.name.setValue("ab")
+    form.fields.name.setValue("abc")
 
     // Not yet validated
     await new Promise((r) => setTimeout(r, 10))
@@ -1182,17 +1166,17 @@ describe('debounceMs field validation', () => {
     unmount()
   })
 
-  it('debounced validation resolves after timer fires', async () => {
+  it("debounced validation resolves after timer fires", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: '' },
+        initialValues: { name: "" },
         validators: {
-          name: (v) => (!v ? 'Required' : undefined),
+          name: (v) => (!v ? "Required" : undefined),
         },
         onSubmit: () => {
           /* noop */
         },
-        validateOn: 'blur',
+        validateOn: "blur",
         debounceMs: 30,
       }),
     )
@@ -1205,25 +1189,25 @@ describe('debounceMs field validation', () => {
 
     // After debounce fires
     await new Promise((r) => setTimeout(r, 50))
-    expect(form.fields.name.error()).toBe('Required')
+    expect(form.fields.name.error()).toBe("Required")
     unmount()
   })
 
-  it('reset clears pending debounce timers', async () => {
+  it("reset clears pending debounce timers", async () => {
     let callCount = 0
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: '' },
+        initialValues: { name: "" },
         validators: {
           name: (v) => {
             callCount++
-            return !v ? 'Required' : undefined
+            return !v ? "Required" : undefined
           },
         },
         onSubmit: () => {
           /* noop */
         },
-        validateOn: 'blur',
+        validateOn: "blur",
         debounceMs: 50,
       }),
     )
@@ -1242,61 +1226,61 @@ describe('debounceMs field validation', () => {
 
 // ─── Edge case: nonexistent field names ──────────────────────────────────────
 
-describe('useForm nonexistent field operations', () => {
-  it('setFieldValue with nonexistent field throws', () => {
+describe("useForm nonexistent field operations", () => {
+  it("setFieldValue with nonexistent field throws", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: 'Alice' },
+        initialValues: { name: "Alice" },
         onSubmit: () => {
           /* noop */
         },
       }),
     )
 
-    expect(() => form.setFieldValue('nonexistent' as any, 'value')).toThrow(
+    expect(() => form.setFieldValue("nonexistent" as any, "value")).toThrow(
       '[@pyreon/form] Field "nonexistent" does not exist',
     )
-    expect(form.fields.name.value()).toBe('Alice')
+    expect(form.fields.name.value()).toBe("Alice")
     unmount()
   })
 
-  it('setFieldError with nonexistent field throws', () => {
+  it("setFieldError with nonexistent field throws", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: 'Alice' },
+        initialValues: { name: "Alice" },
         onSubmit: () => {
           /* noop */
         },
       }),
     )
 
-    expect(() => form.setFieldError('nonexistent' as any, 'error')).toThrow(
+    expect(() => form.setFieldError("nonexistent" as any, "error")).toThrow(
       '[@pyreon/form] Field "nonexistent" does not exist',
     )
     expect(form.isValid()).toBe(true)
     unmount()
   })
 
-  it('resetField with nonexistent field is a no-op', () => {
+  it("resetField with nonexistent field is a no-op", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: 'Alice' },
+        initialValues: { name: "Alice" },
         onSubmit: () => {
           /* noop */
         },
       }),
     )
 
-    form.resetField('nonexistent' as any)
-    expect(form.fields.name.value()).toBe('Alice')
+    form.resetField("nonexistent" as any)
+    expect(form.fields.name.value()).toBe("Alice")
     unmount()
   })
 })
 
 // ─── Edge case: structuredEqual mixed types ──────────────────────────────────
 
-describe('dirty detection with mixed types', () => {
-  it('number vs string is dirty', () => {
+describe("dirty detection with mixed types", () => {
+  it("number vs string is dirty", () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
         initialValues: { value: 0 as any },
@@ -1306,7 +1290,7 @@ describe('dirty detection with mixed types', () => {
       }),
     )
 
-    form.fields.value.setValue('0' as any)
+    form.fields.value.setValue("0" as any)
     expect(form.fields.value.dirty()).toBe(true)
     unmount()
   })
@@ -1314,14 +1298,14 @@ describe('dirty detection with mixed types', () => {
 
 // ─── validate() branch coverage ──────────────────────────────────────────────
 
-describe('validate() branch coverage', () => {
-  it('getErrors returns empty when no errors exist', async () => {
+describe("validate() branch coverage", () => {
+  it("getErrors returns empty when no errors exist", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: 'valid', email: 'a@b.com' },
+        initialValues: { name: "valid", email: "a@b.com" },
         validators: {
-          name: (v) => (!v ? 'Required' : undefined),
-          email: (v) => (!v ? 'Required' : undefined),
+          name: (v) => (!v ? "Required" : undefined),
+          email: (v) => (!v ? "Required" : undefined),
         },
         onSubmit: () => {
           /* noop */
@@ -1335,11 +1319,11 @@ describe('validate() branch coverage', () => {
     unmount()
   })
 
-  it('stale async field-level validation on blur is discarded', async () => {
+  it("stale async field-level validation on blur is discarded", async () => {
     const resolvers: Array<(v: string | undefined) => void> = []
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: '' },
+        initialValues: { name: "" },
         validators: {
           name: (_v) => {
             return new Promise<string | undefined>((resolve) => {
@@ -1350,7 +1334,7 @@ describe('validate() branch coverage', () => {
         onSubmit: () => {
           /* noop */
         },
-        validateOn: 'blur',
+        validateOn: "blur",
       }),
     )
 
@@ -1360,7 +1344,7 @@ describe('validate() branch coverage', () => {
     form.fields.name.setTouched()
 
     // Resolve the first (stale) result
-    resolvers[0]!('Stale error from blur')
+    resolvers[0]!("Stale error from blur")
     await new Promise((r) => setTimeout(r, 0))
     // Error should NOT be set since it's stale
     expect(form.fields.name.error()).toBeUndefined()
@@ -1372,11 +1356,11 @@ describe('validate() branch coverage', () => {
     unmount()
   })
 
-  it('stale async validation results are discarded during validate()', async () => {
+  it("stale async validation results are discarded during validate()", async () => {
     const resolvers: Array<(v: string | undefined) => void> = []
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: '' },
+        initialValues: { name: "" },
         validators: {
           name: (_v) => {
             return new Promise<string | undefined>((resolve) => {
@@ -1396,7 +1380,7 @@ describe('validate() branch coverage', () => {
     const secondValidate = form.validate()
 
     // Resolve the first (stale) validation — should be discarded
-    resolvers[0]!('Stale error')
+    resolvers[0]!("Stale error")
     // Resolve the second (current) validation
     resolvers[1]!(undefined)
 
@@ -1407,13 +1391,13 @@ describe('validate() branch coverage', () => {
     unmount()
   })
 
-  it('field-level validator throwing during validate() captures error', async () => {
+  it("field-level validator throwing during validate() captures error", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: 'Alice' },
+        initialValues: { name: "Alice" },
         validators: {
           name: () => {
-            throw new Error('Validator crashed')
+            throw new Error("Validator crashed")
           },
         },
         onSubmit: () => {
@@ -1424,20 +1408,20 @@ describe('validate() branch coverage', () => {
 
     const valid = await form.validate()
     expect(valid).toBe(false)
-    expect(form.fields.name.error()).toBe('Validator crashed')
+    expect(form.fields.name.error()).toBe("Validator crashed")
     unmount()
   })
 
-  it('field-level validator throwing on blur captures error', async () => {
+  it("field-level validator throwing on blur captures error", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: '' },
+        initialValues: { name: "" },
         validators: {
           name: () => {
-            throw new Error('Blur validator crashed')
+            throw new Error("Blur validator crashed")
           },
         },
-        validateOn: 'blur',
+        validateOn: "blur",
         onSubmit: () => {
           /* noop */
         },
@@ -1446,15 +1430,15 @@ describe('validate() branch coverage', () => {
 
     form.fields.name.setTouched()
     await new Promise((r) => setTimeout(r, 0))
-    expect(form.fields.name.error()).toBe('Blur validator crashed')
+    expect(form.fields.name.error()).toBe("Blur validator crashed")
     unmount()
   })
 
-  it('schema validator with keys having undefined value does not block submit', async () => {
+  it("schema validator with keys having undefined value does not block submit", async () => {
     let submitted = false
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: 'Alice', email: 'a@b.com' },
+        initialValues: { name: "Alice", email: "a@b.com" },
         schema: (_values) => {
           // Return an object where some keys have undefined values
           return { name: undefined, email: undefined } as any
@@ -1471,12 +1455,12 @@ describe('validate() branch coverage', () => {
     unmount()
   })
 
-  it('schema validator throwing sets submitError and returns false', async () => {
+  it("schema validator throwing sets submitError and returns false", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: 'Alice', email: 'a@b.com' },
+        initialValues: { name: "Alice", email: "a@b.com" },
         schema: () => {
-          throw new Error('Schema exploded')
+          throw new Error("Schema exploded")
         },
         onSubmit: () => {
           /* noop */
@@ -1487,16 +1471,16 @@ describe('validate() branch coverage', () => {
     const valid = await form.validate()
     expect(valid).toBe(false)
     expect(form.submitError()).toBeInstanceOf(Error)
-    expect((form.submitError() as Error).message).toBe('Schema exploded')
+    expect((form.submitError() as Error).message).toBe("Schema exploded")
     unmount()
   })
 
-  it('fields without validators return undefined in validate()', async () => {
+  it("fields without validators return undefined in validate()", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: 'Alice', noValidator: 'test' },
+        initialValues: { name: "Alice", noValidator: "test" },
         validators: {
-          name: (v) => (!v ? 'Required' : undefined),
+          name: (v) => (!v ? "Required" : undefined),
           // noValidator field has no validator
         },
         onSubmit: () => {
@@ -1514,19 +1498,19 @@ describe('validate() branch coverage', () => {
 
 // ─── Edge case: debounceMs + validateOn: 'change' ───────────────────────────
 
-describe('debounceMs with validateOn change', () => {
-  it('debounces validation on change', async () => {
+describe("debounceMs with validateOn change", () => {
+  it("debounces validation on change", async () => {
     let callCount = 0
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { name: '' },
+        initialValues: { name: "" },
         validators: {
           name: async (v) => {
             callCount++
-            return v.length < 3 ? 'Too short' : undefined
+            return v.length < 3 ? "Too short" : undefined
           },
         },
-        validateOn: 'change',
+        validateOn: "change",
         debounceMs: 50,
         onSubmit: () => {
           /* noop */
@@ -1534,9 +1518,9 @@ describe('debounceMs with validateOn change', () => {
       }),
     )
 
-    form.fields.name.setValue('a')
-    form.fields.name.setValue('ab')
-    form.fields.name.setValue('abc')
+    form.fields.name.setValue("a")
+    form.fields.name.setValue("ab")
+    form.fields.name.setValue("abc")
 
     // None should have fired yet
     expect(callCount).toBe(0)
@@ -1551,36 +1535,36 @@ describe('debounceMs with validateOn change', () => {
 
 // ─── useField ────────────────────────────────────────────────────────────────
 
-describe('useField', () => {
-  it('extracts a single field from a form', () => {
+describe("useField", () => {
+  it("extracts a single field from a form", () => {
     const { result, unmount } = mountWith(() => {
       const form = useForm({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         onSubmit: () => {
           /* noop */
         },
       })
-      const field = useField(form, 'email')
+      const field = useField(form, "email")
       return { form, field }
     })
 
-    expect(result.field.value()).toBe('')
-    result.field.setValue('test@test.com')
-    expect(result.form.fields.email.value()).toBe('test@test.com')
+    expect(result.field.value()).toBe("")
+    result.field.setValue("test@test.com")
+    expect(result.form.fields.email.value()).toBe("test@test.com")
     expect(result.field.dirty()).toBe(true)
     unmount()
   })
 
-  it('hasError and showError computed correctly', async () => {
+  it("hasError and showError computed correctly", async () => {
     const { result, unmount } = mountWith(() => {
       const form = useForm({
-        initialValues: { email: '' },
-        validators: { email: (v) => (!v ? 'Required' : undefined) },
+        initialValues: { email: "" },
+        validators: { email: (v) => (!v ? "Required" : undefined) },
         onSubmit: () => {
           /* noop */
         },
       })
-      const field = useField(form, 'email')
+      const field = useField(form, "email")
       return { form, field }
     })
 
@@ -1597,26 +1581,26 @@ describe('useField', () => {
     unmount()
   })
 
-  it('register() delegates to form.register()', () => {
+  it("register() delegates to form.register()", () => {
     const { result, unmount } = mountWith(() => {
       const form = useForm({
-        initialValues: { email: '' },
+        initialValues: { email: "" },
         onSubmit: () => {
           /* noop */
         },
       })
-      const field = useField(form, 'email')
+      const field = useField(form, "email")
       return { form, field }
     })
 
     const fieldProps = result.field.register()
-    const formProps = result.form.register('email')
+    const formProps = result.form.register("email")
     // Should be the same memoized object
     expect(fieldProps).toBe(formProps)
     unmount()
   })
 
-  it('register() with checkbox type', () => {
+  it("register() with checkbox type", () => {
     const { result, unmount } = mountWith(() => {
       const form = useForm({
         initialValues: { remember: false },
@@ -1624,35 +1608,35 @@ describe('useField', () => {
           /* noop */
         },
       })
-      const field = useField(form, 'remember')
+      const field = useField(form, "remember")
       return { form, field }
     })
 
-    const props = result.field.register({ type: 'checkbox' })
+    const props = result.field.register({ type: "checkbox" })
     expect(props.checked).toBeDefined()
     expect(props.checked!()).toBe(false)
     unmount()
   })
 
-  it('reset delegates to field reset', () => {
+  it("reset delegates to field reset", () => {
     const { result, unmount } = mountWith(() => {
       const form = useForm({
-        initialValues: { name: 'initial' },
+        initialValues: { name: "initial" },
         onSubmit: () => {
           /* noop */
         },
       })
-      const field = useField(form, 'name')
+      const field = useField(form, "name")
       return { form, field }
     })
 
-    result.field.setValue('changed')
+    result.field.setValue("changed")
     result.field.setTouched()
     expect(result.field.dirty()).toBe(true)
     expect(result.field.touched()).toBe(true)
 
     result.field.reset()
-    expect(result.field.value()).toBe('initial')
+    expect(result.field.value()).toBe("initial")
     expect(result.field.dirty()).toBe(false)
     expect(result.field.touched()).toBe(false)
     unmount()
@@ -1661,48 +1645,48 @@ describe('useField', () => {
 
 // ─── useWatch ────────────────────────────────────────────────────────────────
 
-describe('useWatch', () => {
-  it('watches a single field value', () => {
+describe("useWatch", () => {
+  it("watches a single field value", () => {
     const { result, unmount } = mountWith(() => {
       const form = useForm({
-        initialValues: { email: 'a@b.com', password: '' },
+        initialValues: { email: "a@b.com", password: "" },
         onSubmit: () => {
           /* noop */
         },
       })
-      const email = useWatch(form, 'email')
+      const email = useWatch(form, "email")
       return { form, email }
     })
 
-    expect(result.email()).toBe('a@b.com')
-    result.form.fields.email.setValue('new@email.com')
-    expect(result.email()).toBe('new@email.com')
+    expect(result.email()).toBe("a@b.com")
+    result.form.fields.email.setValue("new@email.com")
+    expect(result.email()).toBe("new@email.com")
     unmount()
   })
 
-  it('watches multiple fields', () => {
+  it("watches multiple fields", () => {
     const { result, unmount } = mountWith(() => {
       const form = useForm({
-        initialValues: { first: 'John', last: 'Doe' },
+        initialValues: { first: "John", last: "Doe" },
         onSubmit: () => {
           /* noop */
         },
       })
-      const [first, last] = useWatch(form, ['first', 'last'])
+      const [first, last] = useWatch(form, ["first", "last"])
       return { form, first, last }
     })
 
-    expect(result.first!()).toBe('John')
-    expect(result.last!()).toBe('Doe')
-    result.form.fields.first.setValue('Jane')
-    expect(result.first!()).toBe('Jane')
+    expect(result.first!()).toBe("John")
+    expect(result.last!()).toBe("Doe")
+    result.form.fields.first.setValue("Jane")
+    expect(result.first!()).toBe("Jane")
     unmount()
   })
 
-  it('watches all fields when no name provided', () => {
+  it("watches all fields when no name provided", () => {
     const { result, unmount } = mountWith(() => {
       const form = useForm({
-        initialValues: { email: 'a@b.com', name: 'Alice' },
+        initialValues: { email: "a@b.com", name: "Alice" },
         onSubmit: () => {
           /* noop */
         },
@@ -1711,21 +1695,21 @@ describe('useWatch', () => {
       return { form, all }
     })
 
-    expect(result.all()).toEqual({ email: 'a@b.com', name: 'Alice' })
-    result.form.fields.email.setValue('new@email.com')
-    expect(result.all()).toEqual({ email: 'new@email.com', name: 'Alice' })
+    expect(result.all()).toEqual({ email: "a@b.com", name: "Alice" })
+    result.form.fields.email.setValue("new@email.com")
+    expect(result.all()).toEqual({ email: "new@email.com", name: "Alice" })
     unmount()
   })
 })
 
 // ─── useFormState ────────────────────────────────────────────────────────────
 
-describe('useFormState', () => {
-  it('returns full form state summary', async () => {
+describe("useFormState", () => {
+  it("returns full form state summary", async () => {
     const { result, unmount } = mountWith(() => {
       const form = useForm({
-        initialValues: { email: '', password: '' },
-        validators: { email: (v) => (!v ? 'Required' : undefined) },
+        initialValues: { email: "", password: "" },
+        validators: { email: (v) => (!v ? "Required" : undefined) },
         onSubmit: () => {
           /* noop */
         },
@@ -1746,7 +1730,7 @@ describe('useFormState', () => {
     expect(s.errors).toEqual({})
 
     // Change form state
-    result.form.fields.email.setValue('test')
+    result.form.fields.email.setValue("test")
     result.form.fields.email.setTouched()
     await new Promise((r) => setTimeout(r, 0))
 
@@ -1757,11 +1741,11 @@ describe('useFormState', () => {
     unmount()
   })
 
-  it('works with selector for fine-grained reactivity', async () => {
+  it("works with selector for fine-grained reactivity", async () => {
     const { result, unmount } = mountWith(() => {
       const form = useForm({
-        initialValues: { email: '' },
-        validators: { email: (v) => (!v ? 'Required' : undefined) },
+        initialValues: { email: "" },
+        validators: { email: (v) => (!v ? "Required" : undefined) },
         onSubmit: () => {
           /* noop */
         },
@@ -1777,19 +1761,19 @@ describe('useFormState', () => {
     expect(result.canSubmit()).toBe(false)
 
     // Fix value
-    result.form.fields.email.setValue('test@test.com')
+    result.form.fields.email.setValue("test@test.com")
     await result.form.validate()
     expect(result.canSubmit()).toBe(true)
     unmount()
   })
 
-  it('tracks errors in summary', async () => {
+  it("tracks errors in summary", async () => {
     const { result, unmount } = mountWith(() => {
       const form = useForm({
-        initialValues: { email: '', name: '' },
+        initialValues: { email: "", name: "" },
         validators: {
-          email: (v) => (!v ? 'Email required' : undefined),
-          name: (v) => (!v ? 'Name required' : undefined),
+          email: (v) => (!v ? "Email required" : undefined),
+          name: (v) => (!v ? "Name required" : undefined),
         },
         onSubmit: () => {
           /* noop */
@@ -1801,7 +1785,7 @@ describe('useFormState', () => {
 
     await result.form.validate()
     const s = result.state()
-    expect(s.errors).toEqual({ email: 'Email required', name: 'Name required' })
+    expect(s.errors).toEqual({ email: "Email required", name: "Name required" })
     expect(s.isValid).toBe(false)
     unmount()
   })
@@ -1809,10 +1793,10 @@ describe('useFormState', () => {
 
 // ─── FormProvider / useFormContext ────────────────────────────────────────────
 
-describe('FormProvider / useFormContext', () => {
-  it('provides form through context', () => {
+describe("FormProvider / useFormContext", () => {
+  it("provides form through context", () => {
     let contextForm: FormState<{ email: string }> | undefined
-    const el = document.createElement('div')
+    const el = document.createElement("div")
     document.body.appendChild(el)
 
     function ContextConsumer() {
@@ -1822,28 +1806,24 @@ describe('FormProvider / useFormContext', () => {
 
     function ContextTest() {
       const form = useForm({
-        initialValues: { email: 'context@test.com' },
+        initialValues: { email: "context@test.com" },
         onSubmit: () => {
           /* noop */
         },
       })
-      return (
-        <FormProvider form={form as any}>
-          {() => <ContextConsumer />}
-        </FormProvider>
-      )
+      return <FormProvider form={form as any}>{() => <ContextConsumer />}</FormProvider>
     }
 
     const unmount = mount(<ContextTest />, el)
 
     expect(contextForm).toBeDefined()
-    expect(contextForm!.fields.email.value()).toBe('context@test.com')
+    expect(contextForm!.fields.email.value()).toBe("context@test.com")
     unmount()
     el.remove()
   })
 
-  it('throws when useFormContext is called outside FormProvider', () => {
-    const el = document.createElement('div')
+  it("throws when useFormContext is called outside FormProvider", () => {
+    const el = document.createElement("div")
     document.body.appendChild(el)
 
     let error: Error | undefined
@@ -1861,8 +1841,8 @@ describe('FormProvider / useFormContext', () => {
     )
 
     expect(error).toBeDefined()
-    expect(error!.message).toContain('useFormContext')
-    expect(error!.message).toContain('FormProvider')
+    expect(error!.message).toContain("useFormContext")
+    expect(error!.message).toContain("FormProvider")
     unmount()
     el.remove()
   })