@pyreon/feature 0.10.0 → 0.11.1

package/src/tests/feature.test.tsx

@@ -1,15 +1,10 @@
-import { QueryClient, QueryClientProvider } from '@pyreon/query'
-import { signal } from '@pyreon/reactivity'
-import { mount } from '@pyreon/runtime-dom'
-import { resetAllStores } from '@pyreon/store'
-import { z } from 'zod'
-import { defineFeature } from '../define-feature'
-import {
-  defaultInitialValues,
-  extractFields,
-  isReference,
-  reference,
-} from '../schema'
+import { QueryClient, QueryClientProvider } from "@pyreon/query"
+import { signal } from "@pyreon/reactivity"
+import { mount } from "@pyreon/runtime-dom"
+import { resetAllStores } from "@pyreon/store"
+import { z } from "zod"
+import { defineFeature } from "../define-feature"
+import { defaultInitialValues, extractFields, isReference, reference } from "../schema"
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -18,12 +13,9 @@ function Capture<T>({ fn }: { fn: () => T }) {
   return null
 }
 
-function mountWith<T>(
-  client: QueryClient,
-  fn: () => T,
-): { result: T; unmount: () => void } {
+function mountWith<T>(client: QueryClient, 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(
     <QueryClientProvider client={client}>
@@ -49,7 +41,7 @@ function mountWith<T>(
 const userSchema = z.object({
   name: z.string().min(2),
   email: z.string().email(),
-  role: z.enum(['admin', 'editor', 'viewer']),
+  role: z.enum(["admin", "editor", "viewer"]),
   age: z.number().optional(),
   active: z.boolean(),
 })
@@ -58,34 +50,24 @@ type UserValues = z.infer<typeof userSchema>
 
 // ─── Mock fetch ────────────────────────────────────────────────────────────────
 
-function createMockFetch(
-  responses: Record<string, { status?: number; body?: unknown }>,
-) {
-  return async (
-    url: string | URL | Request,
-    init?: RequestInit,
-  ): Promise<Response> => {
-    const urlStr = typeof url === 'string' ? url : url.toString()
-    const method = init?.method ?? 'GET'
+function createMockFetch(responses: Record<string, { status?: number; body?: unknown }>) {
+  return async (url: string | URL | Request, init?: RequestInit): Promise<Response> => {
+    const urlStr = typeof url === "string" ? url : url.toString()
+    const method = init?.method ?? "GET"
     const key = `${method} ${urlStr}`
 
-    const match =
-      responses[key] ??
-      Object.entries(responses).find(([k]) => key.startsWith(k))?.[1]
+    const match = responses[key] ?? Object.entries(responses).find(([k]) => key.startsWith(k))?.[1]
 
     if (!match) {
-      return new Response(JSON.stringify({ message: 'Not found' }), {
+      return new Response(JSON.stringify({ message: "Not found" }), {
         status: 404,
       })
     }
 
-    return new Response(
-      match.body !== undefined ? JSON.stringify(match.body) : null,
-      {
-        status: match.status ?? 200,
-        headers: { 'Content-Type': 'application/json' },
-      },
-    )
+    return new Response(match.body !== undefined ? JSON.stringify(match.body) : null, {
+      status: match.status ?? 200,
+      headers: { "Content-Type": "application/json" },
+    })
   }
 }
 
@@ -97,94 +79,94 @@ afterEach(() => {
 
 // ─── Schema introspection ──────────────────────────────────────────────────────
 
-describe('extractFields', () => {
-  it('extracts field names and types from a Zod schema', () => {
+describe("extractFields", () => {
+  it("extracts field names and types from a Zod schema", () => {
     const fields = extractFields(userSchema)
 
     expect(fields).toHaveLength(5)
     expect(fields[0]).toEqual({
-      name: 'name',
-      type: 'string',
+      name: "name",
+      type: "string",
       optional: false,
-      label: 'Name',
+      label: "Name",
     })
     expect(fields[1]).toEqual({
-      name: 'email',
-      type: 'string',
+      name: "email",
+      type: "string",
       optional: false,
-      label: 'Email',
+      label: "Email",
     })
     expect(fields[2]).toMatchObject({
-      name: 'role',
-      type: 'enum',
+      name: "role",
+      type: "enum",
       optional: false,
-      label: 'Role',
+      label: "Role",
     })
   })
 
-  it('detects optional fields', () => {
+  it("detects optional fields", () => {
     const fields = extractFields(userSchema)
-    const ageField = fields.find((f) => f.name === 'age')
+    const ageField = fields.find((f) => f.name === "age")
     expect(ageField?.optional).toBe(true)
-    expect(ageField?.type).toBe('number')
+    expect(ageField?.type).toBe("number")
   })
 
-  it('detects boolean fields', () => {
+  it("detects boolean fields", () => {
     const fields = extractFields(userSchema)
-    const activeField = fields.find((f) => f.name === 'active')
-    expect(activeField?.type).toBe('boolean')
+    const activeField = fields.find((f) => f.name === "active")
+    expect(activeField?.type).toBe("boolean")
   })
 
-  it('converts field names to labels', () => {
+  it("converts field names to labels", () => {
     const schema = z.object({
       firstName: z.string(),
       last_name: z.string(),
       email_address: z.string(),
     })
     const fields = extractFields(schema)
-    expect(fields[0]!.label).toBe('First Name')
-    expect(fields[1]!.label).toBe('Last Name')
-    expect(fields[2]!.label).toBe('Email Address')
+    expect(fields[0]!.label).toBe("First Name")
+    expect(fields[1]!.label).toBe("Last Name")
+    expect(fields[2]!.label).toBe("Email Address")
   })
 
-  it('returns empty array for non-object input', () => {
+  it("returns empty array for non-object input", () => {
     expect(extractFields(null)).toEqual([])
     expect(extractFields(undefined)).toEqual([])
-    expect(extractFields('string')).toEqual([])
+    expect(extractFields("string")).toEqual([])
   })
 
-  it('handles Zod v3-style schema with _def.typeName', () => {
+  it("handles Zod v3-style schema with _def.typeName", () => {
     // Mock v3 schema shape
     const mockSchema = {
       _def: {
         shape: () => ({
           title: {
-            _def: { typeName: 'ZodString' },
+            _def: { typeName: "ZodString" },
           },
           count: {
-            _def: { typeName: 'ZodNumber' },
+            _def: { typeName: "ZodNumber" },
           },
           done: {
-            _def: { typeName: 'ZodBoolean' },
+            _def: { typeName: "ZodBoolean" },
           },
         }),
       },
     }
     const fields = extractFields(mockSchema)
     expect(fields).toHaveLength(3)
-    expect(fields[0]).toMatchObject({ name: 'title', type: 'string' })
-    expect(fields[1]).toMatchObject({ name: 'count', type: 'number' })
-    expect(fields[2]).toMatchObject({ name: 'done', type: 'boolean' })
+    expect(fields[0]).toMatchObject({ name: "title", type: "string" })
+    expect(fields[1]).toMatchObject({ name: "count", type: "number" })
+    expect(fields[2]).toMatchObject({ name: "done", type: "boolean" })
   })
 
-  it('handles Zod v3-style optional with _def.typeName ZodOptional', () => {
+  it("handles Zod v3-style optional with _def.typeName ZodOptional", () => {
     const mockSchema = {
       _def: {
         shape: () => ({
           name: {
             _def: {
-              typeName: 'ZodOptional',
-              innerType: { _def: { typeName: 'ZodString' } },
+              typeName: "ZodOptional",
+              innerType: { _def: { typeName: "ZodString" } },
             },
           },
         }),
@@ -192,20 +174,20 @@ describe('extractFields', () => {
     }
     const fields = extractFields(mockSchema)
     expect(fields[0]).toMatchObject({
-      name: 'name',
-      type: 'string',
+      name: "name",
+      type: "string",
       optional: true,
     })
   })
 
-  it('handles Zod v3-style enum with _def.values', () => {
+  it("handles Zod v3-style enum with _def.values", () => {
     const mockSchema = {
       _def: {
         shape: () => ({
           status: {
             _def: {
-              typeName: 'ZodEnum',
-              values: ['active', 'inactive'],
+              typeName: "ZodEnum",
+              values: ["active", "inactive"],
             },
           },
         }),
@@ -213,42 +195,42 @@ describe('extractFields', () => {
     }
     const fields = extractFields(mockSchema)
     expect(fields[0]).toMatchObject({
-      name: 'status',
-      type: 'enum',
-      enumValues: ['active', 'inactive'],
+      name: "status",
+      type: "enum",
+      enumValues: ["active", "inactive"],
     })
   })
 
-  it('returns unknown for unrecognized field type', () => {
+  it("returns unknown for unrecognized field type", () => {
     const mockSchema = {
       shape: {
-        weird: { _def: { typeName: 'ZodSomethingNew' } },
+        weird: { _def: { typeName: "ZodSomethingNew" } },
       },
     }
     const fields = extractFields(mockSchema)
-    expect(fields[0]).toMatchObject({ name: 'weird', type: 'string' })
+    expect(fields[0]).toMatchObject({ name: "weird", type: "string" })
   })
 
-  it('handles schema with static _def.shape object (not function)', () => {
+  it("handles schema with static _def.shape object (not function)", () => {
     const mockSchema = {
       _def: {
         shape: {
-          name: { _def: { typeName: 'ZodString' } },
+          name: { _def: { typeName: "ZodString" } },
         },
       },
     }
     const fields = extractFields(mockSchema)
     expect(fields).toHaveLength(1)
-    expect(fields[0]).toMatchObject({ name: 'name', type: 'string' })
+    expect(fields[0]).toMatchObject({ name: "name", type: "string" })
   })
 
-  it('handles schema with _zod.def.shape (v4 path)', () => {
+  it("handles schema with _zod.def.shape (v4 path)", () => {
     const mockSchema = {
       _zod: {
         def: {
           shape: {
             email: {
-              _zod: { def: { type: 'string' } },
+              _zod: { def: { type: "string" } },
             },
           },
         },
@@ -256,27 +238,27 @@ describe('extractFields', () => {
     }
     const fields = extractFields(mockSchema)
     expect(fields).toHaveLength(1)
-    expect(fields[0]).toMatchObject({ name: 'email', type: 'string' })
+    expect(fields[0]).toMatchObject({ name: "email", type: "string" })
   })
 
-  it('handles getTypeName returning undefined', () => {
+  it("handles getTypeName returning undefined", () => {
     const mockSchema = {
       shape: {
         field: {},
       },
     }
     const fields = extractFields(mockSchema)
-    expect(fields[0]).toMatchObject({ name: 'field', type: 'unknown' })
+    expect(fields[0]).toMatchObject({ name: "field", type: "unknown" })
   })
 })
 
-describe('defaultInitialValues', () => {
-  it('generates defaults from field types', () => {
+describe("defaultInitialValues", () => {
+  it("generates defaults from field types", () => {
     const fields = extractFields(userSchema)
     const values = defaultInitialValues(fields)
 
-    expect(values.name).toBe('')
-    expect(values.email).toBe('')
+    expect(values.name).toBe("")
+    expect(values.email).toBe("")
     expect(values.age).toBe(0)
     expect(values.active).toBe(false)
   })
@@ -284,52 +266,52 @@ describe('defaultInitialValues', () => {
 
 // ─── defineFeature ─────────────────────────────────────────────────────────────
 
-describe('defineFeature', () => {
-  it('returns a feature with name, api, schema, fields, and queryKey', () => {
+describe("defineFeature", () => {
+  it("returns a feature with name, api, schema, fields, and queryKey", () => {
     const users = defineFeature<UserValues>({
-      name: 'users',
+      name: "users",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
     })
 
-    expect(users.name).toBe('users')
-    expect(users.api).toBe('/api/users')
+    expect(users.name).toBe("users")
+    expect(users.api).toBe("/api/users")
     expect(users.schema).toBe(userSchema)
     expect(users.fields.length).toBeGreaterThan(0)
-    expect(users.fields[0]!.name).toBe('name')
-    expect(users.queryKey()).toEqual(['users'])
-    expect(users.queryKey('123')).toEqual(['users', '123'])
-    expect(users.queryKey(42)).toEqual(['users', 42])
+    expect(users.fields[0]!.name).toBe("name")
+    expect(users.queryKey()).toEqual(["users"])
+    expect(users.queryKey("123")).toEqual(["users", "123"])
+    expect(users.queryKey(42)).toEqual(["users", 42])
   })
 
-  it('has all hooks', () => {
+  it("has all hooks", () => {
     const users = defineFeature<UserValues>({
-      name: 'users',
+      name: "users",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
     })
 
-    expect(typeof users.useList).toBe('function')
-    expect(typeof users.useById).toBe('function')
-    expect(typeof users.useSearch).toBe('function')
-    expect(typeof users.useCreate).toBe('function')
-    expect(typeof users.useUpdate).toBe('function')
-    expect(typeof users.useDelete).toBe('function')
-    expect(typeof users.useForm).toBe('function')
-    expect(typeof users.useTable).toBe('function')
-    expect(typeof users.useStore).toBe('function')
+    expect(typeof users.useList).toBe("function")
+    expect(typeof users.useById).toBe("function")
+    expect(typeof users.useSearch).toBe("function")
+    expect(typeof users.useCreate).toBe("function")
+    expect(typeof users.useUpdate).toBe("function")
+    expect(typeof users.useDelete).toBe("function")
+    expect(typeof users.useForm).toBe("function")
+    expect(typeof users.useTable).toBe("function")
+    expect(typeof users.useStore).toBe("function")
   })
 
-  it('auto-generates initial values from schema', () => {
+  it("auto-generates initial values from schema", () => {
     const users = defineFeature<UserValues>({
-      name: 'users-auto-init',
+      name: "users-auto-init",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
     })
 
     const client = new QueryClient()
     const { result: form, unmount } = mountWith(client, () => users.useForm())
-    expect(form.values().name).toBe('')
+    expect(form.values().name).toBe("")
     expect(form.values().active).toBe(false)
     unmount()
   })
@@ -337,18 +319,16 @@ describe('defineFeature', () => {
 
 // ─── useList ────────────────────────────────────────────────────────────────────
 
-describe('useList', () => {
-  it('fetches list from API', async () => {
-    const mockUsers = [
-      { name: 'Alice', email: 'a@t.com', role: 'admin', active: true },
-    ]
+describe("useList", () => {
+  it("fetches list from API", async () => {
+    const mockUsers = [{ name: "Alice", email: "a@t.com", role: "admin", active: true }]
 
     const users = defineFeature<UserValues>({
-      name: 'users-list',
+      name: "users-list",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: createMockFetch({
-        'GET /api/users': { body: mockUsers },
+        "GET /api/users": { body: mockUsers },
       }) as typeof fetch,
     })
 
@@ -363,66 +343,62 @@ describe('useList', () => {
     unmount()
   })
 
-  it('passes query params to URL', async () => {
-    let capturedUrl = ''
+  it("passes query params to URL", async () => {
+    let capturedUrl = ""
     const users = defineFeature<UserValues>({
-      name: 'users-params',
+      name: "users-params",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: (async (url: string) => {
         capturedUrl = url
-        return new Response('[]', { status: 200 })
+        return new Response("[]", { status: 200 })
       }) as typeof fetch,
     })
 
     const client = new QueryClient({
       defaultOptions: { queries: { retry: false } },
     })
-    const { unmount } = mountWith(client, () =>
-      users.useList({ params: { page: 2 } }),
-    )
+    const { unmount } = mountWith(client, () => users.useList({ params: { page: 2 } }))
     await new Promise((r) => setTimeout(r, 50))
-    expect(capturedUrl).toContain('page=2')
+    expect(capturedUrl).toContain("page=2")
     unmount()
   })
 })
 
 // ─── useList pagination ─────────────────────────────────────────────────────────
 
-describe('useList pagination', () => {
-  it('appends page and pageSize when page is provided as number', async () => {
-    let capturedUrl = ''
+describe("useList pagination", () => {
+  it("appends page and pageSize when page is provided as number", async () => {
+    let capturedUrl = ""
     const users = defineFeature<UserValues>({
-      name: 'users-page-num',
+      name: "users-page-num",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: (async (url: string) => {
         capturedUrl = url
-        return new Response('[]', { status: 200 })
+        return new Response("[]", { status: 200 })
       }) as typeof fetch,
     })
 
     const client = new QueryClient({
       defaultOptions: { queries: { retry: false } },
     })
-    const { unmount } = mountWith(client, () =>
-      users.useList({ page: 1, pageSize: 10 }),
-    )
+    const { unmount } = mountWith(client, () => users.useList({ page: 1, pageSize: 10 }))
     await new Promise((r) => setTimeout(r, 50))
-    expect(capturedUrl).toContain('page=1')
-    expect(capturedUrl).toContain('pageSize=10')
+    expect(capturedUrl).toContain("page=1")
+    expect(capturedUrl).toContain("pageSize=10")
     unmount()
   })
 
-  it('defaults pageSize to 20 when page is provided', async () => {
-    let capturedUrl = ''
+  it("defaults pageSize to 20 when page is provided", async () => {
+    let capturedUrl = ""
     const users = defineFeature<UserValues>({
-      name: 'users-page-default-size',
+      name: "users-page-default-size",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: (async (url: string) => {
         capturedUrl = url
-        return new Response('[]', { status: 200 })
+        return new Response("[]", { status: 200 })
       }) as typeof fetch,
     })
 
@@ -431,20 +407,20 @@ describe('useList pagination', () => {
     })
     const { unmount } = mountWith(client, () => users.useList({ page: 3 }))
     await new Promise((r) => setTimeout(r, 50))
-    expect(capturedUrl).toContain('page=3')
-    expect(capturedUrl).toContain('pageSize=20')
+    expect(capturedUrl).toContain("page=3")
+    expect(capturedUrl).toContain("pageSize=20")
     unmount()
   })
 
-  it('accepts reactive page signal', async () => {
+  it("accepts reactive page signal", async () => {
     const capturedUrls: string[] = []
     const users = defineFeature<UserValues>({
-      name: 'users-page-signal',
+      name: "users-page-signal",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: (async (url: string) => {
         capturedUrls.push(url)
-        return new Response('[]', { status: 200 })
+        return new Response("[]", { status: 200 })
       }) as typeof fetch,
     })
 
@@ -452,21 +428,19 @@ describe('useList pagination', () => {
     const client = new QueryClient({
       defaultOptions: { queries: { retry: false } },
     })
-    const { unmount } = mountWith(client, () =>
-      users.useList({ page, pageSize: 5 }),
-    )
+    const { unmount } = mountWith(client, () => users.useList({ page, pageSize: 5 }))
     await new Promise((r) => setTimeout(r, 50))
-    expect(capturedUrls.some((u) => u.includes('page=1'))).toBe(true)
+    expect(capturedUrls.some((u) => u.includes("page=1"))).toBe(true)
     unmount()
   })
 
-  it('includes page in query key for independent caching', () => {
+  it("includes page in query key for independent caching", () => {
     const users = defineFeature<UserValues>({
-      name: 'users-page-key',
+      name: "users-page-key",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: (async () => {
-        return new Response('[]', { status: 200 })
+        return new Response("[]", { status: 200 })
       }) as typeof fetch,
     })
 
@@ -479,21 +453,21 @@ describe('useList pagination', () => {
 
 // ─── useById ────────────────────────────────────────────────────────────────────
 
-describe('useById', () => {
-  it('fetches single item by ID', async () => {
+describe("useById", () => {
+  it("fetches single item by ID", async () => {
     const mockUser = {
-      name: 'Alice',
-      email: 'a@t.com',
-      role: 'admin',
+      name: "Alice",
+      email: "a@t.com",
+      role: "admin",
       active: true,
     }
 
     const users = defineFeature<UserValues>({
-      name: 'users-by-id',
+      name: "users-by-id",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: createMockFetch({
-        'GET /api/users/1': { body: mockUser },
+        "GET /api/users/1": { body: mockUser },
       }) as typeof fetch,
     })
 
@@ -509,23 +483,21 @@ describe('useById', () => {
 
 // ─── useCreate ──────────────────────────────────────────────────────────────────
 
-describe('useCreate', () => {
-  it('posts to API', async () => {
+describe("useCreate", () => {
+  it("posts to API", async () => {
     const users = defineFeature<UserValues>({
-      name: 'users-create',
+      name: "users-create",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: createMockFetch({
-        'POST /api/users': { body: { name: 'Created' } },
+        "POST /api/users": { body: { name: "Created" } },
       }) as typeof fetch,
     })
 
     const client = new QueryClient()
-    const { result: mutation, unmount } = mountWith(client, () =>
-      users.useCreate(),
-    )
+    const { result: mutation, unmount } = mountWith(client, () => users.useCreate())
 
-    mutation.mutate({ name: 'New' })
+    mutation.mutate({ name: "New" })
     await new Promise((r) => setTimeout(r, 50))
     expect(mutation.isSuccess()).toBe(true)
     unmount()
@@ -534,32 +506,30 @@ describe('useCreate', () => {
 
 // ─── useUpdate ──────────────────────────────────────────────────────────────────
 
-describe('useUpdate', () => {
-  it('sends PUT with id and data', async () => {
-    let capturedUrl = ''
-    let capturedMethod = ''
+describe("useUpdate", () => {
+  it("sends PUT with id and data", async () => {
+    let capturedUrl = ""
+    let capturedMethod = ""
 
     const users = defineFeature<UserValues>({
-      name: 'users-update',
+      name: "users-update",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: (async (url: string, init?: RequestInit) => {
         capturedUrl = url
-        capturedMethod = init?.method ?? 'GET'
-        return new Response('{}', { status: 200 })
+        capturedMethod = init?.method ?? "GET"
+        return new Response("{}", { status: 200 })
       }) as typeof fetch,
     })
 
     const client = new QueryClient()
-    const { result: mutation, unmount } = mountWith(client, () =>
-      users.useUpdate(),
-    )
+    const { result: mutation, unmount } = mountWith(client, () => users.useUpdate())
 
-    mutation.mutate({ id: 42, data: { name: 'Updated' } })
+    mutation.mutate({ id: 42, data: { name: "Updated" } })
     await new Promise((r) => setTimeout(r, 50))
 
-    expect(capturedUrl).toBe('/api/users/42')
-    expect(capturedMethod).toBe('PUT')
+    expect(capturedUrl).toBe("/api/users/42")
+    expect(capturedMethod).toBe("PUT")
     expect(mutation.isSuccess()).toBe(true)
     unmount()
   })
@@ -567,36 +537,36 @@ describe('useUpdate', () => {
 
 // ─── Optimistic updates ─────────────────────────────────────────────────────────
 
-describe('optimistic updates', () => {
-  it('updates cache optimistically before server responds', async () => {
+describe("optimistic updates", () => {
+  it("updates cache optimistically before server responds", async () => {
     let resolveUpdate: ((value: Response) => void) | undefined
     const mockUser = {
       id: 1,
-      name: 'Alice',
-      email: 'a@t.com',
-      role: 'admin',
+      name: "Alice",
+      email: "a@t.com",
+      role: "admin",
       active: true,
     }
 
     const users = defineFeature<UserValues & { id: number }>({
-      name: 'users-optimistic',
+      name: "users-optimistic",
       schema: z.object({
         id: z.number(),
         name: z.string().min(2),
         email: z.string().email(),
-        role: z.enum(['admin', 'editor', 'viewer']),
+        role: z.enum(["admin", "editor", "viewer"]),
         active: z.boolean(),
       }),
-      api: '/api/users',
+      api: "/api/users",
       fetcher: (async (_url: string, init?: RequestInit) => {
-        if (init?.method === 'PUT') {
+        if (init?.method === "PUT") {
           return new Promise<Response>((resolve) => {
             resolveUpdate = resolve
           })
         }
         return new Response(JSON.stringify(mockUser), {
           status: 200,
-          headers: { 'Content-Type': 'application/json' },
+          headers: { "Content-Type": "application/json" },
         })
       }) as typeof fetch,
     })
@@ -606,28 +576,23 @@ describe('optimistic updates', () => {
     })
 
     // Pre-populate cache
-    client.setQueryData(['users-optimistic', 1], mockUser)
+    client.setQueryData(["users-optimistic", 1], mockUser)
 
-    const { result: mutation, unmount } = mountWith(client, () =>
-      users.useUpdate(),
-    )
+    const { result: mutation, unmount } = mountWith(client, () => users.useUpdate())
 
     // Start mutation — should optimistically update cache
-    mutation.mutate({ id: 1, data: { name: 'Bob' } })
+    mutation.mutate({ id: 1, data: { name: "Bob" } })
     await new Promise((r) => setTimeout(r, 20))
 
     // Cache should be optimistically updated
-    const cached = client.getQueryData(['users-optimistic', 1]) as Record<
-      string,
-      unknown
-    >
-    expect(cached.name).toBe('Bob')
+    const cached = client.getQueryData(["users-optimistic", 1]) as Record<string, unknown>
+    expect(cached.name).toBe("Bob")
 
     // Resolve server response
     resolveUpdate!(
-      new Response(JSON.stringify({ ...mockUser, name: 'Bob' }), {
+      new Response(JSON.stringify({ ...mockUser, name: "Bob" }), {
         status: 200,
-        headers: { 'Content-Type': 'application/json' },
+        headers: { "Content-Type": "application/json" },
       }),
     )
     await new Promise((r) => setTimeout(r, 50))
@@ -635,35 +600,35 @@ describe('optimistic updates', () => {
     unmount()
   })
 
-  it('rolls back cache on server error', async () => {
+  it("rolls back cache on server error", async () => {
     const mockUser = {
       id: 2,
-      name: 'Alice',
-      email: 'a@t.com',
-      role: 'admin',
+      name: "Alice",
+      email: "a@t.com",
+      role: "admin",
       active: true,
     }
 
     const users = defineFeature<UserValues & { id: number }>({
-      name: 'users-rollback',
+      name: "users-rollback",
       schema: z.object({
         id: z.number(),
         name: z.string().min(2),
         email: z.string().email(),
-        role: z.enum(['admin', 'editor', 'viewer']),
+        role: z.enum(["admin", "editor", "viewer"]),
         active: z.boolean(),
       }),
-      api: '/api/users',
+      api: "/api/users",
       fetcher: (async (_url: string, init?: RequestInit) => {
-        if (init?.method === 'PUT') {
-          return new Response(JSON.stringify({ message: 'Server error' }), {
+        if (init?.method === "PUT") {
+          return new Response(JSON.stringify({ message: "Server error" }), {
             status: 500,
-            headers: { 'Content-Type': 'application/json' },
+            headers: { "Content-Type": "application/json" },
           })
         }
         return new Response(JSON.stringify(mockUser), {
           status: 200,
-          headers: { 'Content-Type': 'application/json' },
+          headers: { "Content-Type": "application/json" },
         })
       }) as typeof fetch,
     })
@@ -673,21 +638,16 @@ describe('optimistic updates', () => {
     })
 
     // Pre-populate cache
-    client.setQueryData(['users-rollback', 2], mockUser)
+    client.setQueryData(["users-rollback", 2], mockUser)
 
-    const { result: mutation, unmount } = mountWith(client, () =>
-      users.useUpdate(),
-    )
+    const { result: mutation, unmount } = mountWith(client, () => users.useUpdate())
 
-    mutation.mutate({ id: 2, data: { name: 'Should rollback' } })
+    mutation.mutate({ id: 2, data: { name: "Should rollback" } })
     await new Promise((r) => setTimeout(r, 100))
 
     // Should roll back to original
-    const cached = client.getQueryData(['users-rollback', 2]) as Record<
-      string,
-      unknown
-    >
-    expect(cached.name).toBe('Alice')
+    const cached = client.getQueryData(["users-rollback", 2]) as Record<string, unknown>
+    expect(cached.name).toBe("Alice")
     expect(mutation.isError()).toBe(true)
     unmount()
   })
@@ -695,32 +655,30 @@ describe('optimistic updates', () => {
 
 // ─── useDelete ──────────────────────────────────────────────────────────────────
 
-describe('useDelete', () => {
-  it('sends DELETE with id', async () => {
-    let capturedUrl = ''
-    let capturedMethod = ''
+describe("useDelete", () => {
+  it("sends DELETE with id", async () => {
+    let capturedUrl = ""
+    let capturedMethod = ""
 
     const users = defineFeature<UserValues>({
-      name: 'users-delete',
+      name: "users-delete",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: (async (url: string, init?: RequestInit) => {
         capturedUrl = url
-        capturedMethod = init?.method ?? 'GET'
+        capturedMethod = init?.method ?? "GET"
         return new Response(null, { status: 204 })
       }) as typeof fetch,
     })
 
     const client = new QueryClient()
-    const { result: mutation, unmount } = mountWith(client, () =>
-      users.useDelete(),
-    )
+    const { result: mutation, unmount } = mountWith(client, () => users.useDelete())
 
     mutation.mutate(7)
     await new Promise((r) => setTimeout(r, 50))
 
-    expect(capturedUrl).toBe('/api/users/7')
-    expect(capturedMethod).toBe('DELETE')
+    expect(capturedUrl).toBe("/api/users/7")
+    expect(capturedMethod).toBe("DELETE")
     expect(mutation.isSuccess()).toBe(true)
     unmount()
   })
@@ -728,71 +686,71 @@ describe('useDelete', () => {
 
 // ─── useForm ────────────────────────────────────────────────────────────────────
 
-describe('useForm', () => {
-  it('creates form with schema validation', () => {
+describe("useForm", () => {
+  it("creates form with schema validation", () => {
     const users = defineFeature<UserValues>({
-      name: 'users-form',
+      name: "users-form",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
     })
 
     const client = new QueryClient()
     const { result: form, unmount } = mountWith(client, () => users.useForm())
 
-    expect(typeof form.handleSubmit).toBe('function')
-    expect(typeof form.register).toBe('function')
+    expect(typeof form.handleSubmit).toBe("function")
+    expect(typeof form.register).toBe("function")
     unmount()
   })
 
-  it('submits as POST in create mode', async () => {
-    let capturedMethod = ''
+  it("submits as POST in create mode", async () => {
+    let capturedMethod = ""
     const users = defineFeature<UserValues>({
-      name: 'users-form-post',
+      name: "users-form-post",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: (async (_url: string, init?: RequestInit) => {
-        capturedMethod = init?.method ?? 'GET'
-        return new Response('{}', { status: 200 })
+        capturedMethod = init?.method ?? "GET"
+        return new Response("{}", { status: 200 })
       }) as typeof fetch,
     })
 
     const client = new QueryClient()
     const { result: form, unmount } = mountWith(client, () => users.useForm())
 
-    form.setFieldValue('name', 'Al')
-    form.setFieldValue('email', 'a@t.com')
-    form.setFieldValue('role', 'admin')
-    form.setFieldValue('active', true)
+    form.setFieldValue("name", "Al")
+    form.setFieldValue("email", "a@t.com")
+    form.setFieldValue("role", "admin")
+    form.setFieldValue("active", true)
     await form.handleSubmit()
     await new Promise((r) => setTimeout(r, 50))
 
-    expect(capturedMethod).toBe('POST')
+    expect(capturedMethod).toBe("POST")
     unmount()
   })
 
-  it('submits as PUT in edit mode', async () => {
-    let capturedMethod = ''
-    let capturedUrl = ''
+  it("submits as PUT in edit mode", async () => {
+    let capturedMethod = ""
+    let capturedUrl = ""
     const users = defineFeature<UserValues>({
-      name: 'users-form-put',
+      name: "users-form-put",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: (async (url: string, init?: RequestInit) => {
         capturedUrl = url
-        capturedMethod = init?.method ?? 'GET'
-        return new Response('{}', { status: 200 })
+        capturedMethod = init?.method ?? "GET"
+        return new Response("{}", { status: 200 })
       }) as typeof fetch,
     })
 
     const client = new QueryClient()
     const { result: form, unmount } = mountWith(client, () =>
       users.useForm({
-        mode: 'edit',
+        mode: "edit",
         id: 42,
         initialValues: {
-          name: 'Al',
-          email: 'a@t.com',
-          role: 'admin',
+          name: "Al",
+          email: "a@t.com",
+          role: "admin",
           active: true,
         },
       }),
@@ -804,19 +762,19 @@ describe('useForm', () => {
     await form.handleSubmit()
     await new Promise((r) => setTimeout(r, 50))
 
-    expect(capturedMethod).toBe('PUT')
-    expect(capturedUrl).toBe('/api/users/42')
+    expect(capturedMethod).toBe("PUT")
+    expect(capturedUrl).toBe("/api/users/42")
     unmount()
   })
 
-  it('calls onSuccess callback', async () => {
+  it("calls onSuccess callback", async () => {
     let successResult: unknown = null
     const users = defineFeature<UserValues>({
-      name: 'users-form-cb',
+      name: "users-form-cb",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: createMockFetch({
-        'POST /api/users': { body: { id: 1 } },
+        "POST /api/users": { body: { id: 1 } },
       }) as typeof fetch,
     })
 
@@ -829,10 +787,10 @@ describe('useForm', () => {
       }),
     )
 
-    form.setFieldValue('name', 'Al')
-    form.setFieldValue('email', 'a@t.com')
-    form.setFieldValue('role', 'admin')
-    form.setFieldValue('active', true)
+    form.setFieldValue("name", "Al")
+    form.setFieldValue("email", "a@t.com")
+    form.setFieldValue("role", "admin")
+    form.setFieldValue("active", true)
     await form.handleSubmit()
     await new Promise((r) => setTimeout(r, 50))
 
@@ -843,28 +801,28 @@ describe('useForm', () => {
 
 // ─── Auto-fetch edit form ────────────────────────────────────────────────────
 
-describe('auto-fetch edit form', () => {
-  it('populates form fields from API when mode is edit', async () => {
+describe("auto-fetch edit form", () => {
+  it("populates form fields from API when mode is edit", async () => {
     const mockUser = {
-      name: 'Alice',
-      email: 'alice@example.com',
-      role: 'admin',
+      name: "Alice",
+      email: "alice@example.com",
+      role: "admin",
       active: true,
     }
 
     const users = defineFeature<UserValues>({
-      name: 'users-form-autofetch',
+      name: "users-form-autofetch",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: createMockFetch({
-        'GET /api/users/42': { body: mockUser },
-        'PUT /api/users/42': { body: mockUser },
+        "GET /api/users/42": { body: mockUser },
+        "PUT /api/users/42": { body: mockUser },
       }) as typeof fetch,
     })
 
     const client = new QueryClient()
     const { result: form, unmount } = mountWith(client, () =>
-      users.useForm({ mode: 'edit', id: 42 }),
+      users.useForm({ mode: "edit", id: 42 }),
     )
 
     // Should be loading initially
@@ -874,26 +832,26 @@ describe('auto-fetch edit form', () => {
 
     // Should have populated values
     expect(form.isSubmitting()).toBe(false)
-    expect(form.values().name).toBe('Alice')
-    expect(form.values().email).toBe('alice@example.com')
-    expect(form.values().role).toBe('admin')
+    expect(form.values().name).toBe("Alice")
+    expect(form.values().email).toBe("alice@example.com")
+    expect(form.values().role).toBe("admin")
     expect(form.values().active).toBe(true)
     unmount()
   })
 
-  it('clears loading state on fetch error', async () => {
+  it("clears loading state on fetch error", async () => {
     const users = defineFeature<UserValues>({
-      name: 'users-form-autofetch-err',
+      name: "users-form-autofetch-err",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: createMockFetch({
-        'GET /api/users/999': { status: 404, body: { message: 'Not found' } },
+        "GET /api/users/999": { status: 404, body: { message: "Not found" } },
       }) as typeof fetch,
     })
 
     const client = new QueryClient()
     const { result: form, unmount } = mountWith(client, () =>
-      users.useForm({ mode: 'edit', id: 999 }),
+      users.useForm({ mode: "edit", id: 999 }),
     )
 
     expect(form.isSubmitting()).toBe(true)
@@ -905,18 +863,16 @@ describe('auto-fetch edit form', () => {
 
 // ─── useStore ──────────────────────────────────────────────────────────────────
 
-describe('useStore', () => {
-  it('returns a store with items, selected, and loading signals', () => {
+describe("useStore", () => {
+  it("returns a store with items, selected, and loading signals", () => {
     const users = defineFeature<UserValues>({
-      name: 'users-store',
+      name: "users-store",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
     })
 
     const client = new QueryClient()
-    const { result: storeApi, unmount } = mountWith(client, () =>
-      users.useStore(),
-    )
+    const { result: storeApi, unmount } = mountWith(client, () => users.useStore())
 
     expect(storeApi.store.items()).toEqual([])
     expect(storeApi.store.selected()).toBe(null)
@@ -924,71 +880,67 @@ describe('useStore', () => {
     unmount()
   })
 
-  it('select() finds item by id from items list', () => {
+  it("select() finds item by id from items list", () => {
     const users = defineFeature<UserValues & { id: number }>({
-      name: 'users-store-select',
+      name: "users-store-select",
       schema: z.object({
         id: z.number(),
         name: z.string().min(2),
         email: z.string().email(),
-        role: z.enum(['admin', 'editor', 'viewer']),
+        role: z.enum(["admin", "editor", "viewer"]),
         active: z.boolean(),
       }),
-      api: '/api/users',
+      api: "/api/users",
     })
 
     const client = new QueryClient()
-    const { result: storeApi, unmount } = mountWith(client, () =>
-      users.useStore(),
-    )
+    const { result: storeApi, unmount } = mountWith(client, () => users.useStore())
 
     const items = [
       {
         id: 1,
-        name: 'Alice',
-        email: 'a@t.com',
-        role: 'admin' as const,
+        name: "Alice",
+        email: "a@t.com",
+        role: "admin" as const,
         active: true,
       },
       {
         id: 2,
-        name: 'Bob',
-        email: 'b@t.com',
-        role: 'editor' as const,
+        name: "Bob",
+        email: "b@t.com",
+        role: "editor" as const,
         active: false,
       },
     ]
     storeApi.store.items.set(items)
     storeApi.store.select(2)
 
-    expect(storeApi.store.selected()?.name).toBe('Bob')
+    expect(storeApi.store.selected()?.name).toBe("Bob")
     unmount()
   })
 
-  it('select() sets null when id not found', () => {
+  it("select() sets null when id not found", () => {
     const users = defineFeature<UserValues & { id: number }>({
-      name: 'users-store-select-miss',
+      name: "users-store-select-miss",
       schema: z.object({
         id: z.number(),
         name: z.string().min(2),
         email: z.string().email(),
-        role: z.enum(['admin', 'editor', 'viewer']),
+        role: z.enum(["admin", "editor", "viewer"]),
         active: z.boolean(),
       }),
-      api: '/api/users',
+      api: "/api/users",
     })
 
     const client = new QueryClient()
-    const { result: storeApi, unmount } = mountWith(client, () =>
-      users.useStore(),
-    )
+    const { result: storeApi, unmount } = mountWith(client, () => users.useStore())
 
     storeApi.store.items.set([
       {
         id: 1,
-        name: 'Alice',
-        email: 'a@t.com',
-        role: 'admin' as const,
+        name: "Alice",
+        email: "a@t.com",
+        role: "admin" as const,
         active: true,
       },
     ])
@@ -998,30 +950,28 @@ describe('useStore', () => {
     unmount()
   })
 
-  it('clear() resets selection to null', () => {
+  it("clear() resets selection to null", () => {
     const users = defineFeature<UserValues & { id: number }>({
-      name: 'users-store-clear',
+      name: "users-store-clear",
       schema: z.object({
         id: z.number(),
         name: z.string().min(2),
         email: z.string().email(),
-        role: z.enum(['admin', 'editor', 'viewer']),
+        role: z.enum(["admin", "editor", "viewer"]),
         active: z.boolean(),
       }),
-      api: '/api/users',
+      api: "/api/users",
     })
 
     const client = new QueryClient()
-    const { result: storeApi, unmount } = mountWith(client, () =>
-      users.useStore(),
-    )
+    const { result: storeApi, unmount } = mountWith(client, () => users.useStore())
 
     storeApi.store.items.set([
       {
         id: 1,
-        name: 'Alice',
-        email: 'a@t.com',
-        role: 'admin' as const,
+        name: "Alice",
+        email: "a@t.com",
+        role: "admin" as const,
         active: true,
       },
     ])
@@ -1033,17 +983,15 @@ describe('useStore', () => {
     unmount()
   })
 
-  it('loading signal reflects loading state', () => {
+  it("loading signal reflects loading state", () => {
     const users = defineFeature<UserValues>({
-      name: 'users-store-loading',
+      name: "users-store-loading",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
     })
 
     const client = new QueryClient()
-    const { result: storeApi, unmount } = mountWith(client, () =>
-      users.useStore(),
-    )
+    const { result: storeApi, unmount } = mountWith(client, () => users.useStore())
 
     expect(storeApi.store.loading()).toBe(false)
     storeApi.store.loading.set(true)
@@ -1051,20 +999,16 @@ describe('useStore', () => {
     unmount()
   })
 
-  it('is singleton — same store returned on multiple calls', () => {
+  it("is singleton — same store returned on multiple calls", () => {
     const users = defineFeature<UserValues>({
-      name: 'users-store-singleton',
+      name: "users-store-singleton",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
     })
 
     const client = new QueryClient()
-    const { result: store1, unmount: unmount1 } = mountWith(client, () =>
-      users.useStore(),
-    )
-    const { result: store2, unmount: unmount2 } = mountWith(client, () =>
-      users.useStore(),
-    )
+    const { result: store1, unmount: unmount1 } = mountWith(client, () => users.useStore())
+    const { result: store2, unmount: unmount2 } = mountWith(client, () => users.useStore())
 
     expect(store1.id).toBe(store2.id)
     store1.store.loading.set(true)
@@ -1076,63 +1020,58 @@ describe('useStore', () => {
 
 // ─── useTable ───────────────────────────────────────────────────────────────────
 
-describe('useTable', () => {
-  it('creates table with schema-inferred columns', () => {
+describe("useTable", () => {
+  it("creates table with schema-inferred columns", () => {
     const users = defineFeature<UserValues>({
-      name: 'users-table',
+      name: "users-table",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
     })
 
-    const data: UserValues[] = [
-      { name: 'Alice', email: 'a@t.com', role: 'admin', active: true },
-    ]
+    const data: UserValues[] = [{ name: "Alice", email: "a@t.com", role: "admin", active: true }]
 
     const client = new QueryClient()
     const { result, unmount } = mountWith(client, () => users.useTable(data))
 
     expect(result.columns.length).toBeGreaterThan(0)
-    expect(result.columns[0]!.name).toBe('name')
-    expect(result.columns[0]!.label).toBe('Name')
+    expect(result.columns[0]!.name).toBe("name")
+    expect(result.columns[0]!.label).toBe("Name")
     expect(result.table().getRowModel().rows).toHaveLength(1)
     unmount()
   })
 
-  it('filters columns by name', () => {
+  it("filters columns by name", () => {
     const users = defineFeature<UserValues>({
-      name: 'users-table-cols',
+      name: "users-table-cols",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
     })
 
     const client = new QueryClient()
     const { result, unmount } = mountWith(client, () =>
-      users.useTable(
-        [{ name: 'Alice', email: 'a@t.com', role: 'admin', active: true }],
-        { columns: ['name', 'email'] },
-      ),
+      users.useTable([{ name: "Alice", email: "a@t.com", role: "admin", active: true }], {
+        columns: ["name", "email"],
+      }),
     )
 
     expect(result.columns).toHaveLength(2)
-    expect(result.columns.map((c) => c.name)).toEqual(['name', 'email'])
+    expect(result.columns.map((c) => c.name)).toEqual(["name", "email"])
     unmount()
   })
 
-  it('accepts reactive data function', () => {
+  it("accepts reactive data function", () => {
     const users = defineFeature<UserValues>({
-      name: 'users-table-fn',
+      name: "users-table-fn",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
     })
 
     const data = signal<UserValues[]>([
-      { name: 'Alice', email: 'a@t.com', role: 'admin', active: true },
+      { name: "Alice", email: "a@t.com", role: "admin", active: true },
     ])
 
     const client = new QueryClient()
-    const { result, unmount } = mountWith(client, () =>
-      users.useTable(() => data()),
-    )
+    const { result, unmount } = mountWith(client, () => users.useTable(() => data()))
 
     expect(result.table().getRowModel().rows).toHaveLength(1)
     unmount()
@@ -1141,45 +1080,43 @@ describe('useTable', () => {
 
 // ─── useSearch ──────────────────────────────────────────────────────────────────
 
-describe('useSearch', () => {
-  it('passes search term as query param', async () => {
-    let capturedUrl = ''
+describe("useSearch", () => {
+  it("passes search term as query param", async () => {
+    let capturedUrl = ""
     const users = defineFeature<UserValues>({
-      name: 'users-search',
+      name: "users-search",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: (async (url: string) => {
         capturedUrl = url
-        return new Response('[]', { status: 200 })
+        return new Response("[]", { status: 200 })
       }) as typeof fetch,
     })
 
-    const term = signal('alice')
+    const term = signal("alice")
     const client = new QueryClient({
       defaultOptions: { queries: { retry: false } },
     })
     const { unmount } = mountWith(client, () => users.useSearch(term))
 
     await new Promise((r) => setTimeout(r, 50))
-    expect(capturedUrl).toContain('q=alice')
+    expect(capturedUrl).toContain("q=alice")
     unmount()
   })
 
-  it('disables query when search term is empty', () => {
+  it("disables query when search term is empty", () => {
     const users = defineFeature<UserValues>({
-      name: 'users-search-empty',
+      name: "users-search-empty",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: (() => {
-        throw new Error('Should not fetch')
+        throw new Error("Should not fetch")
       }) as typeof fetch,
     })
 
-    const term = signal('')
+    const term = signal("")
     const client = new QueryClient()
-    const { result: query, unmount } = mountWith(client, () =>
-      users.useSearch(term),
-    )
+    const { result: query, unmount } = mountWith(client, () => users.useSearch(term))
 
     expect(query.isPending()).toBe(true)
     expect(query.isFetching()).toBe(false)
@@ -1189,14 +1126,14 @@ describe('useSearch', () => {
 
 // ─── Error handling ────────────────────────────────────────────────────────────
 
-describe('error handling', () => {
-  it('handles API errors in useList', async () => {
+describe("error handling", () => {
+  it("handles API errors in useList", async () => {
     const users = defineFeature<UserValues>({
-      name: 'users-err',
+      name: "users-err",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: createMockFetch({
-        'GET /api/users': { status: 500, body: { message: 'Server error' } },
+        "GET /api/users": { status: 500, body: { message: "Server error" } },
       }) as typeof fetch,
     })
 
@@ -1210,67 +1147,65 @@ describe('error handling', () => {
     unmount()
   })
 
-  it('parses structured error body from API', async () => {
+  it("parses structured error body from API", async () => {
     const users = defineFeature<UserValues>({
-      name: 'users-err-struct',
+      name: "users-err-struct",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: createMockFetch({
-        'POST /api/users': {
+        "POST /api/users": {
           status: 422,
-          body: { message: 'Validation failed', errors: { email: 'Taken' } },
+          body: { message: "Validation failed", errors: { email: "Taken" } },
         },
       }) as typeof fetch,
     })
 
     const client = new QueryClient()
-    const { result: mutation, unmount } = mountWith(client, () =>
-      users.useCreate(),
-    )
+    const { result: mutation, unmount } = mountWith(client, () => users.useCreate())
 
-    mutation.mutate({ name: 'Test' })
+    mutation.mutate({ name: "Test" })
     await new Promise((r) => setTimeout(r, 50))
 
     expect(mutation.isError()).toBe(true)
     const err = mutation.error() as Error & { errors?: unknown }
-    expect(err.message).toBe('Validation failed')
-    expect(err.errors).toEqual({ email: 'Taken' })
+    expect(err.message).toBe("Validation failed")
+    expect(err.errors).toEqual({ email: "Taken" })
     unmount()
   })
 })
 
 // ─── References ─────────────────────────────────────────────────────────────────
 
-describe('reference', () => {
-  it('creates a reference schema object', () => {
+describe("reference", () => {
+  it("creates a reference schema object", () => {
     const users = defineFeature<UserValues>({
-      name: 'users-ref',
+      name: "users-ref",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
     })
 
     const ref = reference(users)
     expect(isReference(ref)).toBe(true)
-    expect(ref._featureName).toBe('users-ref')
+    expect(ref._featureName).toBe("users-ref")
   })
 
-  it('validates string and number IDs', () => {
+  it("validates string and number IDs", () => {
     const users = defineFeature<UserValues>({
-      name: 'users-ref-validate',
+      name: "users-ref-validate",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
     })
 
     const ref = reference(users)
     expect(ref.safeParse(42).success).toBe(true)
-    expect(ref.safeParse('abc-123').success).toBe(true)
+    expect(ref.safeParse("abc-123").success).toBe(true)
     expect(ref.safeParse(null).success).toBe(false)
     expect(ref.safeParse(undefined).success).toBe(false)
     expect(ref.safeParse({}).success).toBe(false)
   })
 
-  it('safeParseAsync works the same as safeParse', async () => {
-    const ref = reference({ name: 'test' })
+  it("safeParseAsync works the same as safeParse", async () => {
+    const ref = reference({ name: "test" })
     const result = await ref.safeParseAsync(42)
     expect(result.success).toBe(true)
 
@@ -1278,20 +1213,20 @@ describe('reference', () => {
     expect(fail.success).toBe(false)
   })
 
-  it('isReference returns false for non-reference objects', () => {
+  it("isReference returns false for non-reference objects", () => {
     expect(isReference(null)).toBe(false)
     expect(isReference(undefined)).toBe(false)
     expect(isReference(42)).toBe(false)
-    expect(isReference('string')).toBe(false)
+    expect(isReference("string")).toBe(false)
     expect(isReference({})).toBe(false)
     expect(isReference(z.string())).toBe(false)
   })
 
-  it('reference fields detected in schema introspection', () => {
+  it("reference fields detected in schema introspection", () => {
     const users = defineFeature<UserValues>({
-      name: 'users-ref-introspect',
+      name: "users-ref-introspect",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
     })
 
     const postSchema = z.object({
@@ -1301,63 +1236,63 @@ describe('reference', () => {
     })
 
     const fields = extractFields(postSchema)
-    const authorField = fields.find((f) => f.name === 'authorId')
+    const authorField = fields.find((f) => f.name === "authorId")
     expect(authorField).toBeDefined()
-    expect(authorField!.type).toBe('reference')
-    expect(authorField!.referenceTo).toBe('users-ref-introspect')
+    expect(authorField!.type).toBe("reference")
+    expect(authorField!.referenceTo).toBe("users-ref-introspect")
   })
 
-  it('reference fields in defineFeature schema produce reference FieldInfo', () => {
+  it("reference fields in defineFeature schema produce reference FieldInfo", () => {
     const users = defineFeature<UserValues>({
-      name: 'users-ref-in-feat',
+      name: "users-ref-in-feat",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
     })
 
     type PostValues = { title: string; body: string; authorId: string }
     const posts = defineFeature<PostValues>({
-      name: 'posts-ref',
+      name: "posts-ref",
       schema: z.object({
         title: z.string(),
         body: z.string(),
         authorId: reference(users) as any,
       }),
-      api: '/api/posts',
+      api: "/api/posts",
     })
 
-    const authorField = posts.fields.find((f) => f.name === 'authorId')
+    const authorField = posts.fields.find((f) => f.name === "authorId")
     expect(authorField).toBeDefined()
-    expect(authorField!.type).toBe('reference')
-    expect(authorField!.referenceTo).toBe('users-ref-in-feat')
+    expect(authorField!.type).toBe("reference")
+    expect(authorField!.referenceTo).toBe("users-ref-in-feat")
   })
 })
 
 // ─── Edge case coverage ────────────────────────────────────────────────────────
 
-describe('edge cases', () => {
-  it('defineFeature works without a Zod schema (no validation)', () => {
+describe("edge cases", () => {
+  it("defineFeature works without a Zod schema (no validation)", () => {
     const items = defineFeature<{ title: string }>({
-      name: 'items-no-zod',
-      schema: { notAZodSchema: true },
-      api: '/api/items',
+      name: "items-no-zod",
+      schema: { notAZodSchema: true } as { _output?: { title: string } },
+      api: "/api/items",
     })
 
     const client = new QueryClient()
     const { result: form, unmount } = mountWith(client, () => items.useForm())
-    expect(typeof form.handleSubmit).toBe('function')
+    expect(typeof form.handleSubmit).toBe("function")
     unmount()
   })
 
-  it('useForm onError callback fires on submit failure', async () => {
+  it("useForm onError callback fires on submit failure", async () => {
     let caughtError: unknown = null
     const users = defineFeature<UserValues>({
-      name: 'users-form-onerror',
+      name: "users-form-onerror",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
       fetcher: createMockFetch({
-        'POST /api/users': {
+        "POST /api/users": {
           status: 500,
-          body: { message: 'Server broke' },
+          body: { message: "Server broke" },
         },
       }) as typeof fetch,
     })
@@ -1371,10 +1306,10 @@ describe('edge cases', () => {
       }),
     )
 
-    form.setFieldValue('name', 'Al')
-    form.setFieldValue('email', 'a@t.com')
-    form.setFieldValue('role', 'admin')
-    form.setFieldValue('active', true)
+    form.setFieldValue("name", "Al")
+    form.setFieldValue("email", "a@t.com")
+    form.setFieldValue("role", "admin")
+    form.setFieldValue("active", true)
 
     try {
       await form.handleSubmit()
@@ -1387,32 +1322,32 @@ describe('edge cases', () => {
     unmount()
   })
 
-  it('useTable sorting via direct state object (non-function updater)', () => {
+  it("useTable sorting via direct state object (non-function updater)", () => {
     const users = defineFeature<UserValues>({
-      name: 'users-table-sort-direct',
+      name: "users-table-sort-direct",
       schema: userSchema,
-      api: '/api/users',
+      api: "/api/users",
     })
 
     const data: UserValues[] = [
-      { name: 'Bob', email: 'b@t.com', role: 'editor', active: true },
-      { name: 'Alice', email: 'a@t.com', role: 'admin', active: true },
+      { name: "Bob", email: "b@t.com", role: "editor", active: true },
+      { name: "Alice", email: "a@t.com", role: "admin", active: true },
     ]
 
     const client = new QueryClient()
     const { result, unmount } = mountWith(client, () => users.useTable(data))
 
     // Trigger sorting via the table's toggle handler (function updater)
-    result.table().getColumn('name')!.toggleSorting(false)
+    result.table().getColumn("name")!.toggleSorting(false)
     expect(result.sorting().length).toBe(1)
 
     // Also set sorting directly (non-function updater path)
-    result.sorting.set([{ id: 'email', desc: true }])
-    expect(result.sorting()).toEqual([{ id: 'email', desc: true }])
+    result.sorting.set([{ id: "email", desc: true }])
+    expect(result.sorting()).toEqual([{ id: "email", desc: true }])
 
     // Set globalFilter directly
-    result.globalFilter.set('alice')
-    expect(result.globalFilter()).toBe('alice')
+    result.globalFilter.set("alice")
+    expect(result.globalFilter()).toBe("alice")
 
     unmount()
   })