@pyreon/form 0.11.4 → 0.11.6

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,15 +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
         },
@@ -239,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 */
@@ -283,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 */
@@ -302,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)
@@ -315,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 */
@@ -333,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: () => {
@@ -351,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 */
@@ -390,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 */
         },
@@ -489,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,
       }),
     )
@@ -529,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: () => {
@@ -558,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 */
@@ -598,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: () => {
@@ -646,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 */
         },
@@ -668,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 },
@@ -678,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)
 
@@ -693,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 },
@@ -703,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')
         },
       }),
     )
@@ -752,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()
@@ -760,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 */
         },
@@ -771,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 */
         },
@@ -791,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()
   })
@@ -803,16 +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)
@@ -820,69 +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
@@ -894,75 +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 */
         },
@@ -970,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> },
@@ -1029,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> },
@@ -1044,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 },
@@ -1062,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',
       }),
     )
 
@@ -1088,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',
       }),
     )
 
@@ -1118,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()
@@ -1130,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))
@@ -1166,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,
       }),
     )
@@ -1189,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,
       }),
     )
@@ -1226,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 },
@@ -1290,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()
   })
@@ -1298,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 */
@@ -1319,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) => {
@@ -1334,7 +1334,7 @@ describe("validate() branch coverage", () => {
         onSubmit: () => {
           /* noop */
         },
-        validateOn: "blur",
+        validateOn: 'blur',
       }),
     )
 
@@ -1344,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()
@@ -1356,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) => {
@@ -1380,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)
 
@@ -1391,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: () => {
@@ -1408,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 */
         },
@@ -1430,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
@@ -1455,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 */
@@ -1471,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: () => {
@@ -1498,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 */
@@ -1518,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)
@@ -1535,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 }
     })
 
@@ -1581,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 },
@@ -1608,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()
@@ -1645,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 */
         },
@@ -1695,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 */
         },
@@ -1730,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))
 
@@ -1741,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 */
         },
@@ -1761,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 */
@@ -1785,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()
   })
@@ -1793,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() {
@@ -1806,7 +1806,7 @@ describe("FormProvider / useFormContext", () => {
 
     function ContextTest() {
       const form = useForm({
-        initialValues: { email: "context@test.com" },
+        initialValues: { email: 'context@test.com' },
         onSubmit: () => {
           /* noop */
         },
@@ -1817,13 +1817,13 @@ describe("FormProvider / useFormContext", () => {
     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
@@ -1841,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()
   })