@pyreon/validation 0.11.5 → 0.11.6

package/README.md

@@ -11,9 +11,9 @@ bun add @pyreon/validation
 ## Quick Start
 
 ```ts
-import { z } from "zod"
-import { useForm } from "@pyreon/form"
-import { zodSchema } from "@pyreon/validation"
+import { z } from 'zod'
+import { useForm } from '@pyreon/form'
+import { zodSchema } from '@pyreon/validation'
 
 const schema = z.object({
   email: z.string().email(),
@@ -21,7 +21,7 @@ const schema = z.object({
 })
 
 const form = useForm({
-  initialValues: { email: "", age: 0 },
+  initialValues: { email: '', age: 0 },
   schema: zodSchema(schema),
   onSubmit: async (values) => console.log(values),
 })
@@ -35,9 +35,9 @@ Each adapter comes in two flavors: **schema-level** (validates the whole form) a
 
 Create a form-level schema validator from a Zod schema. Uses `safeParseAsync` internally — supports both sync and async refinements. Duck-typed to work with Zod v3 and v4.
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| `schema` | Zod schema | Any Zod object schema with `safeParse`/`safeParseAsync` |
+| Parameter | Type       | Description                                             |
+| --------- | ---------- | ------------------------------------------------------- |
+| `schema`  | Zod schema | Any Zod object schema with `safeParse`/`safeParseAsync` |
 
 **Returns:** `SchemaValidateFn<TValues>`
 
@@ -57,9 +57,9 @@ const form = useForm({
 
 Create a single-field validator from a Zod schema. Returns the first error message on failure.
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| `schema` | Zod schema | Any Zod schema (string, number, etc.) |
+| Parameter | Type       | Description                           |
+| --------- | ---------- | ------------------------------------- |
+| `schema`  | Zod schema | Any Zod schema (string, number, etc.) |
 
 **Returns:** `ValidateFn<T>`
 
@@ -77,10 +77,10 @@ const form = useForm({
 
 Create a form-level schema validator from a Valibot schema. Valibot uses standalone functions, so you must pass the parse function.
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| `schema` | Valibot schema | Any Valibot object schema |
-| `safeParseFn` | `Function` | `v.safeParse` or `v.safeParseAsync` from valibot |
+| Parameter     | Type           | Description                                      |
+| ------------- | -------------- | ------------------------------------------------ |
+| `schema`      | Valibot schema | Any Valibot object schema                        |
+| `safeParseFn` | `Function`     | `v.safeParse` or `v.safeParseAsync` from valibot |
 
 **Returns:** `SchemaValidateFn<TValues>`
 
@@ -103,10 +103,10 @@ const form = useForm({
 
 Create a single-field validator from a Valibot schema.
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| `schema` | Valibot schema | Any Valibot schema |
-| `safeParseFn` | `Function` | `v.safeParse` or `v.safeParseAsync` from valibot |
+| Parameter     | Type           | Description                                      |
+| ------------- | -------------- | ------------------------------------------------ |
+| `schema`      | Valibot schema | Any Valibot schema                               |
+| `safeParseFn` | `Function`     | `v.safeParse` or `v.safeParseAsync` from valibot |
 
 **Returns:** `ValidateFn<T>`
 
@@ -120,9 +120,9 @@ validators: {
 
 Create a form-level schema validator from an ArkType schema. ArkType validation is synchronous.
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| `schema` | ArkType `Type` | Any callable ArkType type |
+| Parameter | Type           | Description               |
+| --------- | -------------- | ------------------------- |
+| `schema`  | ArkType `Type` | Any callable ArkType type |
 
 **Returns:** `SchemaValidateFn<TValues>`
 
@@ -142,9 +142,9 @@ const form = useForm({
 
 Create a single-field validator from an ArkType schema.
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| `schema` | ArkType `Type` | Any callable ArkType type |
+| Parameter | Type           | Description               |
+| --------- | -------------- | ------------------------- |
+| `schema`  | ArkType `Type` | Any callable ArkType type |
 
 **Returns:** `ValidateFn<T>`
 
@@ -158,17 +158,17 @@ validators: {
 
 Convert an array of `ValidationIssue` objects into a flat field-to-error record. First error per field wins. Useful for building custom adapters.
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| `issues` | `ValidationIssue[]` | Array of `{ path: string, message: string }` |
+| Parameter | Type                | Description                                  |
+| --------- | ------------------- | -------------------------------------------- |
+| `issues`  | `ValidationIssue[]` | Array of `{ path: string, message: string }` |
 
 **Returns:** `Partial<Record<keyof TValues, ValidationError>>`
 
 ```ts
 issuesToRecord([
-  { path: "email", message: "Required" },
-  { path: "email", message: "Invalid" },  // ignored — first wins
-  { path: "age", message: "Too young" },
+  { path: 'email', message: 'Required' },
+  { path: 'email', message: 'Invalid' }, // ignored — first wins
+  { path: 'age', message: 'Too young' },
 ])
 // => { email: "Required", age: "Too young" }
 ```
@@ -180,9 +180,9 @@ issuesToRecord([
 Each adapter is available via subpath import to avoid bundling unused adapters:
 
 ```ts
-import { zodSchema } from "@pyreon/validation/zod"
-import { valibotSchema } from "@pyreon/validation/valibot"
-import { arktypeSchema } from "@pyreon/validation/arktype"
+import { zodSchema } from '@pyreon/validation/zod'
+import { valibotSchema } from '@pyreon/validation/valibot'
+import { arktypeSchema } from '@pyreon/validation/arktype'
 ```
 
 ### Mixing Field and Schema Validators
@@ -205,14 +205,14 @@ const form = useForm({
 
 ## Types
 
-| Type | Description |
-| --- | --- |
-| `ValidationIssue` | `{ path: string, message: string }` — normalized issue |
-| `SchemaAdapter<TSchema>` | Generic schema adapter factory type |
-| `FieldAdapter<TSchema>` | Generic field adapter factory type |
-| `SchemaValidateFn<TValues>` | Re-exported from `@pyreon/form` |
-| `ValidateFn<T>` | Re-exported from `@pyreon/form` |
-| `ValidationError` | Re-exported from `@pyreon/form` — `string \| undefined` |
+| Type                        | Description                                             |
+| --------------------------- | ------------------------------------------------------- |
+| `ValidationIssue`           | `{ path: string, message: string }` — normalized issue  |
+| `SchemaAdapter<TSchema>`    | Generic schema adapter factory type                     |
+| `FieldAdapter<TSchema>`     | Generic field adapter factory type                      |
+| `SchemaValidateFn<TValues>` | Re-exported from `@pyreon/form`                         |
+| `ValidateFn<T>`             | Re-exported from `@pyreon/form`                         |
+| `ValidationError`           | Re-exported from `@pyreon/form` — `string \| undefined` |
 
 ## Gotchas
 

package/lib/arktype.js.map

@@ -1 +1 @@
-{"version":3,"file":"arktype.js","names":[],"sources":["../src/utils.ts","../src/arktype.ts"],"sourcesContent":["import type { ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\nimport { issuesToRecord } from \"./utils\"\n\n/**\n * Minimal ArkType-compatible interfaces so we don't require arktype as a hard dep.\n */\ninterface ArkError {\n  path: PropertyKey[]\n  message: string\n}\n\ninterface ArkErrors extends Array<ArkError> {\n  summary: string\n}\n\n/**\n * Internal callable interface matching ArkType's Type.\n * Not exposed publicly — consumers pass their ArkType schema directly.\n */\ntype ArkTypeCallable = (data: unknown) => unknown\n\nfunction isArkErrors(result: unknown): result is ArkErrors {\n  return Array.isArray(result) && \"summary\" in (result as object)\n}\n\nfunction arkIssuesToGeneric(errors: ArkErrors): ValidationIssue[] {\n  return errors.map((err) => ({\n    path: err.path.map(String).join(\".\"),\n    message: err.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from an ArkType schema.\n *\n * Accepts any callable ArkType `Type` instance. The schema is duck-typed —\n * no ArkType import required.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeSchema } from '@pyreon/validation/arktype'\n *\n * const schema = type({\n *   email: 'string.email',\n *   password: 'string >= 8',\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: arktypeSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeSchema<TValues extends Record<string, unknown>>(\n  schema: ArkTypeCallable,\n): SchemaValidateFn<TValues> {\n  return (values: TValues) => {\n    try {\n      const result = schema(values)\n      if (!isArkErrors(result)) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(arkIssuesToGeneric(result))\n    } catch (err) {\n      return {\n        \"\": err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from an ArkType schema.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeField } from '@pyreon/validation/arktype'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: arktypeField(type('string.email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeField<T>(schema: ArkTypeCallable): ValidateFn<T> {\n  return (value: T) => {\n    try {\n      const result = schema(value)\n      if (!isArkErrors(result)) return undefined\n      return result[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":";;;;;;AAQA,SAAgB,eACd,QACiD;CACjD,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,MAAM,MAAM;AAElB,MAAI,OAAO,SAAS,OAClB,QAAO,OAAO,MAAM;;AAGxB,QAAO;;;;;ACGT,SAAS,YAAY,QAAsC;AACzD,QAAO,MAAM,QAAQ,OAAO,IAAI,aAAc;;AAGhD,SAAS,mBAAmB,QAAsC;AAChE,QAAO,OAAO,KAAK,SAAS;EAC1B,MAAM,IAAI,KAAK,IAAI,OAAO,CAAC,KAAK,IAAI;EACpC,SAAS,IAAI;EACd,EAAE;;;;;;;;;;;;;;;;;;;;;;;AAwBL,SAAgB,cACd,QAC2B;AAC3B,SAAQ,WAAoB;AAC1B,MAAI;GACF,MAAM,SAAS,OAAO,OAAO;AAC7B,OAAI,CAAC,YAAY,OAAO,CAAE,QAAO,EAAE;AACnC,UAAO,eAAwB,mBAAmB,OAAO,CAAC;WACnD,KAAK;AACZ,UAAO,EACL,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACrD;;;;;;;;;;;;;;;;;;;AAoBP,SAAgB,aAAgB,QAAwC;AACtE,SAAQ,UAAa;AACnB,MAAI;GACF,MAAM,SAAS,OAAO,MAAM;AAC5B,OAAI,CAAC,YAAY,OAAO,CAAE,QAAO;AACjC,UAAO,OAAO,IAAI;WACX,KAAK;AACZ,UAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI"}
+{"version":3,"file":"arktype.js","names":[],"sources":["../src/utils.ts","../src/arktype.ts"],"sourcesContent":["import type { ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal ArkType-compatible interfaces so we don't require arktype as a hard dep.\n */\ninterface ArkError {\n  path: PropertyKey[]\n  message: string\n}\n\ninterface ArkErrors extends Array<ArkError> {\n  summary: string\n}\n\n/**\n * Internal callable interface matching ArkType's Type.\n * Not exposed publicly — consumers pass their ArkType schema directly.\n */\ntype ArkTypeCallable = (data: unknown) => unknown\n\nfunction isArkErrors(result: unknown): result is ArkErrors {\n  return Array.isArray(result) && 'summary' in (result as object)\n}\n\nfunction arkIssuesToGeneric(errors: ArkErrors): ValidationIssue[] {\n  return errors.map((err) => ({\n    path: err.path.map(String).join('.'),\n    message: err.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from an ArkType schema.\n *\n * Accepts any callable ArkType `Type` instance. The schema is duck-typed —\n * no ArkType import required.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeSchema } from '@pyreon/validation/arktype'\n *\n * const schema = type({\n *   email: 'string.email',\n *   password: 'string >= 8',\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: arktypeSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeSchema<TValues extends Record<string, unknown>>(\n  schema: ArkTypeCallable,\n): SchemaValidateFn<TValues> {\n  return (values: TValues) => {\n    try {\n      const result = schema(values)\n      if (!isArkErrors(result)) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(arkIssuesToGeneric(result))\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from an ArkType schema.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeField } from '@pyreon/validation/arktype'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: arktypeField(type('string.email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeField<T>(schema: ArkTypeCallable): ValidateFn<T> {\n  return (value: T) => {\n    try {\n      const result = schema(value)\n      if (!isArkErrors(result)) return undefined\n      return result[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":";;;;;;AAQA,SAAgB,eACd,QACiD;CACjD,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,MAAM,MAAM;AAElB,MAAI,OAAO,SAAS,OAClB,QAAO,OAAO,MAAM;;AAGxB,QAAO;;;;;ACGT,SAAS,YAAY,QAAsC;AACzD,QAAO,MAAM,QAAQ,OAAO,IAAI,aAAc;;AAGhD,SAAS,mBAAmB,QAAsC;AAChE,QAAO,OAAO,KAAK,SAAS;EAC1B,MAAM,IAAI,KAAK,IAAI,OAAO,CAAC,KAAK,IAAI;EACpC,SAAS,IAAI;EACd,EAAE;;;;;;;;;;;;;;;;;;;;;;;AAwBL,SAAgB,cACd,QAC2B;AAC3B,SAAQ,WAAoB;AAC1B,MAAI;GACF,MAAM,SAAS,OAAO,OAAO;AAC7B,OAAI,CAAC,YAAY,OAAO,CAAE,QAAO,EAAE;AACnC,UAAO,eAAwB,mBAAmB,OAAO,CAAC;WACnD,KAAK;AACZ,UAAO,EACL,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACrD;;;;;;;;;;;;;;;;;;;AAoBP,SAAgB,aAAgB,QAAwC;AACtE,SAAQ,UAAa;AACnB,MAAI;GACF,MAAM,SAAS,OAAO,MAAM;AAC5B,OAAI,CAAC,YAAY,OAAO,CAAE,QAAO;AACjC,UAAO,OAAO,IAAI;WACX,KAAK;AACZ,UAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI"}

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/utils.ts","../src/arktype.ts","../src/valibot.ts","../src/zod.ts"],"sourcesContent":["import type { ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\nimport { issuesToRecord } from \"./utils\"\n\n/**\n * Minimal ArkType-compatible interfaces so we don't require arktype as a hard dep.\n */\ninterface ArkError {\n  path: PropertyKey[]\n  message: string\n}\n\ninterface ArkErrors extends Array<ArkError> {\n  summary: string\n}\n\n/**\n * Internal callable interface matching ArkType's Type.\n * Not exposed publicly — consumers pass their ArkType schema directly.\n */\ntype ArkTypeCallable = (data: unknown) => unknown\n\nfunction isArkErrors(result: unknown): result is ArkErrors {\n  return Array.isArray(result) && \"summary\" in (result as object)\n}\n\nfunction arkIssuesToGeneric(errors: ArkErrors): ValidationIssue[] {\n  return errors.map((err) => ({\n    path: err.path.map(String).join(\".\"),\n    message: err.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from an ArkType schema.\n *\n * Accepts any callable ArkType `Type` instance. The schema is duck-typed —\n * no ArkType import required.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeSchema } from '@pyreon/validation/arktype'\n *\n * const schema = type({\n *   email: 'string.email',\n *   password: 'string >= 8',\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: arktypeSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeSchema<TValues extends Record<string, unknown>>(\n  schema: ArkTypeCallable,\n): SchemaValidateFn<TValues> {\n  return (values: TValues) => {\n    try {\n      const result = schema(values)\n      if (!isArkErrors(result)) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(arkIssuesToGeneric(result))\n    } catch (err) {\n      return {\n        \"\": err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from an ArkType schema.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeField } from '@pyreon/validation/arktype'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: arktypeField(type('string.email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeField<T>(schema: ArkTypeCallable): ValidateFn<T> {\n  return (value: T) => {\n    try {\n      const result = schema(value)\n      if (!isArkErrors(result)) return undefined\n      return result[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\nimport { issuesToRecord } from \"./utils\"\n\n/**\n * Minimal Valibot-compatible interfaces so we don't require valibot as a hard dep.\n */\ninterface ValibotPathItem {\n  key: string | number\n}\n\ninterface ValibotIssue {\n  path?: ValibotPathItem[]\n  message: string\n}\n\ninterface ValibotSafeParseResult {\n  success: boolean\n  output?: unknown\n  issues?: ValibotIssue[]\n}\n\n/**\n * Any function that takes (schema, input, ...rest) and returns a parse result.\n * Valibot's safeParse/safeParseAsync have generic constraints on the schema\n * parameter that can't be expressed without importing Valibot types. We accept\n * any callable and cast internally.\n */\n// biome-ignore lint/complexity/noBannedTypes: must accept any valibot parse function\ntype GenericSafeParseFn = Function\n\nfunction valibotIssuesToGeneric(issues: ValibotIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path?.map((p) => String(p.key)).join(\".\") ?? \"\",\n    message: issue.message,\n  }))\n}\n\ntype InternalParseFn = (\n  schema: unknown,\n  input: unknown,\n) => ValibotSafeParseResult | Promise<ValibotSafeParseResult>\n\n/**\n * Create a form-level schema validator from a Valibot schema.\n *\n * Valibot uses standalone functions rather than methods, so you must pass\n * the `safeParseAsync` (or `safeParse`) function from valibot.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotSchema } from '@pyreon/validation/valibot'\n *\n * const schema = v.object({\n *   email: v.pipe(v.string(), v.email()),\n *   password: v.pipe(v.string(), v.minLength(8)),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: valibotSchema(schema, v.safeParseAsync),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotSchema<TValues extends Record<string, unknown>>(\n  schema: unknown,\n  safeParseFn: GenericSafeParseFn,\n): SchemaValidateFn<TValues> {\n  const parse = safeParseFn as InternalParseFn\n  return async (values: TValues) => {\n    try {\n      const result = await parse(schema, values)\n      if (result.success) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(valibotIssuesToGeneric(result.issues ?? []))\n    } catch (err) {\n      return {\n        \"\": err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Valibot schema.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotField } from '@pyreon/validation/valibot'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotField<T>(schema: unknown, safeParseFn: GenericSafeParseFn): ValidateFn<T> {\n  const parse = safeParseFn as InternalParseFn\n  return async (value: T) => {\n    try {\n      const result = await parse(schema, value)\n      if (result.success) return undefined\n      return result.issues?.[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\nimport { issuesToRecord } from \"./utils\"\n\n/**\n * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.\n * These match Zod v3's public API surface.\n */\ninterface ZodIssue {\n  path: PropertyKey[]\n  message: string\n}\n\n/**\n * Duck-typed Zod schema interface — works with both Zod v3 and v4.\n * Inlines the result shape to avoid version-specific type mismatches.\n */\ninterface ZodSchema<T = unknown> {\n  safeParse(data: unknown): {\n    success: boolean\n    data?: T\n    error?: { issues: ZodIssue[] }\n  }\n  safeParseAsync(\n    data: unknown,\n  ): Promise<{ success: boolean; data?: T; error?: { issues: ZodIssue[] } }>\n}\n\nfunction zodIssuesToGeneric(issues: ZodIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path.map(String).join(\".\"),\n    message: issue.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from a Zod schema.\n * Supports both sync and async Zod schemas (uses `safeParseAsync`).\n *\n * @example\n * import { z } from 'zod'\n * import { zodSchema } from '@pyreon/validation/zod'\n *\n * const schema = z.object({\n *   email: z.string().email(),\n *   password: z.string().min(8),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: zodSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodSchema<TValues extends Record<string, unknown>>(\n  schema: ZodSchema<TValues>,\n): SchemaValidateFn<TValues> {\n  return async (values: TValues) => {\n    try {\n      const result = await schema.safeParseAsync(values)\n      if (result.success) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(zodIssuesToGeneric(result.error!.issues))\n    } catch (err) {\n      return {\n        \"\": err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Zod schema.\n * Supports both sync and async Zod refinements.\n *\n * @example\n * import { z } from 'zod'\n * import { zodField } from '@pyreon/validation/zod'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: zodField(z.string().email('Invalid email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodField<T>(schema: ZodSchema<T>): ValidateFn<T> {\n  return async (value: T) => {\n    try {\n      const result = await schema.safeParseAsync(value)\n      if (result.success) return undefined\n      return result.error!.issues[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/utils.ts","../src/arktype.ts","../src/valibot.ts","../src/zod.ts"],"sourcesContent":["import type { ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal ArkType-compatible interfaces so we don't require arktype as a hard dep.\n */\ninterface ArkError {\n  path: PropertyKey[]\n  message: string\n}\n\ninterface ArkErrors extends Array<ArkError> {\n  summary: string\n}\n\n/**\n * Internal callable interface matching ArkType's Type.\n * Not exposed publicly — consumers pass their ArkType schema directly.\n */\ntype ArkTypeCallable = (data: unknown) => unknown\n\nfunction isArkErrors(result: unknown): result is ArkErrors {\n  return Array.isArray(result) && 'summary' in (result as object)\n}\n\nfunction arkIssuesToGeneric(errors: ArkErrors): ValidationIssue[] {\n  return errors.map((err) => ({\n    path: err.path.map(String).join('.'),\n    message: err.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from an ArkType schema.\n *\n * Accepts any callable ArkType `Type` instance. The schema is duck-typed —\n * no ArkType import required.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeSchema } from '@pyreon/validation/arktype'\n *\n * const schema = type({\n *   email: 'string.email',\n *   password: 'string >= 8',\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: arktypeSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeSchema<TValues extends Record<string, unknown>>(\n  schema: ArkTypeCallable,\n): SchemaValidateFn<TValues> {\n  return (values: TValues) => {\n    try {\n      const result = schema(values)\n      if (!isArkErrors(result)) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(arkIssuesToGeneric(result))\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from an ArkType schema.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeField } from '@pyreon/validation/arktype'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: arktypeField(type('string.email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeField<T>(schema: ArkTypeCallable): ValidateFn<T> {\n  return (value: T) => {\n    try {\n      const result = schema(value)\n      if (!isArkErrors(result)) return undefined\n      return result[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal Valibot-compatible interfaces so we don't require valibot as a hard dep.\n */\ninterface ValibotPathItem {\n  key: string | number\n}\n\ninterface ValibotIssue {\n  path?: ValibotPathItem[]\n  message: string\n}\n\ninterface ValibotSafeParseResult {\n  success: boolean\n  output?: unknown\n  issues?: ValibotIssue[]\n}\n\n/**\n * Any function that takes (schema, input, ...rest) and returns a parse result.\n * Valibot's safeParse/safeParseAsync have generic constraints on the schema\n * parameter that can't be expressed without importing Valibot types. We accept\n * any callable and cast internally.\n */\n// biome-ignore lint/complexity/noBannedTypes: must accept any valibot parse function\ntype GenericSafeParseFn = Function\n\nfunction valibotIssuesToGeneric(issues: ValibotIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path?.map((p) => String(p.key)).join('.') ?? '',\n    message: issue.message,\n  }))\n}\n\ntype InternalParseFn = (\n  schema: unknown,\n  input: unknown,\n) => ValibotSafeParseResult | Promise<ValibotSafeParseResult>\n\n/**\n * Create a form-level schema validator from a Valibot schema.\n *\n * Valibot uses standalone functions rather than methods, so you must pass\n * the `safeParseAsync` (or `safeParse`) function from valibot.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotSchema } from '@pyreon/validation/valibot'\n *\n * const schema = v.object({\n *   email: v.pipe(v.string(), v.email()),\n *   password: v.pipe(v.string(), v.minLength(8)),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: valibotSchema(schema, v.safeParseAsync),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotSchema<TValues extends Record<string, unknown>>(\n  schema: unknown,\n  safeParseFn: GenericSafeParseFn,\n): SchemaValidateFn<TValues> {\n  const parse = safeParseFn as InternalParseFn\n  return async (values: TValues) => {\n    try {\n      const result = await parse(schema, values)\n      if (result.success) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(valibotIssuesToGeneric(result.issues ?? []))\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Valibot schema.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotField } from '@pyreon/validation/valibot'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotField<T>(schema: unknown, safeParseFn: GenericSafeParseFn): ValidateFn<T> {\n  const parse = safeParseFn as InternalParseFn\n  return async (value: T) => {\n    try {\n      const result = await parse(schema, value)\n      if (result.success) return undefined\n      return result.issues?.[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.\n * These match Zod v3's public API surface.\n */\ninterface ZodIssue {\n  path: PropertyKey[]\n  message: string\n}\n\n/**\n * Duck-typed Zod schema interface — works with both Zod v3 and v4.\n * Inlines the result shape to avoid version-specific type mismatches.\n */\ninterface ZodSchema<T = unknown> {\n  safeParse(data: unknown): {\n    success: boolean\n    data?: T\n    error?: { issues: ZodIssue[] }\n  }\n  safeParseAsync(\n    data: unknown,\n  ): Promise<{ success: boolean; data?: T; error?: { issues: ZodIssue[] } }>\n}\n\nfunction zodIssuesToGeneric(issues: ZodIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path.map(String).join('.'),\n    message: issue.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from a Zod schema.\n * Supports both sync and async Zod schemas (uses `safeParseAsync`).\n *\n * @example\n * import { z } from 'zod'\n * import { zodSchema } from '@pyreon/validation/zod'\n *\n * const schema = z.object({\n *   email: z.string().email(),\n *   password: z.string().min(8),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: zodSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodSchema<TValues extends Record<string, unknown>>(\n  schema: ZodSchema<TValues>,\n): SchemaValidateFn<TValues> {\n  return async (values: TValues) => {\n    try {\n      const result = await schema.safeParseAsync(values)\n      if (result.success) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(zodIssuesToGeneric(result.error!.issues))\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Zod schema.\n * Supports both sync and async Zod refinements.\n *\n * @example\n * import { z } from 'zod'\n * import { zodField } from '@pyreon/validation/zod'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: zodField(z.string().email('Invalid email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodField<T>(schema: ZodSchema<T>): ValidateFn<T> {\n  return async (value: T) => {\n    try {\n      const result = await schema.safeParseAsync(value)\n      if (result.success) return undefined\n      return result.error!.issues[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":"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"}

package/lib/valibot.js.map

@@ -1 +1 @@
-{"version":3,"file":"valibot.js","names":[],"sources":["../src/utils.ts","../src/valibot.ts"],"sourcesContent":["import type { ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\nimport { issuesToRecord } from \"./utils\"\n\n/**\n * Minimal Valibot-compatible interfaces so we don't require valibot as a hard dep.\n */\ninterface ValibotPathItem {\n  key: string | number\n}\n\ninterface ValibotIssue {\n  path?: ValibotPathItem[]\n  message: string\n}\n\ninterface ValibotSafeParseResult {\n  success: boolean\n  output?: unknown\n  issues?: ValibotIssue[]\n}\n\n/**\n * Any function that takes (schema, input, ...rest) and returns a parse result.\n * Valibot's safeParse/safeParseAsync have generic constraints on the schema\n * parameter that can't be expressed without importing Valibot types. We accept\n * any callable and cast internally.\n */\n// biome-ignore lint/complexity/noBannedTypes: must accept any valibot parse function\ntype GenericSafeParseFn = Function\n\nfunction valibotIssuesToGeneric(issues: ValibotIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path?.map((p) => String(p.key)).join(\".\") ?? \"\",\n    message: issue.message,\n  }))\n}\n\ntype InternalParseFn = (\n  schema: unknown,\n  input: unknown,\n) => ValibotSafeParseResult | Promise<ValibotSafeParseResult>\n\n/**\n * Create a form-level schema validator from a Valibot schema.\n *\n * Valibot uses standalone functions rather than methods, so you must pass\n * the `safeParseAsync` (or `safeParse`) function from valibot.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotSchema } from '@pyreon/validation/valibot'\n *\n * const schema = v.object({\n *   email: v.pipe(v.string(), v.email()),\n *   password: v.pipe(v.string(), v.minLength(8)),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: valibotSchema(schema, v.safeParseAsync),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotSchema<TValues extends Record<string, unknown>>(\n  schema: unknown,\n  safeParseFn: GenericSafeParseFn,\n): SchemaValidateFn<TValues> {\n  const parse = safeParseFn as InternalParseFn\n  return async (values: TValues) => {\n    try {\n      const result = await parse(schema, values)\n      if (result.success) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(valibotIssuesToGeneric(result.issues ?? []))\n    } catch (err) {\n      return {\n        \"\": err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Valibot schema.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotField } from '@pyreon/validation/valibot'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotField<T>(schema: unknown, safeParseFn: GenericSafeParseFn): ValidateFn<T> {\n  const parse = safeParseFn as InternalParseFn\n  return async (value: T) => {\n    try {\n      const result = await parse(schema, value)\n      if (result.success) return undefined\n      return result.issues?.[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":";;;;;;AAQA,SAAgB,eACd,QACiD;CACjD,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,MAAM,MAAM;AAElB,MAAI,OAAO,SAAS,OAClB,QAAO,OAAO,MAAM;;AAGxB,QAAO;;;;;ACYT,SAAS,uBAAuB,QAA2C;AACzE,QAAO,OAAO,KAAK,WAAW;EAC5B,MAAM,MAAM,MAAM,KAAK,MAAM,OAAO,EAAE,IAAI,CAAC,CAAC,KAAK,IAAI,IAAI;EACzD,SAAS,MAAM;EAChB,EAAE;;;;;;;;;;;;;;;;;;;;;;;AA6BL,SAAgB,cACd,QACA,aAC2B;CAC3B,MAAM,QAAQ;AACd,QAAO,OAAO,WAAoB;AAChC,MAAI;GACF,MAAM,SAAS,MAAM,MAAM,QAAQ,OAAO;AAC1C,OAAI,OAAO,QAAS,QAAO,EAAE;AAC7B,UAAO,eAAwB,uBAAuB,OAAO,UAAU,EAAE,CAAC,CAAC;WACpE,KAAK;AACZ,UAAO,EACL,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACrD;;;;;;;;;;;;;;;;;;;AAoBP,SAAgB,aAAgB,QAAiB,aAAgD;CAC/F,MAAM,QAAQ;AACd,QAAO,OAAO,UAAa;AACzB,MAAI;GACF,MAAM,SAAS,MAAM,MAAM,QAAQ,MAAM;AACzC,OAAI,OAAO,QAAS,QAAO;AAC3B,UAAO,OAAO,SAAS,IAAI;WACpB,KAAK;AACZ,UAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI"}
+{"version":3,"file":"valibot.js","names":[],"sources":["../src/utils.ts","../src/valibot.ts"],"sourcesContent":["import type { ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal Valibot-compatible interfaces so we don't require valibot as a hard dep.\n */\ninterface ValibotPathItem {\n  key: string | number\n}\n\ninterface ValibotIssue {\n  path?: ValibotPathItem[]\n  message: string\n}\n\ninterface ValibotSafeParseResult {\n  success: boolean\n  output?: unknown\n  issues?: ValibotIssue[]\n}\n\n/**\n * Any function that takes (schema, input, ...rest) and returns a parse result.\n * Valibot's safeParse/safeParseAsync have generic constraints on the schema\n * parameter that can't be expressed without importing Valibot types. We accept\n * any callable and cast internally.\n */\n// biome-ignore lint/complexity/noBannedTypes: must accept any valibot parse function\ntype GenericSafeParseFn = Function\n\nfunction valibotIssuesToGeneric(issues: ValibotIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path?.map((p) => String(p.key)).join('.') ?? '',\n    message: issue.message,\n  }))\n}\n\ntype InternalParseFn = (\n  schema: unknown,\n  input: unknown,\n) => ValibotSafeParseResult | Promise<ValibotSafeParseResult>\n\n/**\n * Create a form-level schema validator from a Valibot schema.\n *\n * Valibot uses standalone functions rather than methods, so you must pass\n * the `safeParseAsync` (or `safeParse`) function from valibot.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotSchema } from '@pyreon/validation/valibot'\n *\n * const schema = v.object({\n *   email: v.pipe(v.string(), v.email()),\n *   password: v.pipe(v.string(), v.minLength(8)),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: valibotSchema(schema, v.safeParseAsync),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotSchema<TValues extends Record<string, unknown>>(\n  schema: unknown,\n  safeParseFn: GenericSafeParseFn,\n): SchemaValidateFn<TValues> {\n  const parse = safeParseFn as InternalParseFn\n  return async (values: TValues) => {\n    try {\n      const result = await parse(schema, values)\n      if (result.success) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(valibotIssuesToGeneric(result.issues ?? []))\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Valibot schema.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotField } from '@pyreon/validation/valibot'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotField<T>(schema: unknown, safeParseFn: GenericSafeParseFn): ValidateFn<T> {\n  const parse = safeParseFn as InternalParseFn\n  return async (value: T) => {\n    try {\n      const result = await parse(schema, value)\n      if (result.success) return undefined\n      return result.issues?.[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":";;;;;;AAQA,SAAgB,eACd,QACiD;CACjD,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,MAAM,MAAM;AAElB,MAAI,OAAO,SAAS,OAClB,QAAO,OAAO,MAAM;;AAGxB,QAAO;;;;;ACYT,SAAS,uBAAuB,QAA2C;AACzE,QAAO,OAAO,KAAK,WAAW;EAC5B,MAAM,MAAM,MAAM,KAAK,MAAM,OAAO,EAAE,IAAI,CAAC,CAAC,KAAK,IAAI,IAAI;EACzD,SAAS,MAAM;EAChB,EAAE;;;;;;;;;;;;;;;;;;;;;;;AA6BL,SAAgB,cACd,QACA,aAC2B;CAC3B,MAAM,QAAQ;AACd,QAAO,OAAO,WAAoB;AAChC,MAAI;GACF,MAAM,SAAS,MAAM,MAAM,QAAQ,OAAO;AAC1C,OAAI,OAAO,QAAS,QAAO,EAAE;AAC7B,UAAO,eAAwB,uBAAuB,OAAO,UAAU,EAAE,CAAC,CAAC;WACpE,KAAK;AACZ,UAAO,EACL,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACrD;;;;;;;;;;;;;;;;;;;AAoBP,SAAgB,aAAgB,QAAiB,aAAgD;CAC/F,MAAM,QAAQ;AACd,QAAO,OAAO,UAAa;AACzB,MAAI;GACF,MAAM,SAAS,MAAM,MAAM,QAAQ,MAAM;AACzC,OAAI,OAAO,QAAS,QAAO;AAC3B,UAAO,OAAO,SAAS,IAAI;WACpB,KAAK;AACZ,UAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI"}

package/lib/zod.js.map

@@ -1 +1 @@
-{"version":3,"file":"zod.js","names":[],"sources":["../src/utils.ts","../src/zod.ts"],"sourcesContent":["import type { ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\nimport { issuesToRecord } from \"./utils\"\n\n/**\n * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.\n * These match Zod v3's public API surface.\n */\ninterface ZodIssue {\n  path: PropertyKey[]\n  message: string\n}\n\n/**\n * Duck-typed Zod schema interface — works with both Zod v3 and v4.\n * Inlines the result shape to avoid version-specific type mismatches.\n */\ninterface ZodSchema<T = unknown> {\n  safeParse(data: unknown): {\n    success: boolean\n    data?: T\n    error?: { issues: ZodIssue[] }\n  }\n  safeParseAsync(\n    data: unknown,\n  ): Promise<{ success: boolean; data?: T; error?: { issues: ZodIssue[] } }>\n}\n\nfunction zodIssuesToGeneric(issues: ZodIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path.map(String).join(\".\"),\n    message: issue.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from a Zod schema.\n * Supports both sync and async Zod schemas (uses `safeParseAsync`).\n *\n * @example\n * import { z } from 'zod'\n * import { zodSchema } from '@pyreon/validation/zod'\n *\n * const schema = z.object({\n *   email: z.string().email(),\n *   password: z.string().min(8),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: zodSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodSchema<TValues extends Record<string, unknown>>(\n  schema: ZodSchema<TValues>,\n): SchemaValidateFn<TValues> {\n  return async (values: TValues) => {\n    try {\n      const result = await schema.safeParseAsync(values)\n      if (result.success) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(zodIssuesToGeneric(result.error!.issues))\n    } catch (err) {\n      return {\n        \"\": err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Zod schema.\n * Supports both sync and async Zod refinements.\n *\n * @example\n * import { z } from 'zod'\n * import { zodField } from '@pyreon/validation/zod'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: zodField(z.string().email('Invalid email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodField<T>(schema: ZodSchema<T>): ValidateFn<T> {\n  return async (value: T) => {\n    try {\n      const result = await schema.safeParseAsync(value)\n      if (result.success) return undefined\n      return result.error!.issues[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":";;;;;;AAQA,SAAgB,eACd,QACiD;CACjD,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,MAAM,MAAM;AAElB,MAAI,OAAO,SAAS,OAClB,QAAO,OAAO,MAAM;;AAGxB,QAAO;;;;;ACST,SAAS,mBAAmB,QAAuC;AACjE,QAAO,OAAO,KAAK,WAAW;EAC5B,MAAM,MAAM,KAAK,IAAI,OAAO,CAAC,KAAK,IAAI;EACtC,SAAS,MAAM;EAChB,EAAE;;;;;;;;;;;;;;;;;;;;;AAsBL,SAAgB,UACd,QAC2B;AAC3B,QAAO,OAAO,WAAoB;AAChC,MAAI;GACF,MAAM,SAAS,MAAM,OAAO,eAAe,OAAO;AAClD,OAAI,OAAO,QAAS,QAAO,EAAE;AAC7B,UAAO,eAAwB,mBAAmB,OAAO,MAAO,OAAO,CAAC;WACjE,KAAK;AACZ,UAAO,EACL,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACrD;;;;;;;;;;;;;;;;;;;;AAqBP,SAAgB,SAAY,QAAqC;AAC/D,QAAO,OAAO,UAAa;AACzB,MAAI;GACF,MAAM,SAAS,MAAM,OAAO,eAAe,MAAM;AACjD,OAAI,OAAO,QAAS,QAAO;AAC3B,UAAO,OAAO,MAAO,OAAO,IAAI;WACzB,KAAK;AACZ,UAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI"}
+{"version":3,"file":"zod.js","names":[],"sources":["../src/utils.ts","../src/zod.ts"],"sourcesContent":["import type { ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.\n * These match Zod v3's public API surface.\n */\ninterface ZodIssue {\n  path: PropertyKey[]\n  message: string\n}\n\n/**\n * Duck-typed Zod schema interface — works with both Zod v3 and v4.\n * Inlines the result shape to avoid version-specific type mismatches.\n */\ninterface ZodSchema<T = unknown> {\n  safeParse(data: unknown): {\n    success: boolean\n    data?: T\n    error?: { issues: ZodIssue[] }\n  }\n  safeParseAsync(\n    data: unknown,\n  ): Promise<{ success: boolean; data?: T; error?: { issues: ZodIssue[] } }>\n}\n\nfunction zodIssuesToGeneric(issues: ZodIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path.map(String).join('.'),\n    message: issue.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from a Zod schema.\n * Supports both sync and async Zod schemas (uses `safeParseAsync`).\n *\n * @example\n * import { z } from 'zod'\n * import { zodSchema } from '@pyreon/validation/zod'\n *\n * const schema = z.object({\n *   email: z.string().email(),\n *   password: z.string().min(8),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: zodSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodSchema<TValues extends Record<string, unknown>>(\n  schema: ZodSchema<TValues>,\n): SchemaValidateFn<TValues> {\n  return async (values: TValues) => {\n    try {\n      const result = await schema.safeParseAsync(values)\n      if (result.success) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(zodIssuesToGeneric(result.error!.issues))\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Zod schema.\n * Supports both sync and async Zod refinements.\n *\n * @example\n * import { z } from 'zod'\n * import { zodField } from '@pyreon/validation/zod'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: zodField(z.string().email('Invalid email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodField<T>(schema: ZodSchema<T>): ValidateFn<T> {\n  return async (value: T) => {\n    try {\n      const result = await schema.safeParseAsync(value)\n      if (result.success) return undefined\n      return result.error!.issues[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":";;;;;;AAQA,SAAgB,eACd,QACiD;CACjD,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,MAAM,MAAM;AAElB,MAAI,OAAO,SAAS,OAClB,QAAO,OAAO,MAAM;;AAGxB,QAAO;;;;;ACST,SAAS,mBAAmB,QAAuC;AACjE,QAAO,OAAO,KAAK,WAAW;EAC5B,MAAM,MAAM,KAAK,IAAI,OAAO,CAAC,KAAK,IAAI;EACtC,SAAS,MAAM;EAChB,EAAE;;;;;;;;;;;;;;;;;;;;;AAsBL,SAAgB,UACd,QAC2B;AAC3B,QAAO,OAAO,WAAoB;AAChC,MAAI;GACF,MAAM,SAAS,MAAM,OAAO,eAAe,OAAO;AAClD,OAAI,OAAO,QAAS,QAAO,EAAE;AAC7B,UAAO,eAAwB,mBAAmB,OAAO,MAAO,OAAO,CAAC;WACjE,KAAK;AACZ,UAAO,EACL,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACrD;;;;;;;;;;;;;;;;;;;;AAqBP,SAAgB,SAAY,QAAqC;AAC/D,QAAO,OAAO,UAAa;AACzB,MAAI;GACF,MAAM,SAAS,MAAM,OAAO,eAAe,MAAM;AACjD,OAAI,OAAO,QAAS,QAAO;AAC3B,UAAO,OAAO,MAAO,OAAO,IAAI;WACzB,KAAK;AACZ,UAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI"}

package/package.json

@@ -1,20 +1,17 @@
 {
   "name": "@pyreon/validation",
-  "version": "0.11.5",
+  "version": "0.11.6",
   "description": "Schema validation adapters for Pyreon forms (Zod, Valibot, ArkType)",
+  "homepage": "https://github.com/pyreon/pyreon/tree/main/packages/validation#readme",
+  "bugs": {
+    "url": "https://github.com/pyreon/pyreon/issues"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/pyreon/pyreon.git",
     "directory": "packages/fundamentals/validation"
   },
-  "homepage": "https://github.com/pyreon/pyreon/tree/main/packages/validation#readme",
-  "bugs": {
-    "url": "https://github.com/pyreon/pyreon/issues"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
   "files": [
     "lib",
     "src",
@@ -48,15 +45,28 @@
       "types": "./lib/types/arktype.d.ts"
     }
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "vl_rolldown_build",
     "dev": "vl_rolldown_build-watch",
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
-    "lint": "biome check ."
+    "lint": "oxlint ."
+  },
+  "devDependencies": {
+    "@happy-dom/global-registrator": "^20.8.3",
+    "@pyreon/core": "^0.11.6",
+    "@pyreon/form": "^0.11.6",
+    "@pyreon/reactivity": "^0.11.6",
+    "@pyreon/runtime-dom": "^0.11.6",
+    "arktype": "^2.2.0",
+    "valibot": "^1.2.0",
+    "zod": "^4.3.6"
   },
   "peerDependencies": {
-    "@pyreon/form": "^0.11.5"
+    "@pyreon/form": "^0.11.6"
   },
   "peerDependenciesMeta": {
     "zod": {
@@ -68,15 +78,5 @@
     "arktype": {
       "optional": true
     }
-  },
-  "devDependencies": {
-    "@happy-dom/global-registrator": "^20.8.3",
-    "@pyreon/core": "^0.11.5",
-    "@pyreon/form": "^0.11.5",
-    "@pyreon/reactivity": "^0.11.5",
-    "@pyreon/runtime-dom": "^0.11.5",
-    "zod": "^4.3.6",
-    "valibot": "^1.2.0",
-    "arktype": "^2.2.0"
   }
 }

package/src/arktype.ts

@@ -1,6 +1,6 @@
-import type { SchemaValidateFn, ValidateFn, ValidationError } from "@pyreon/form"
-import type { ValidationIssue } from "./types"
-import { issuesToRecord } from "./utils"
+import type { SchemaValidateFn, ValidateFn, ValidationError } from '@pyreon/form'
+import type { ValidationIssue } from './types'
+import { issuesToRecord } from './utils'
 
 /**
  * Minimal ArkType-compatible interfaces so we don't require arktype as a hard dep.
@@ -21,12 +21,12 @@ interface ArkErrors extends Array<ArkError> {
 type ArkTypeCallable = (data: unknown) => unknown
 
 function isArkErrors(result: unknown): result is ArkErrors {
-  return Array.isArray(result) && "summary" in (result as object)
+  return Array.isArray(result) && 'summary' in (result as object)
 }
 
 function arkIssuesToGeneric(errors: ArkErrors): ValidationIssue[] {
   return errors.map((err) => ({
-    path: err.path.map(String).join("."),
+    path: err.path.map(String).join('.'),
     message: err.message,
   }))
 }
@@ -62,7 +62,7 @@ export function arktypeSchema<TValues extends Record<string, unknown>>(
       return issuesToRecord<TValues>(arkIssuesToGeneric(result))
     } catch (err) {
       return {
-        "": err instanceof Error ? err.message : String(err),
+        '': err instanceof Error ? err.message : String(err),
       } as Partial<Record<keyof TValues, ValidationError>>
     }
   }

package/src/index.ts

@@ -1,4 +1,4 @@
-export { arktypeField, arktypeSchema } from "./arktype"
+export { arktypeField, arktypeSchema } from './arktype'
 export type {
   FieldAdapter,
   SchemaAdapter,
@@ -6,7 +6,7 @@ export type {
   ValidateFn,
   ValidationError,
   ValidationIssue,
-} from "./types"
-export { issuesToRecord } from "./utils"
-export { valibotField, valibotSchema } from "./valibot"
-export { zodField, zodSchema } from "./zod"
+} from './types'
+export { issuesToRecord } from './utils'
+export { valibotField, valibotSchema } from './valibot'
+export { zodField, zodSchema } from './zod'

package/src/tests/setup.ts

@@ -1 +1 @@
-import "@happy-dom/global-registrator"
+import '@happy-dom/global-registrator'

package/src/tests/validation.test.tsx

@@ -1,12 +1,12 @@
-import { useForm } from "@pyreon/form"
-import { mount } from "@pyreon/runtime-dom"
-import { type } from "arktype"
-import * as v from "valibot"
-import { z } from "zod"
-import { arktypeField, arktypeSchema } from "../arktype"
-import { issuesToRecord } from "../utils"
-import { valibotField, valibotSchema } from "../valibot"
-import { zodField, zodSchema } from "../zod"
+import { useForm } from '@pyreon/form'
+import { mount } from '@pyreon/runtime-dom'
+import { type } from 'arktype'
+import * as v from 'valibot'
+import { z } from 'zod'
+import { arktypeField, arktypeSchema } from '../arktype'
+import { issuesToRecord } from '../utils'
+import { valibotField, valibotSchema } from '../valibot'
+import { zodField, zodSchema } from '../zod'
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -17,7 +17,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
@@ -38,85 +38,85 @@ function mountWith<T>(fn: () => T): { result: T; unmount: () => void } {
 
 // ─── issuesToRecord ──────────────────────────────────────────────────────────
 
-describe("issuesToRecord", () => {
-  it("converts issues to a flat record", () => {
+describe('issuesToRecord', () => {
+  it('converts issues to a flat record', () => {
     const result = issuesToRecord([
-      { path: "email", message: "Required" },
-      { path: "password", message: "Too short" },
+      { path: 'email', message: 'Required' },
+      { path: 'password', message: 'Too short' },
     ])
-    expect(result).toEqual({ email: "Required", password: "Too short" })
+    expect(result).toEqual({ email: 'Required', password: 'Too short' })
   })
 
-  it("first error per field wins", () => {
+  it('first error per field wins', () => {
     const result = issuesToRecord([
-      { path: "email", message: "Required" },
-      { path: "email", message: "Invalid format" },
+      { path: 'email', message: 'Required' },
+      { path: 'email', message: 'Invalid format' },
     ])
-    expect(result).toEqual({ email: "Required" })
+    expect(result).toEqual({ email: 'Required' })
   })
 
-  it("returns empty object for no issues", () => {
+  it('returns empty object for no issues', () => {
     expect(issuesToRecord([])).toEqual({})
   })
 })
 
 // ─── Zod Adapter ─────────────────────────────────────────────────────────────
 
-describe("zodSchema", () => {
+describe('zodSchema', () => {
   const schema = z.object({
-    email: z.string().email("Invalid email"),
-    password: z.string().min(8, "Min 8 chars"),
+    email: z.string().email('Invalid email'),
+    password: z.string().min(8, 'Min 8 chars'),
   })
 
-  it("returns empty record for valid data", async () => {
+  it('returns empty record for valid data', async () => {
     const validate = zodSchema(schema)
-    const result = await validate({ email: "a@b.com", password: "12345678" })
+    const result = await validate({ email: 'a@b.com', password: '12345678' })
     expect(result).toEqual({})
   })
 
-  it("returns field errors for invalid data", async () => {
+  it('returns field errors for invalid data', async () => {
     const validate = zodSchema(schema)
-    const result = await validate({ email: "bad", password: "short" })
-    expect(result.email).toBe("Invalid email")
-    expect(result.password).toBe("Min 8 chars")
+    const result = await validate({ email: 'bad', password: 'short' })
+    expect(result.email).toBe('Invalid email')
+    expect(result.password).toBe('Min 8 chars')
   })
 
-  it("returns error for single invalid field", async () => {
+  it('returns error for single invalid field', async () => {
     const validate = zodSchema(schema)
-    const result = await validate({ email: "a@b.com", password: "short" })
+    const result = await validate({ email: 'a@b.com', password: 'short' })
     expect(result.email).toBeUndefined()
-    expect(result.password).toBe("Min 8 chars")
+    expect(result.password).toBe('Min 8 chars')
   })
 })
 
-describe("zodField", () => {
-  it("returns undefined for valid value", async () => {
-    const validate = zodField(z.string().email("Invalid email"))
-    expect(await validate("a@b.com", {})).toBeUndefined()
+describe('zodField', () => {
+  it('returns undefined for valid value', async () => {
+    const validate = zodField(z.string().email('Invalid email'))
+    expect(await validate('a@b.com', {})).toBeUndefined()
   })
 
-  it("returns error message for invalid value", async () => {
-    const validate = zodField(z.string().email("Invalid email"))
-    expect(await validate("bad", {})).toBe("Invalid email")
+  it('returns error message for invalid value', async () => {
+    const validate = zodField(z.string().email('Invalid email'))
+    expect(await validate('bad', {})).toBe('Invalid email')
   })
 
-  it("works with number schemas", async () => {
-    const validate = zodField(z.number().min(0, "Must be positive"))
-    expect(await validate(-1, {})).toBe("Must be positive")
+  it('works with number schemas', async () => {
+    const validate = zodField(z.number().min(0, 'Must be positive'))
+    expect(await validate(-1, {})).toBe('Must be positive')
     expect(await validate(5, {})).toBeUndefined()
   })
 })
 
-describe("zod + useForm integration", () => {
-  it("validates form with zod schema", async () => {
+describe('zod + useForm integration', () => {
+  it('validates form with zod schema', async () => {
     const schema = z.object({
-      email: z.string().email("Invalid email"),
-      password: z.string().min(8, "Min 8 chars"),
+      email: z.string().email('Invalid email'),
+      password: z.string().min(8, 'Min 8 chars'),
     })
 
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { email: "", password: "" },
+        initialValues: { email: '', password: '' },
         schema: zodSchema(schema),
         onSubmit: () => {
           /* noop */
@@ -126,18 +126,18 @@ describe("zod + useForm integration", () => {
 
     const valid = await form.validate()
     expect(valid).toBe(false)
-    expect(form.fields.email.error()).toBe("Invalid email")
-    expect(form.fields.password.error()).toBe("Min 8 chars")
+    expect(form.fields.email.error()).toBe('Invalid email')
+    expect(form.fields.password.error()).toBe('Min 8 chars')
     unmount()
   })
 
-  it("validates with field-level zod validators", async () => {
+  it('validates with field-level zod validators', async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { email: "", age: 0 },
+        initialValues: { email: '', age: 0 },
         validators: {
-          email: zodField(z.string().email("Invalid")),
-          age: zodField(z.number().min(18, "Must be 18+")),
+          email: zodField(z.string().email('Invalid')),
+          age: zodField(z.number().min(18, 'Must be 18+')),
         },
         onSubmit: () => {
           /* noop */
@@ -147,52 +147,52 @@ describe("zod + useForm integration", () => {
 
     const valid = await form.validate()
     expect(valid).toBe(false)
-    expect(form.fields.email.error()).toBe("Invalid")
-    expect(form.fields.age.error()).toBe("Must be 18+")
+    expect(form.fields.email.error()).toBe('Invalid')
+    expect(form.fields.age.error()).toBe('Must be 18+')
     unmount()
   })
 })
 
 // ─── Valibot Adapter ─────────────────────────────────────────────────────────
 
-describe("valibotSchema", () => {
+describe('valibotSchema', () => {
   const schema = v.object({
-    email: v.pipe(v.string(), v.email("Invalid email")),
-    password: v.pipe(v.string(), v.minLength(8, "Min 8 chars")),
+    email: v.pipe(v.string(), v.email('Invalid email')),
+    password: v.pipe(v.string(), v.minLength(8, 'Min 8 chars')),
   })
 
-  it("returns empty record for valid data", async () => {
+  it('returns empty record for valid data', async () => {
     const validate = valibotSchema(schema, v.safeParseAsync)
-    const result = await validate({ email: "a@b.com", password: "12345678" })
+    const result = await validate({ email: 'a@b.com', password: '12345678' })
     expect(result).toEqual({})
   })
 
-  it("returns field errors for invalid data", async () => {
+  it('returns field errors for invalid data', async () => {
     const validate = valibotSchema(schema, v.safeParseAsync)
-    const result = await validate({ email: "bad", password: "short" })
-    expect(result.email).toBe("Invalid email")
-    expect(result.password).toBe("Min 8 chars")
+    const result = await validate({ email: 'bad', password: 'short' })
+    expect(result.email).toBe('Invalid email')
+    expect(result.password).toBe('Min 8 chars')
   })
 
-  it("works with sync safeParse", async () => {
+  it('works with sync safeParse', async () => {
     const validate = valibotSchema(schema, v.safeParse)
-    const result = await validate({ email: "bad", password: "short" })
-    expect(result.email).toBe("Invalid email")
+    const result = await validate({ email: 'bad', password: 'short' })
+    expect(result.email).toBe('Invalid email')
   })
 
-  it("handles issues without path", async () => {
+  it('handles issues without path', async () => {
     // Simulate a safeParse function that returns issues without path
     const mockSafeParse = async () => ({
       success: false as const,
-      issues: [{ message: "Schema-level error" }],
+      issues: [{ message: 'Schema-level error' }],
     })
     const validate = valibotSchema({}, mockSafeParse)
     const result = await validate({})
     // Issue without path maps to empty string key
-    expect(result["" as keyof typeof result]).toBe("Schema-level error")
+    expect(result['' as keyof typeof result]).toBe('Schema-level error')
   })
 
-  it("handles result with undefined issues array", async () => {
+  it('handles result with undefined issues array', async () => {
     const mockSafeParse = async () => ({
       success: false as const,
       // issues is undefined
@@ -203,36 +203,36 @@ describe("valibotSchema", () => {
   })
 })
 
-describe("valibotField", () => {
-  it("returns undefined for valid value", async () => {
-    const validate = valibotField(v.pipe(v.string(), v.email("Invalid email")), v.safeParseAsync)
-    expect(await validate("a@b.com", {})).toBeUndefined()
+describe('valibotField', () => {
+  it('returns undefined for valid value', async () => {
+    const validate = valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync)
+    expect(await validate('a@b.com', {})).toBeUndefined()
   })
 
-  it("returns error message for invalid value", async () => {
-    const validate = valibotField(v.pipe(v.string(), v.email("Invalid email")), v.safeParseAsync)
-    expect(await validate("bad", {})).toBe("Invalid email")
+  it('returns error message for invalid value', async () => {
+    const validate = valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync)
+    expect(await validate('bad', {})).toBe('Invalid email')
   })
 
-  it("handles result with undefined issues", async () => {
+  it('handles result with undefined issues', async () => {
     const mockSafeParse = async () => ({
       success: false as const,
     })
     const validate = valibotField({}, mockSafeParse)
-    expect(await validate("x", {})).toBeUndefined()
+    expect(await validate('x', {})).toBeUndefined()
   })
 })
 
-describe("valibot + useForm integration", () => {
-  it("validates form with valibot schema", async () => {
+describe('valibot + useForm integration', () => {
+  it('validates form with valibot schema', async () => {
     const schema = v.object({
-      email: v.pipe(v.string(), v.email("Invalid email")),
-      password: v.pipe(v.string(), v.minLength(8, "Min 8 chars")),
+      email: v.pipe(v.string(), v.email('Invalid email')),
+      password: v.pipe(v.string(), v.minLength(8, 'Min 8 chars')),
     })
 
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { email: "", password: "" },
+        initialValues: { email: '', password: '' },
         schema: valibotSchema(schema, v.safeParseAsync),
         onSubmit: () => {
           /* noop */
@@ -242,198 +242,198 @@ describe("valibot + useForm integration", () => {
 
     const valid = await form.validate()
     expect(valid).toBe(false)
-    expect(form.fields.email.error()).toBe("Invalid email")
-    expect(form.fields.password.error()).toBe("Min 8 chars")
+    expect(form.fields.email.error()).toBe('Invalid email')
+    expect(form.fields.password.error()).toBe('Min 8 chars')
     unmount()
   })
 })
 
 // ─── ArkType Adapter ─────────────────────────────────────────────────────────
 
-describe("arktypeSchema", () => {
+describe('arktypeSchema', () => {
   const schema = type({
-    email: "string.email",
-    password: "string >= 8",
+    email: 'string.email',
+    password: 'string >= 8',
   })
 
-  it("returns empty record for valid data", async () => {
+  it('returns empty record for valid data', async () => {
     const validate = arktypeSchema(schema)
-    const result = await validate({ email: "a@b.com", password: "12345678" })
+    const result = await validate({ email: 'a@b.com', password: '12345678' })
     expect(result).toEqual({})
   })
 
-  it("returns field errors for invalid data", async () => {
+  it('returns field errors for invalid data', async () => {
     const validate = arktypeSchema(schema)
-    const result = await validate({ email: "bad", password: "short" })
+    const result = await validate({ email: 'bad', password: 'short' })
     expect(result.email).toBeDefined()
     expect(result.password).toBeDefined()
   })
 })
 
-describe("arktypeField", () => {
-  it("returns undefined for valid value", async () => {
-    const validate = arktypeField(type("string.email"))
-    expect(await validate("a@b.com", {})).toBeUndefined()
+describe('arktypeField', () => {
+  it('returns undefined for valid value', async () => {
+    const validate = arktypeField(type('string.email'))
+    expect(await validate('a@b.com', {})).toBeUndefined()
   })
 
-  it("returns error message for invalid value", async () => {
-    const validate = arktypeField(type("string.email"))
-    const result = await validate("bad", {})
+  it('returns error message for invalid value', async () => {
+    const validate = arktypeField(type('string.email'))
+    const result = await validate('bad', {})
     expect(result).toBeDefined()
-    expect(typeof result).toBe("string")
+    expect(typeof result).toBe('string')
   })
 })
 
-describe("zodSchema catch branch", () => {
-  it("captures Error when safeParseAsync throws an Error", async () => {
+describe('zodSchema catch branch', () => {
+  it('captures Error when safeParseAsync throws an Error', async () => {
     const throwingSchema = {
       safeParseAsync: () => {
-        throw new Error("Zod schema exploded")
+        throw new Error('Zod schema exploded')
       },
       safeParse: () => {
-        throw new Error("Zod schema exploded")
+        throw new Error('Zod schema exploded')
       },
     }
     const validate = zodSchema(throwingSchema as any)
-    const result = await validate({ email: "", password: "" })
-    expect(result["" as keyof typeof result]).toBe("Zod schema exploded")
+    const result = await validate({ email: '', password: '' })
+    expect(result['' as keyof typeof result]).toBe('Zod schema exploded')
   })
 
-  it("captures non-Error when safeParseAsync throws a string", async () => {
+  it('captures non-Error when safeParseAsync throws a string', async () => {
     const throwingSchema = {
       safeParseAsync: () => {
-        throw "raw string error"
+        throw 'raw string error'
       },
       safeParse: () => {
-        throw "raw string error"
+        throw 'raw string error'
       },
     }
     const validate = zodSchema(throwingSchema as any)
-    const result = await validate({ email: "", password: "" })
-    expect(result["" as keyof typeof result]).toBe("raw string error")
+    const result = await validate({ email: '', password: '' })
+    expect(result['' as keyof typeof result]).toBe('raw string error')
   })
 })
 
-describe("zodField catch branch", () => {
-  it("captures Error when safeParseAsync throws an Error", async () => {
+describe('zodField catch branch', () => {
+  it('captures Error when safeParseAsync throws an Error', async () => {
     const throwingSchema = {
       safeParseAsync: () => {
-        throw new Error("Zod field exploded")
+        throw new Error('Zod field exploded')
       },
       safeParse: () => {
-        throw new Error("Zod field exploded")
+        throw new Error('Zod field exploded')
       },
     }
     const validate = zodField(throwingSchema as any)
-    const result = await validate("test", {})
-    expect(result).toBe("Zod field exploded")
+    const result = await validate('test', {})
+    expect(result).toBe('Zod field exploded')
   })
 
-  it("captures non-Error when safeParseAsync throws a string", async () => {
+  it('captures non-Error when safeParseAsync throws a string', async () => {
     const throwingSchema = {
       safeParseAsync: () => {
-        throw "raw zod field error"
+        throw 'raw zod field error'
       },
       safeParse: () => {
-        throw "raw zod field error"
+        throw 'raw zod field error'
       },
     }
     const validate = zodField(throwingSchema as any)
-    const result = await validate("test", {})
-    expect(result).toBe("raw zod field error")
+    const result = await validate('test', {})
+    expect(result).toBe('raw zod field error')
   })
 })
 
-describe("valibotSchema catch branch", () => {
-  it("captures Error when safeParse function throws an Error", async () => {
+describe('valibotSchema catch branch', () => {
+  it('captures Error when safeParse function throws an Error', async () => {
     const throwingParse = () => {
-      throw new Error("Valibot schema exploded")
+      throw new Error('Valibot schema exploded')
     }
     const validate = valibotSchema({}, throwingParse)
-    const result = await validate({ email: "", password: "" })
-    expect(result["" as keyof typeof result]).toBe("Valibot schema exploded")
+    const result = await validate({ email: '', password: '' })
+    expect(result['' as keyof typeof result]).toBe('Valibot schema exploded')
   })
 
-  it("captures non-Error when safeParse function throws a string", async () => {
+  it('captures non-Error when safeParse function throws a string', async () => {
     const throwingParse = () => {
-      throw "raw valibot schema error"
+      throw 'raw valibot schema error'
     }
     const validate = valibotSchema({}, throwingParse)
-    const result = await validate({ email: "", password: "" })
-    expect(result["" as keyof typeof result]).toBe("raw valibot schema error")
+    const result = await validate({ email: '', password: '' })
+    expect(result['' as keyof typeof result]).toBe('raw valibot schema error')
   })
 })
 
-describe("valibotField catch branch", () => {
-  it("captures Error when safeParse function throws an Error", async () => {
+describe('valibotField catch branch', () => {
+  it('captures Error when safeParse function throws an Error', async () => {
     const throwingParse = () => {
-      throw new Error("Valibot field exploded")
+      throw new Error('Valibot field exploded')
     }
     const validate = valibotField({}, throwingParse)
-    const result = await validate("test", {})
-    expect(result).toBe("Valibot field exploded")
+    const result = await validate('test', {})
+    expect(result).toBe('Valibot field exploded')
   })
 
-  it("captures non-Error when safeParse function throws a string", async () => {
+  it('captures non-Error when safeParse function throws a string', async () => {
     const throwingParse = () => {
-      throw "raw valibot field error"
+      throw 'raw valibot field error'
     }
     const validate = valibotField({}, throwingParse)
-    const result = await validate("test", {})
-    expect(result).toBe("raw valibot field error")
+    const result = await validate('test', {})
+    expect(result).toBe('raw valibot field error')
   })
 })
 
-describe("arktypeSchema catch branch", () => {
-  it("captures Error when schema function throws an Error", async () => {
+describe('arktypeSchema catch branch', () => {
+  it('captures Error when schema function throws an Error', async () => {
     const throwingSchema = () => {
-      throw new Error("ArkType schema exploded")
+      throw new Error('ArkType schema exploded')
     }
     const validate = arktypeSchema(throwingSchema)
-    const result = await validate({ email: "", password: "" })
-    expect(result["" as keyof typeof result]).toBe("ArkType schema exploded")
+    const result = await validate({ email: '', password: '' })
+    expect(result['' as keyof typeof result]).toBe('ArkType schema exploded')
   })
 
-  it("captures non-Error when schema function throws a string", async () => {
+  it('captures non-Error when schema function throws a string', async () => {
     const throwingSchema = () => {
-      throw "raw arktype schema error"
+      throw 'raw arktype schema error'
     }
     const validate = arktypeSchema(throwingSchema)
-    const result = await validate({ email: "", password: "" })
-    expect(result["" as keyof typeof result]).toBe("raw arktype schema error")
+    const result = await validate({ email: '', password: '' })
+    expect(result['' as keyof typeof result]).toBe('raw arktype schema error')
   })
 })
 
-describe("arktypeField catch branch", () => {
-  it("captures Error when schema function throws an Error", async () => {
+describe('arktypeField catch branch', () => {
+  it('captures Error when schema function throws an Error', async () => {
     const throwingSchema = () => {
-      throw new Error("ArkType field exploded")
+      throw new Error('ArkType field exploded')
     }
     const validate = arktypeField(throwingSchema)
-    const result = await validate("test", {})
-    expect(result).toBe("ArkType field exploded")
+    const result = await validate('test', {})
+    expect(result).toBe('ArkType field exploded')
   })
 
-  it("captures non-Error when schema function throws a string", async () => {
+  it('captures non-Error when schema function throws a string', async () => {
     const throwingSchema = () => {
-      throw "raw arktype field error"
+      throw 'raw arktype field error'
     }
     const validate = arktypeField(throwingSchema)
-    const result = await validate("test", {})
-    expect(result).toBe("raw arktype field error")
+    const result = await validate('test', {})
+    expect(result).toBe('raw arktype field error')
   })
 })
 
-describe("arktype + useForm integration", () => {
-  it("validates form with arktype schema", async () => {
+describe('arktype + useForm integration', () => {
+  it('validates form with arktype schema', async () => {
     const schema = type({
-      email: "string.email",
-      password: "string >= 8",
+      email: 'string.email',
+      password: 'string >= 8',
     })
 
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { email: "", password: "" },
+        initialValues: { email: '', password: '' },
         schema: arktypeSchema(schema),
         onSubmit: () => {
           /* noop */

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { SchemaValidateFn, ValidateFn, ValidationError } from "@pyreon/form"
+import type { SchemaValidateFn, ValidateFn, ValidationError } from '@pyreon/form'
 
 /** Re-export form types for convenience. */
 export type { SchemaValidateFn, ValidateFn, ValidationError }

package/src/utils.ts

@@ -1,5 +1,5 @@
-import type { ValidationError } from "@pyreon/form"
-import type { ValidationIssue } from "./types"
+import type { ValidationError } from '@pyreon/form'
+import type { ValidationIssue } from './types'
 
 /**
  * Convert an array of validation issues into a flat field → error record.

package/src/valibot.ts

@@ -1,6 +1,6 @@
-import type { SchemaValidateFn, ValidateFn, ValidationError } from "@pyreon/form"
-import type { ValidationIssue } from "./types"
-import { issuesToRecord } from "./utils"
+import type { SchemaValidateFn, ValidateFn, ValidationError } from '@pyreon/form'
+import type { ValidationIssue } from './types'
+import { issuesToRecord } from './utils'
 
 /**
  * Minimal Valibot-compatible interfaces so we don't require valibot as a hard dep.
@@ -31,7 +31,7 @@ type GenericSafeParseFn = Function
 
 function valibotIssuesToGeneric(issues: ValibotIssue[]): ValidationIssue[] {
   return issues.map((issue) => ({
-    path: issue.path?.map((p) => String(p.key)).join(".") ?? "",
+    path: issue.path?.map((p) => String(p.key)).join('.') ?? '',
     message: issue.message,
   }))
 }
@@ -74,7 +74,7 @@ export function valibotSchema<TValues extends Record<string, unknown>>(
       return issuesToRecord<TValues>(valibotIssuesToGeneric(result.issues ?? []))
     } catch (err) {
       return {
-        "": err instanceof Error ? err.message : String(err),
+        '': err instanceof Error ? err.message : String(err),
       } as Partial<Record<keyof TValues, ValidationError>>
     }
   }

package/src/zod.ts

@@ -1,6 +1,6 @@
-import type { SchemaValidateFn, ValidateFn, ValidationError } from "@pyreon/form"
-import type { ValidationIssue } from "./types"
-import { issuesToRecord } from "./utils"
+import type { SchemaValidateFn, ValidateFn, ValidationError } from '@pyreon/form'
+import type { ValidationIssue } from './types'
+import { issuesToRecord } from './utils'
 
 /**
  * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.
@@ -28,7 +28,7 @@ interface ZodSchema<T = unknown> {
 
 function zodIssuesToGeneric(issues: ZodIssue[]): ValidationIssue[] {
   return issues.map((issue) => ({
-    path: issue.path.map(String).join("."),
+    path: issue.path.map(String).join('.'),
     message: issue.message,
   }))
 }
@@ -62,7 +62,7 @@ export function zodSchema<TValues extends Record<string, unknown>>(
       return issuesToRecord<TValues>(zodIssuesToGeneric(result.error!.issues))
     } catch (err) {
       return {
-        "": err instanceof Error ? err.message : String(err),
+        '': err instanceof Error ? err.message : String(err),
       } as Partial<Record<keyof TValues, ValidationError>>
     }
   }